From 9ee2cdb4c0ec3a69657009712702a89a9e3ec87c Mon Sep 17 00:00:00 2001 From: Jack He Date: Tue, 15 Aug 2023 19:04:22 -0700 Subject: [PATCH 001/123] initialize signature and test case --- src/core/api.c | 13 +++++ src/core/api.h | 8 +++ src/core/library.c | 1 + src/core/unittest/main.h | 2 + src/inc/msquic.h | 16 ++++++ src/inc/msquic.hpp | 7 +++ src/test/MsQuicTests.h | 9 ++- src/test/bin/quic_gtest.cpp | 9 +++ src/test/bin/winkernel/control.cpp | 4 ++ src/test/lib/DataTest.cpp | 92 ++++++++++++++++++++++++++++++ 10 files changed, 160 insertions(+), 1 deletion(-) diff --git a/src/core/api.c b/src/core/api.c index 7cf0b70b35..24e2a07634 100644 --- a/src/core/api.c +++ b/src/core/api.c @@ -868,6 +868,19 @@ MsQuicStreamStart( return Status; } +_IRQL_requires_max_(DISPATCH_LEVEL) +QUIC_STATUS +QUIC_API +MsQuicStreamShutdownReliable( + _In_ _Pre_defensive_ HQUIC Handle, + _In_ uint64_t ReliableSize + ) +{ + // TODO: do something with ReliableSize to ensure data gets re-trasmitted before actually shutting down. + MsQuicStreamShutdown(Handle, QUIC_STREAM_SHUTDOWN_FLAG_ABORT, 0x21); + return QUIC_STATUS_SUCCESS; +} + _IRQL_requires_max_(DISPATCH_LEVEL) QUIC_STATUS QUIC_API diff --git a/src/core/api.h b/src/core/api.h index 87c6631a04..29666da932 100644 --- a/src/core/api.h +++ b/src/core/api.h @@ -196,6 +196,14 @@ MsQuicStreamShutdown( _In_ _Pre_defensive_ QUIC_UINT62 ErrorCode ); +_IRQL_requires_max_(DISPATCH_LEVEL) +QUIC_STATUS +QUIC_API +MsQuicStreamShutdownReliable( + _In_ _Pre_defensive_ HQUIC Handle, + _In_ uint64_t ReliableSize + ); + _IRQL_requires_max_(DISPATCH_LEVEL) QUIC_STATUS QUIC_API diff --git a/src/core/library.c b/src/core/library.c index d3de6de5eb..bf44a080fd 100644 --- a/src/core/library.c +++ b/src/core/library.c @@ -1706,6 +1706,7 @@ MsQuicOpenVersion( Api->StreamOpen = MsQuicStreamOpen; Api->StreamClose = MsQuicStreamClose; Api->StreamShutdown = MsQuicStreamShutdown; + Api->StreamShutdownReliable = MsQuicStreamShutdownReliable; Api->StreamStart = MsQuicStreamStart; Api->StreamSend = MsQuicStreamSend; Api->StreamReceiveComplete = MsQuicStreamReceiveComplete; diff --git a/src/core/unittest/main.h b/src/core/unittest/main.h index 1ad53dacd6..b0c604e81e 100644 --- a/src/core/unittest/main.h +++ b/src/core/unittest/main.h @@ -87,6 +87,8 @@ std::ostream& operator << (std::ostream& o, const QUIC_FRAME_TYPE& type) { return o << "QUIC_FRAME_ACK_FREQUENCY"; case QUIC_FRAME_IMMEDIATE_ACK: return o << "QUIC_FRAME_IMMEDIATE_ACK"; + case QUIC_FRAME_RELIABLE_RESET_STREAM: + return o << "QUIC_FRAME_RELIABLE_RESET_STREAM"; default: return o << "UNRECOGNIZED_FRAME_TYPE(" << (uint32_t) type << ")"; } diff --git a/src/inc/msquic.h b/src/inc/msquic.h index 245d2c05dc..5a496fffeb 100644 --- a/src/inc/msquic.h +++ b/src/inc/msquic.h @@ -216,6 +216,9 @@ typedef enum QUIC_STREAM_SHUTDOWN_FLAGS { QUIC_STREAM_SHUTDOWN_FLAG_IMMEDIATE = 0x0008, // Immediately sends completion events to app. QUIC_STREAM_SHUTDOWN_FLAG_INLINE = 0x0010, // Process the shutdown immediately inline. Only for calls on callbacks. // WARNING: Can cause reentrant callbacks! +#ifdef QUIC_API_ENABLE_PREVIEW_FEATURES + QUIC_STREAM_SHUTDOWN_FLAG_RELIABLE = 0x0020, // Closes the send and receive paths once promised data is delivered. +#endif } QUIC_STREAM_SHUTDOWN_FLAGS; DEFINE_ENUM_FLAG_OPERATORS(QUIC_STREAM_SHUTDOWN_FLAGS) @@ -1473,6 +1476,18 @@ QUIC_STATUS _In_ _Pre_defensive_ QUIC_UINT62 ErrorCode // Application defined error code ); +// +// Shuts the stream down as specified, and waits for graceful +// shutdowns to complete. Does nothing if already shut down. +// +typedef +_IRQL_requires_max_(DISPATCH_LEVEL) +QUIC_STATUS +(QUIC_API * QUIC_STREAM_SHUTDOWN_RELIABLE_FN)( + _In_ _Pre_defensive_ HQUIC Stream, + _In_ uint64_t ReliableSize + ); + // // Sends data on an open stream. // @@ -1569,6 +1584,7 @@ typedef struct QUIC_API_TABLE { QUIC_STREAM_CLOSE_FN StreamClose; QUIC_STREAM_START_FN StreamStart; QUIC_STREAM_SHUTDOWN_FN StreamShutdown; + QUIC_STREAM_SHUTDOWN_RELIABLE_FN StreamShutdownReliable; QUIC_STREAM_SEND_FN StreamSend; QUIC_STREAM_RECEIVE_COMPLETE_FN StreamReceiveComplete; QUIC_STREAM_RECEIVE_SET_ENABLED_FN StreamReceiveSetEnabled; diff --git a/src/inc/msquic.hpp b/src/inc/msquic.hpp index f38168f364..fead8fe6e2 100644 --- a/src/inc/msquic.hpp +++ b/src/inc/msquic.hpp @@ -1332,6 +1332,13 @@ struct MsQuicStream { return MsQuic->StreamShutdown(Handle, Flags, ErrorCode); } + QUIC_STATUS + ShutdownReliable( + _In_ uint64_t ReliableSize = 0 + ) noexcept { + return MsQuic->StreamShutdownReliable(Handle, ReliableSize); + } + void Close( ) noexcept { diff --git a/src/test/MsQuicTests.h b/src/test/MsQuicTests.h index 35ab05dec7..878ff16436 100644 --- a/src/test/MsQuicTests.h +++ b/src/test/MsQuicTests.h @@ -530,6 +530,10 @@ void QuicTestStreamAbortConnFlowControl( ); +void +QuicTestStreamReliableReset( + ); + void QuicTestStreamBlockUnblockConnFlowControl( _In_ BOOLEAN Bidirectional @@ -1193,4 +1197,7 @@ typedef struct { QUIC_CTL_CODE(111, METHOD_BUFFERED, FILE_WRITE_DATA) // QUIC_RUN_RELIABLE_RESET_NEGOTIATION -#define QUIC_MAX_IOCTL_FUNC_CODE 111 +#define IOCTL_QUIC_RUN_STREAM_RELIABLE_RESET \ + QUIC_CTL_CODE(112, METHOD_BUFFERED, FILE_WRITE_DATA) + +#define QUIC_MAX_IOCTL_FUNC_CODE 112 diff --git a/src/test/bin/quic_gtest.cpp b/src/test/bin/quic_gtest.cpp index 34c380d8a7..4309f7d7da 100644 --- a/src/test/bin/quic_gtest.cpp +++ b/src/test/bin/quic_gtest.cpp @@ -2064,6 +2064,15 @@ TEST(Misc, StreamBlockUnblockBidiConnFlowControl) { } } +TEST(Misc, StreamReliableReset) { + TestLogger Logger("StreamReliableReset"); + if (TestingKernelMode) { + ASSERT_TRUE(DriverClient.Run(IOCTL_QUIC_RUN_STREAM_RELIABLE_RESET)); + } else { + QuicTestStreamReliableReset(); + } +} + TEST(Misc, StreamBlockUnblockUnidiConnFlowControl) { TestLogger Logger("StreamBlockUnblockUnidiConnFlowControl"); if (TestingKernelMode) { diff --git a/src/test/bin/winkernel/control.cpp b/src/test/bin/winkernel/control.cpp index 625a6f8a6b..57b1ca56f9 100644 --- a/src/test/bin/winkernel/control.cpp +++ b/src/test/bin/winkernel/control.cpp @@ -1167,6 +1167,10 @@ QuicTestCtlEvtIoDeviceControl( QuicTestCtlRun(QuicTestStreamAbortConnFlowControl()); break; + case IOCTL_QUIC_RUN_STREAM_RELIABLE_RESET: + QuicTestCtlRun(QuicTestStreamReliableReset()); + break; + case IOCTL_QUIC_RUN__REG_SHUTDOWN_BEFORE_OPEN: QuicTestCtlRun(QuicTestRegistrationShutdownBeforeConnOpen()); break; diff --git a/src/test/lib/DataTest.cpp b/src/test/lib/DataTest.cpp index 8de2558550..ba6a4427a2 100644 --- a/src/test/lib/DataTest.cpp +++ b/src/test/lib/DataTest.cpp @@ -2960,6 +2960,98 @@ QuicTestStreamAbortConnFlowControl( TEST_TRUE(Context.ClientStreamShutdownComplete.WaitTimeout(TestWaitTimeout)); } +struct StreamReliableReset { + + CxPlatEvent ClientStreamShutdownComplete; + QUIC_BUFFER * ReceivedData; + + static QUIC_STATUS ClientStreamCallback(_In_ MsQuicStream* Stream, _In_opt_ void* Context, _Inout_ QUIC_STREAM_EVENT* Event) { + auto TestContext = (StreamReliableReset*)Context; + if (Event->Type == QUIC_STREAM_EVENT_SEND_SHUTDOWN_COMPLETE) { + Stream->Shutdown(0, QUIC_STREAM_SHUTDOWN_FLAG_ABORT_RECEIVE | QUIC_STREAM_SHUTDOWN_FLAG_INLINE); + } else if (Event->Type == QUIC_STREAM_EVENT_SHUTDOWN_COMPLETE) { + TestContext->ClientStreamShutdownComplete.Set(); + } + if (Event->Type == QUIC_STREAM_EVENT_RECEIVE) { + // TODO: De-reference and assign to ReceivedData the Event buffer here. Not sure how to do that rn. + } + return QUIC_STATUS_SUCCESS; + } + + static QUIC_STATUS ServerStreamCallback(_In_ MsQuicStream* Stream, _In_opt_ void*, _Inout_ QUIC_STREAM_EVENT* Event) { + if (Event->Type == QUIC_STREAM_EVENT_RECEIVE) { + Stream->Shutdown(QUIC_STREAM_SHUTDOWN_FLAG_ABORT_SEND); + } + return QUIC_STATUS_SUCCESS; + } + + static QUIC_STATUS ConnCallback(_In_ MsQuicConnection*, _In_opt_ void* Context, _Inout_ QUIC_CONNECTION_EVENT* Event) { + if (Event->Type == QUIC_CONNECTION_EVENT_PEER_STREAM_STARTED) { + new(std::nothrow) MsQuicStream(Event->PEER_STREAM_STARTED.Stream, CleanUpAutoDelete, ServerStreamCallback, Context); + } + return QUIC_STATUS_SUCCESS; + } +}; + +void +QuicTestStreamReliableReset( + ) +{ + MsQuicRegistration Registration(true); + TEST_TRUE(Registration.IsValid()); + + MsQuicSettings ServerSettings; + MsQuicSettings ClientSettings; + ServerSettings.SetReliableResetEnabled(true); + ClientSettings.SetReliableResetEnabled(true); + ServerSettings.SetPeerBidiStreamCount(1); + + MsQuicConfiguration ServerConfiguration(Registration, "MsQuicTest", ServerSettings, ServerSelfSignedCredConfig); + TEST_QUIC_SUCCEEDED(ServerConfiguration.GetInitStatus()); + + MsQuicConfiguration ClientConfiguration(Registration, "MsQuicTest", ClientSettings, MsQuicCredentialConfig()); + TEST_QUIC_SUCCEEDED(ClientConfiguration.GetInitStatus()); + + StreamReliableReset Context; + uint8_t DataBuffer[10]; + uint8_t ZeroBuffer[10]; + for (int i = 0; i < 10; ++i) { + DataBuffer[i] = (uint8_t)i + 69; + ZeroBuffer[i] = 0; + } + QUIC_BUFFER Buffer { sizeof(DataBuffer), DataBuffer }; + QUIC_BUFFER ReceivedData = { sizeof(ZeroBuffer), ZeroBuffer }; + Context.ReceivedData = &Buffer; + + MsQuicAutoAcceptListener Listener(Registration, ServerConfiguration, StreamReliableReset::ConnCallback, &Context); + TEST_QUIC_SUCCEEDED(Listener.GetInitStatus()); + TEST_QUIC_SUCCEEDED(Listener.Start("MsQuicTest")); + QuicAddr ServerLocalAddr; + TEST_QUIC_SUCCEEDED(Listener.GetLocalAddr(ServerLocalAddr)); + + MsQuicConnection Connection(Registration); + TEST_QUIC_SUCCEEDED(Connection.GetInitStatus()); + + MsQuicStream Stream(Connection, QUIC_STREAM_OPEN_FLAG_NONE, CleanUpManual, StreamReliableReset::ClientStreamCallback, &Context); + TEST_QUIC_SUCCEEDED(Stream.GetInitStatus()); + TEST_QUIC_SUCCEEDED(Stream.Start()); + + uint64_t ReliableSize = 6; + TEST_QUIC_SUCCEEDED(Stream.ShutdownReliable(ReliableSize)); + + TEST_QUIC_SUCCEEDED(Connection.Start(ClientConfiguration, ServerLocalAddr.GetFamily(), QUIC_TEST_LOOPBACK_FOR_AF(ServerLocalAddr.GetFamily()), ServerLocalAddr.GetPort())); + TEST_TRUE(Connection.HandshakeCompleteEvent.WaitTimeout(TestWaitTimeout)); + TEST_TRUE(Connection.HandshakeComplete); + TEST_TRUE(Listener.LastConnection->HandshakeCompleteEvent.WaitTimeout(TestWaitTimeout)); + TEST_TRUE(Listener.LastConnection->HandshakeComplete); + TEST_TRUE(Context.ClientStreamShutdownComplete.WaitTimeout(TestWaitTimeout)); + + for (int i = 0; i < ReliableSize; ++i) { + // Ensure data up to ReliableSize was received. + TEST_EQUAL(Buffer.Buffer[i], ReceivedData.Buffer[i]); + } +} + struct StreamBlockUnblockConnFlowControl { CxPlatEvent ClientStreamShutdownComplete; CxPlatEvent ClientStreamSendComplete; From 657cb669fce61fac8f0033638ea4c9cbcfc5493a Mon Sep 17 00:00:00 2001 From: Jack He Date: Tue, 15 Aug 2023 19:07:57 -0700 Subject: [PATCH 002/123] update fn description --- src/inc/msquic.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/inc/msquic.h b/src/inc/msquic.h index 5a496fffeb..46bc21478d 100644 --- a/src/inc/msquic.h +++ b/src/inc/msquic.h @@ -1477,8 +1477,8 @@ QUIC_STATUS ); // -// Shuts the stream down as specified, and waits for graceful -// shutdowns to complete. Does nothing if already shut down. +// Shuts the stream down reliably using error code 0x21, +// which will guarantee the transmission of "ReliableSize" bytes before aborting the stream. // typedef _IRQL_requires_max_(DISPATCH_LEVEL) From b6c5767a0177327805f21e26619bad628952e33d Mon Sep 17 00:00:00 2001 From: Jack He Date: Tue, 15 Aug 2023 19:13:58 -0700 Subject: [PATCH 003/123] add ifdef preview feature --- src/inc/msquic.h | 7 ++++--- src/inc/msquic.hpp | 2 ++ 2 files changed, 6 insertions(+), 3 deletions(-) diff --git a/src/inc/msquic.h b/src/inc/msquic.h index 46bc21478d..8df67131de 100644 --- a/src/inc/msquic.h +++ b/src/inc/msquic.h @@ -216,9 +216,6 @@ typedef enum QUIC_STREAM_SHUTDOWN_FLAGS { QUIC_STREAM_SHUTDOWN_FLAG_IMMEDIATE = 0x0008, // Immediately sends completion events to app. QUIC_STREAM_SHUTDOWN_FLAG_INLINE = 0x0010, // Process the shutdown immediately inline. Only for calls on callbacks. // WARNING: Can cause reentrant callbacks! -#ifdef QUIC_API_ENABLE_PREVIEW_FEATURES - QUIC_STREAM_SHUTDOWN_FLAG_RELIABLE = 0x0020, // Closes the send and receive paths once promised data is delivered. -#endif } QUIC_STREAM_SHUTDOWN_FLAGS; DEFINE_ENUM_FLAG_OPERATORS(QUIC_STREAM_SHUTDOWN_FLAGS) @@ -1476,6 +1473,7 @@ QUIC_STATUS _In_ _Pre_defensive_ QUIC_UINT62 ErrorCode // Application defined error code ); +#ifdef QUIC_API_ENABLE_PREVIEW_FEATURES // // Shuts the stream down reliably using error code 0x21, // which will guarantee the transmission of "ReliableSize" bytes before aborting the stream. @@ -1487,6 +1485,7 @@ QUIC_STATUS _In_ _Pre_defensive_ HQUIC Stream, _In_ uint64_t ReliableSize ); +#endif // // Sends data on an open stream. @@ -1584,7 +1583,9 @@ typedef struct QUIC_API_TABLE { QUIC_STREAM_CLOSE_FN StreamClose; QUIC_STREAM_START_FN StreamStart; QUIC_STREAM_SHUTDOWN_FN StreamShutdown; +#ifdef QUIC_API_ENABLE_PREVIEW_FEATURES QUIC_STREAM_SHUTDOWN_RELIABLE_FN StreamShutdownReliable; +#endif QUIC_STREAM_SEND_FN StreamSend; QUIC_STREAM_RECEIVE_COMPLETE_FN StreamReceiveComplete; QUIC_STREAM_RECEIVE_SET_ENABLED_FN StreamReceiveSetEnabled; diff --git a/src/inc/msquic.hpp b/src/inc/msquic.hpp index fead8fe6e2..1d96b95403 100644 --- a/src/inc/msquic.hpp +++ b/src/inc/msquic.hpp @@ -1332,12 +1332,14 @@ struct MsQuicStream { return MsQuic->StreamShutdown(Handle, Flags, ErrorCode); } +#ifdef QUIC_API_ENABLE_PREVIEW_FEATURES QUIC_STATUS ShutdownReliable( _In_ uint64_t ReliableSize = 0 ) noexcept { return MsQuic->StreamShutdownReliable(Handle, ReliableSize); } +#endif void Close( From 723740d66b37d106b937aa52232e8be65aa03298 Mon Sep 17 00:00:00 2001 From: Jack He Date: Wed, 16 Aug 2023 19:49:49 -0700 Subject: [PATCH 004/123] use get set params --- src/core/api.c | 13 ------------- src/core/api.h | 8 -------- src/core/library.c | 1 - src/core/stream.c | 34 ++++++++++++++++++++++++++++++++++ src/core/stream.h | 10 ++++++++++ src/core/stream_send.c | 2 +- src/inc/msquic.h | 19 ++----------------- src/inc/msquic.hpp | 29 ++++++++++++++++++++--------- src/test/lib/DataTest.cpp | 26 +++++++++++++++----------- 9 files changed, 82 insertions(+), 60 deletions(-) diff --git a/src/core/api.c b/src/core/api.c index 24e2a07634..7cf0b70b35 100644 --- a/src/core/api.c +++ b/src/core/api.c @@ -868,19 +868,6 @@ MsQuicStreamStart( return Status; } -_IRQL_requires_max_(DISPATCH_LEVEL) -QUIC_STATUS -QUIC_API -MsQuicStreamShutdownReliable( - _In_ _Pre_defensive_ HQUIC Handle, - _In_ uint64_t ReliableSize - ) -{ - // TODO: do something with ReliableSize to ensure data gets re-trasmitted before actually shutting down. - MsQuicStreamShutdown(Handle, QUIC_STREAM_SHUTDOWN_FLAG_ABORT, 0x21); - return QUIC_STATUS_SUCCESS; -} - _IRQL_requires_max_(DISPATCH_LEVEL) QUIC_STATUS QUIC_API diff --git a/src/core/api.h b/src/core/api.h index 29666da932..87c6631a04 100644 --- a/src/core/api.h +++ b/src/core/api.h @@ -196,14 +196,6 @@ MsQuicStreamShutdown( _In_ _Pre_defensive_ QUIC_UINT62 ErrorCode ); -_IRQL_requires_max_(DISPATCH_LEVEL) -QUIC_STATUS -QUIC_API -MsQuicStreamShutdownReliable( - _In_ _Pre_defensive_ HQUIC Handle, - _In_ uint64_t ReliableSize - ); - _IRQL_requires_max_(DISPATCH_LEVEL) QUIC_STATUS QUIC_API diff --git a/src/core/library.c b/src/core/library.c index bf44a080fd..d3de6de5eb 100644 --- a/src/core/library.c +++ b/src/core/library.c @@ -1706,7 +1706,6 @@ MsQuicOpenVersion( Api->StreamOpen = MsQuicStreamOpen; Api->StreamClose = MsQuicStreamClose; Api->StreamShutdown = MsQuicStreamShutdown; - Api->StreamShutdownReliable = MsQuicStreamShutdownReliable; Api->StreamStart = MsQuicStreamStart; Api->StreamSend = MsQuicStreamSend; Api->StreamReceiveComplete = MsQuicStreamReceiveComplete; diff --git a/src/core/stream.c b/src/core/stream.c index 3e434d96df..5b66b61a10 100644 --- a/src/core/stream.c +++ b/src/core/stream.c @@ -70,6 +70,8 @@ QuicStreamInitialize( Stream->RefCount = 1; Stream->SendRequestsTail = &Stream->SendRequests; Stream->SendPriority = QUIC_STREAM_PRIORITY_DEFAULT; + Stream->ReliableOffsetRecv = 0; + Stream->ReliableOffsetSend = 0; CxPlatDispatchLockInitialize(&Stream->ApiSendRequestLock); CxPlatRefInitialize(&Stream->RefCount); QuicRangeInitialize( @@ -659,6 +661,38 @@ QuicStreamParamSet( break; } + case QUIC_PARAM_STREAM_RELIABLE_OFFSET_SEND: + + if (BufferLength != sizeof(uint64_t) || Buffer == NULL) { + Status = QUIC_STATUS_INVALID_PARAMETER; + break; + } + + if (!Stream->Connection->State.ReliableResetStreamNegotiated) { + Status = QUIC_STATUS_INVALID_STATE; + break; + } + + Stream->ReliableOffsetSend = *(uint64_t*)Buffer; + Status = QUIC_STATUS_SUCCESS; + break; + + case QUIC_PARAM_STREAM_RELIABLE_OFFSET_RECV: + + if (BufferLength != sizeof(uint64_t) || Buffer == NULL) { + Status = QUIC_STATUS_INVALID_PARAMETER; + break; + } + + if (!Stream->Connection->State.ReliableResetStreamNegotiated) { + Status = QUIC_STATUS_INVALID_STATE; + break; + } + + Stream->ReliableOffsetRecv = *(uint64_t*)Buffer; + Status = QUIC_STATUS_SUCCESS; + break; + default: Status = QUIC_STATUS_INVALID_PARAMETER; break; diff --git a/src/core/stream.h b/src/core/stream.h index 9653196976..2b5e28bc1d 100644 --- a/src/core/stream.h +++ b/src/core/stream.h @@ -363,10 +363,20 @@ typedef struct QUIC_STREAM { // uint16_t SendPriority; + // + // If > 0, bytes up to offset must be re-transmitted and ACK'd from peer before we can abort this stream. + // + uint64_t ReliableOffsetSend; + // // Recv State // + // + // If > 0, bytes up to offset must be received from peer before we can abort this stream. + // + uint64_t ReliableOffsetRecv; + // // The max allowed RecvOffset (i.e., the number we report in // MAX_STREAM_DATA frames). When we have zero bytes buffered, diff --git a/src/core/stream_send.c b/src/core/stream_send.c index 9fa05dbd83..59ffdc53a3 100644 --- a/src/core/stream_send.c +++ b/src/core/stream_send.c @@ -516,7 +516,7 @@ QuicStreamSendFlush( if (!Stream->Flags.SendEnabled) { // - // Only possible if they queue muliple sends, with a FIN flag set + // Only possible if they queue multiple sends, with a FIN flag set // NOT in the last one. // QuicStreamCompleteSendRequest(Stream, SendRequest, TRUE, FALSE); diff --git a/src/inc/msquic.h b/src/inc/msquic.h index 8df67131de..6c2a60f266 100644 --- a/src/inc/msquic.h +++ b/src/inc/msquic.h @@ -922,6 +922,8 @@ typedef struct QUIC_SCHANNEL_CONTEXT_ATTRIBUTE_EX_W { #define QUIC_PARAM_STREAM_IDEAL_SEND_BUFFER_SIZE 0x08000002 // uint64_t - bytes #define QUIC_PARAM_STREAM_PRIORITY 0x08000003 // uint16_t - 0 (low) to 0xFFFF (high) - 0x7FFF (default) #define QUIC_PARAM_STREAM_STATISTICS 0X08000004 // QUIC_STREAM_STATISTICS +#define QUIC_PARAM_STREAM_RELIABLE_OFFSET_SEND 0x08000005 // uint64_t +#define QUIC_PARAM_STREAM_RELIABLE_OFFSET_RECV 0x08000006 // uint64_t typedef _IRQL_requires_max_(PASSIVE_LEVEL) @@ -1473,20 +1475,6 @@ QUIC_STATUS _In_ _Pre_defensive_ QUIC_UINT62 ErrorCode // Application defined error code ); -#ifdef QUIC_API_ENABLE_PREVIEW_FEATURES -// -// Shuts the stream down reliably using error code 0x21, -// which will guarantee the transmission of "ReliableSize" bytes before aborting the stream. -// -typedef -_IRQL_requires_max_(DISPATCH_LEVEL) -QUIC_STATUS -(QUIC_API * QUIC_STREAM_SHUTDOWN_RELIABLE_FN)( - _In_ _Pre_defensive_ HQUIC Stream, - _In_ uint64_t ReliableSize - ); -#endif - // // Sends data on an open stream. // @@ -1583,9 +1571,6 @@ typedef struct QUIC_API_TABLE { QUIC_STREAM_CLOSE_FN StreamClose; QUIC_STREAM_START_FN StreamStart; QUIC_STREAM_SHUTDOWN_FN StreamShutdown; -#ifdef QUIC_API_ENABLE_PREVIEW_FEATURES - QUIC_STREAM_SHUTDOWN_RELIABLE_FN StreamShutdownReliable; -#endif QUIC_STREAM_SEND_FN StreamSend; QUIC_STREAM_RECEIVE_COMPLETE_FN StreamReceiveComplete; QUIC_STREAM_RECEIVE_SET_ENABLED_FN StreamReceiveSetEnabled; diff --git a/src/inc/msquic.hpp b/src/inc/msquic.hpp index 1d96b95403..d164fc0fad 100644 --- a/src/inc/msquic.hpp +++ b/src/inc/msquic.hpp @@ -1332,15 +1332,6 @@ struct MsQuicStream { return MsQuic->StreamShutdown(Handle, Flags, ErrorCode); } -#ifdef QUIC_API_ENABLE_PREVIEW_FEATURES - QUIC_STATUS - ShutdownReliable( - _In_ uint64_t ReliableSize = 0 - ) noexcept { - return MsQuic->StreamShutdownReliable(Handle, ReliableSize); - } -#endif - void Close( ) noexcept { @@ -1449,6 +1440,26 @@ struct MsQuicStream { Statistics); } + QUIC_STATUS + SetReliableOffsetSend(_In_ uint64_t Offset) noexcept { + return + MsQuic->SetParam( + Handle, + QUIC_PARAM_STREAM_RELIABLE_OFFSET_SEND, + sizeof(Offset), + &Offset); + } + + QUIC_STATUS + SetReliableOffsetRecv(_In_ uint64_t Offset) noexcept { + return + MsQuic->SetParam( + Handle, + QUIC_PARAM_STREAM_RELIABLE_OFFSET_RECV, + sizeof(Offset), + &Offset); + } + QUIC_STATUS GetInitStatus() const noexcept { return InitStatus; } bool IsValid() const { return QUIC_SUCCEEDED(InitStatus); } MsQuicStream(const MsQuicStream& Other) = delete; diff --git a/src/test/lib/DataTest.cpp b/src/test/lib/DataTest.cpp index ba6a4427a2..b67678574b 100644 --- a/src/test/lib/DataTest.cpp +++ b/src/test/lib/DataTest.cpp @@ -3013,15 +3013,15 @@ QuicTestStreamReliableReset( TEST_QUIC_SUCCEEDED(ClientConfiguration.GetInitStatus()); StreamReliableReset Context; - uint8_t DataBuffer[10]; - uint8_t ZeroBuffer[10]; + uint8_t SendDataBuffer[10]; + uint8_t ReceiveDataBuffer[10]; for (int i = 0; i < 10; ++i) { - DataBuffer[i] = (uint8_t)i + 69; - ZeroBuffer[i] = 0; + SendDataBuffer[i] = (uint8_t)i + 69; + ReceiveDataBuffer[i] = 0; } - QUIC_BUFFER Buffer { sizeof(DataBuffer), DataBuffer }; - QUIC_BUFFER ReceivedData = { sizeof(ZeroBuffer), ZeroBuffer }; - Context.ReceivedData = &Buffer; + QUIC_BUFFER SendBuffer { sizeof(SendDataBuffer), SendDataBuffer }; + QUIC_BUFFER ReceiveBuffer = { sizeof(ReceiveDataBuffer), ReceiveDataBuffer }; + Context.ReceivedData = &ReceiveBuffer; MsQuicAutoAcceptListener Listener(Registration, ServerConfiguration, StreamReliableReset::ConnCallback, &Context); TEST_QUIC_SUCCEEDED(Listener.GetInitStatus()); @@ -3034,21 +3034,25 @@ QuicTestStreamReliableReset( MsQuicStream Stream(Connection, QUIC_STREAM_OPEN_FLAG_NONE, CleanUpManual, StreamReliableReset::ClientStreamCallback, &Context); TEST_QUIC_SUCCEEDED(Stream.GetInitStatus()); + // TODO: Start another stream from Listener->LastConnection, and send data on it. TEST_QUIC_SUCCEEDED(Stream.Start()); - uint64_t ReliableSize = 6; - TEST_QUIC_SUCCEEDED(Stream.ShutdownReliable(ReliableSize)); - TEST_QUIC_SUCCEEDED(Connection.Start(ClientConfiguration, ServerLocalAddr.GetFamily(), QUIC_TEST_LOOPBACK_FOR_AF(ServerLocalAddr.GetFamily()), ServerLocalAddr.GetPort())); TEST_TRUE(Connection.HandshakeCompleteEvent.WaitTimeout(TestWaitTimeout)); TEST_TRUE(Connection.HandshakeComplete); TEST_TRUE(Listener.LastConnection->HandshakeCompleteEvent.WaitTimeout(TestWaitTimeout)); TEST_TRUE(Listener.LastConnection->HandshakeComplete); + + uint64_t ReliableSize = 6; + TEST_QUIC_SUCCEEDED(Stream.SetReliableOffsetRecv(ReliableSize)); + // Call shutdown, we must guarantee we receive 6 bytes of data before actually closing. + TEST_QUIC_SUCCEEDED(Stream.Shutdown(0)); + TEST_TRUE(Context.ClientStreamShutdownComplete.WaitTimeout(TestWaitTimeout)); for (int i = 0; i < ReliableSize; ++i) { // Ensure data up to ReliableSize was received. - TEST_EQUAL(Buffer.Buffer[i], ReceivedData.Buffer[i]); + TEST_EQUAL(SendBuffer.Buffer[i], ReceiveBuffer.Buffer[i]); } } From fb68ffd4d7fe1e4d007c1e680cd498e9479fedf4 Mon Sep 17 00:00:00 2001 From: Jack He Date: Thu, 17 Aug 2023 11:06:53 -0700 Subject: [PATCH 005/123] remove unnecessary alloc and add null buffer check --- src/core/stream.c | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/src/core/stream.c b/src/core/stream.c index 5b66b61a10..4ee28d9f82 100644 --- a/src/core/stream.c +++ b/src/core/stream.c @@ -70,8 +70,6 @@ QuicStreamInitialize( Stream->RefCount = 1; Stream->SendRequestsTail = &Stream->SendRequests; Stream->SendPriority = QUIC_STREAM_PRIORITY_DEFAULT; - Stream->ReliableOffsetRecv = 0; - Stream->ReliableOffsetSend = 0; CxPlatDispatchLockInitialize(&Stream->ApiSendRequestLock); CxPlatRefInitialize(&Stream->RefCount); QuicRangeInitialize( @@ -635,7 +633,7 @@ QuicStreamParamSet( case QUIC_PARAM_STREAM_PRIORITY: { - if (BufferLength != sizeof(Stream->SendPriority)) { + if (BufferLength != sizeof(Stream->SendPriority) || Buffer == NULL) { Status = QUIC_STATUS_INVALID_PARAMETER; break; } From a038e8fdc372ba6e707e53500020dac83446ab54 Mon Sep 17 00:00:00 2001 From: Jack He Date: Thu, 17 Aug 2023 11:17:22 -0700 Subject: [PATCH 006/123] update control.cpp to conform to standards --- src/test/bin/winkernel/control.cpp | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/src/test/bin/winkernel/control.cpp b/src/test/bin/winkernel/control.cpp index 57b1ca56f9..bc847a09b0 100644 --- a/src/test/bin/winkernel/control.cpp +++ b/src/test/bin/winkernel/control.cpp @@ -482,7 +482,8 @@ size_t QUIC_IOCTL_BUFFER_SIZES[] = sizeof(INT32), sizeof(INT32), sizeof(QUIC_RUN_CUSTOM_CERT_VALIDATION), - sizeof(QUIC_RUN_RELIABLE_RESET_NEGOTIATION) + sizeof(QUIC_RUN_RELIABLE_RESET_NEGOTIATION), + 0, }; CXPLAT_STATIC_ASSERT( @@ -1167,10 +1168,6 @@ QuicTestCtlEvtIoDeviceControl( QuicTestCtlRun(QuicTestStreamAbortConnFlowControl()); break; - case IOCTL_QUIC_RUN_STREAM_RELIABLE_RESET: - QuicTestCtlRun(QuicTestStreamReliableReset()); - break; - case IOCTL_QUIC_RUN__REG_SHUTDOWN_BEFORE_OPEN: QuicTestCtlRun(QuicTestRegistrationShutdownBeforeConnOpen()); break; @@ -1352,6 +1349,10 @@ QuicTestCtlEvtIoDeviceControl( Params->ReliableResetNegotiationParams.ServerSupport, Params->ReliableResetNegotiationParams.ClientSupport)); break; + + case IOCTL_QUIC_RUN_STREAM_RELIABLE_RESET: + QuicTestCtlRun(QuicTestStreamReliableReset()); + break; #endif default: Status = STATUS_NOT_IMPLEMENTED; From 660d7f250bade54344dfaba62a8435fc13637db0 Mon Sep 17 00:00:00 2001 From: Jack He Date: Thu, 17 Aug 2023 11:50:46 -0700 Subject: [PATCH 007/123] update packing order and feature variables --- src/core/stream.c | 18 +----------------- src/core/stream.h | 21 +++++++++++---------- src/inc/msquic.h | 5 +++-- src/inc/msquic.hpp | 16 ++++------------ src/test/lib/DataTest.cpp | 2 +- 5 files changed, 20 insertions(+), 42 deletions(-) diff --git a/src/core/stream.c b/src/core/stream.c index 4ee28d9f82..d8d22d4a39 100644 --- a/src/core/stream.c +++ b/src/core/stream.c @@ -659,7 +659,7 @@ QuicStreamParamSet( break; } - case QUIC_PARAM_STREAM_RELIABLE_OFFSET_SEND: + case QUIC_PARAM_STREAM_RELIABLE_OFFSET: if (BufferLength != sizeof(uint64_t) || Buffer == NULL) { Status = QUIC_STATUS_INVALID_PARAMETER; @@ -675,22 +675,6 @@ QuicStreamParamSet( Status = QUIC_STATUS_SUCCESS; break; - case QUIC_PARAM_STREAM_RELIABLE_OFFSET_RECV: - - if (BufferLength != sizeof(uint64_t) || Buffer == NULL) { - Status = QUIC_STATUS_INVALID_PARAMETER; - break; - } - - if (!Stream->Connection->State.ReliableResetStreamNegotiated) { - Status = QUIC_STATUS_INVALID_STATE; - break; - } - - Stream->ReliableOffsetRecv = *(uint64_t*)Buffer; - Status = QUIC_STATUS_SUCCESS; - break; - default: Status = QUIC_STATUS_INVALID_PARAMETER; break; diff --git a/src/core/stream.h b/src/core/stream.h index 2b5e28bc1d..b7375b2cbf 100644 --- a/src/core/stream.h +++ b/src/core/stream.h @@ -345,6 +345,12 @@ typedef struct QUIC_STREAM { // uint64_t RecoveryNextOffset; uint64_t RecoveryEndOffset; + + // + // If > 0, bytes up to offset must be re-transmitted and ACK'd from peer before we can abort this stream. + // + uint64_t ReliableOffsetSend; + #define RECOV_WINDOW_OPEN(S) ((S)->RecoveryNextOffset < (S)->RecoveryEndOffset) // @@ -363,20 +369,10 @@ typedef struct QUIC_STREAM { // uint16_t SendPriority; - // - // If > 0, bytes up to offset must be re-transmitted and ACK'd from peer before we can abort this stream. - // - uint64_t ReliableOffsetSend; - // // Recv State // - // - // If > 0, bytes up to offset must be received from peer before we can abort this stream. - // - uint64_t ReliableOffsetRecv; - // // The max allowed RecvOffset (i.e., the number we report in // MAX_STREAM_DATA frames). When we have zero bytes buffered, @@ -420,6 +416,11 @@ typedef struct QUIC_STREAM { // uint64_t RecvInlineCompletionLength; + // + // If > 0, bytes up to offset must be received from peer before we can abort this stream. + // + uint64_t ReliableOffsetRecv; + // // The error code for why the receive path was shutdown. // diff --git a/src/inc/msquic.h b/src/inc/msquic.h index 6c2a60f266..dbfb192f76 100644 --- a/src/inc/msquic.h +++ b/src/inc/msquic.h @@ -922,8 +922,9 @@ typedef struct QUIC_SCHANNEL_CONTEXT_ATTRIBUTE_EX_W { #define QUIC_PARAM_STREAM_IDEAL_SEND_BUFFER_SIZE 0x08000002 // uint64_t - bytes #define QUIC_PARAM_STREAM_PRIORITY 0x08000003 // uint16_t - 0 (low) to 0xFFFF (high) - 0x7FFF (default) #define QUIC_PARAM_STREAM_STATISTICS 0X08000004 // QUIC_STREAM_STATISTICS -#define QUIC_PARAM_STREAM_RELIABLE_OFFSET_SEND 0x08000005 // uint64_t -#define QUIC_PARAM_STREAM_RELIABLE_OFFSET_RECV 0x08000006 // uint64_t +#ifdef QUIC_API_ENABLE_PREVIEW_FEATURES +#define QUIC_PARAM_STREAM_RELIABLE_OFFSET 0x08000005 // uint64_t +#endif typedef _IRQL_requires_max_(PASSIVE_LEVEL) diff --git a/src/inc/msquic.hpp b/src/inc/msquic.hpp index d164fc0fad..52c3a3dab3 100644 --- a/src/inc/msquic.hpp +++ b/src/inc/msquic.hpp @@ -1440,25 +1440,17 @@ struct MsQuicStream { Statistics); } + #ifdef QUIC_API_ENABLE_PREVIEW_FEATURES QUIC_STATUS - SetReliableOffsetSend(_In_ uint64_t Offset) noexcept { + SetReliableOffset(_In_ uint64_t Offset) noexcept { return MsQuic->SetParam( Handle, - QUIC_PARAM_STREAM_RELIABLE_OFFSET_SEND, - sizeof(Offset), - &Offset); - } - - QUIC_STATUS - SetReliableOffsetRecv(_In_ uint64_t Offset) noexcept { - return - MsQuic->SetParam( - Handle, - QUIC_PARAM_STREAM_RELIABLE_OFFSET_RECV, + QUIC_PARAM_STREAM_RELIABLE_OFFSET, sizeof(Offset), &Offset); } + #endif QUIC_STATUS GetInitStatus() const noexcept { return InitStatus; } bool IsValid() const { return QUIC_SUCCEEDED(InitStatus); } diff --git a/src/test/lib/DataTest.cpp b/src/test/lib/DataTest.cpp index b67678574b..a624de7533 100644 --- a/src/test/lib/DataTest.cpp +++ b/src/test/lib/DataTest.cpp @@ -3044,7 +3044,7 @@ QuicTestStreamReliableReset( TEST_TRUE(Listener.LastConnection->HandshakeComplete); uint64_t ReliableSize = 6; - TEST_QUIC_SUCCEEDED(Stream.SetReliableOffsetRecv(ReliableSize)); + TEST_QUIC_SUCCEEDED(Stream.SetReliableOffset(ReliableSize)); // Call shutdown, we must guarantee we receive 6 bytes of data before actually closing. TEST_QUIC_SUCCEEDED(Stream.Shutdown(0)); From b860449a6818b2b1692ddc312d8359cb100c8056 Mon Sep 17 00:00:00 2001 From: Jack He Date: Thu, 17 Aug 2023 12:30:52 -0700 Subject: [PATCH 008/123] test pass but should not pass --- src/core/stream.c | 2 +- src/test/lib/DataTest.cpp | 44 ++++++++++++++++++++++++--------------- 2 files changed, 28 insertions(+), 18 deletions(-) diff --git a/src/core/stream.c b/src/core/stream.c index d8d22d4a39..59d87b7394 100644 --- a/src/core/stream.c +++ b/src/core/stream.c @@ -666,7 +666,7 @@ QuicStreamParamSet( break; } - if (!Stream->Connection->State.ReliableResetStreamNegotiated) { + if (!Stream->Connection->State.ReliableResetStreamNegotiated || *(uint64_t*)Buffer > Stream->QueuedSendOffset) { Status = QUIC_STATUS_INVALID_STATE; break; } diff --git a/src/test/lib/DataTest.cpp b/src/test/lib/DataTest.cpp index a624de7533..1780816cbc 100644 --- a/src/test/lib/DataTest.cpp +++ b/src/test/lib/DataTest.cpp @@ -2965,21 +2965,20 @@ struct StreamReliableReset { CxPlatEvent ClientStreamShutdownComplete; QUIC_BUFFER * ReceivedData; - static QUIC_STATUS ClientStreamCallback(_In_ MsQuicStream* Stream, _In_opt_ void* Context, _Inout_ QUIC_STREAM_EVENT* Event) { - auto TestContext = (StreamReliableReset*)Context; - if (Event->Type == QUIC_STREAM_EVENT_SEND_SHUTDOWN_COMPLETE) { - Stream->Shutdown(0, QUIC_STREAM_SHUTDOWN_FLAG_ABORT_RECEIVE | QUIC_STREAM_SHUTDOWN_FLAG_INLINE); - } else if (Event->Type == QUIC_STREAM_EVENT_SHUTDOWN_COMPLETE) { + static QUIC_STATUS ClientStreamCallback(_In_ MsQuicStream*, _In_opt_ void* ClientContext, _Inout_ QUIC_STREAM_EVENT* Event) { + auto TestContext = (StreamReliableReset*)ClientContext; + if (Event->Type == QUIC_STREAM_EVENT_SHUTDOWN_COMPLETE) { TestContext->ClientStreamShutdownComplete.Set(); } - if (Event->Type == QUIC_STREAM_EVENT_RECEIVE) { - // TODO: De-reference and assign to ReceivedData the Event buffer here. Not sure how to do that rn. - } return QUIC_STATUS_SUCCESS; } - static QUIC_STATUS ServerStreamCallback(_In_ MsQuicStream* Stream, _In_opt_ void*, _Inout_ QUIC_STREAM_EVENT* Event) { + static QUIC_STATUS ServerStreamCallback(_In_ MsQuicStream* Stream, _In_opt_ void* ServerContext, _Inout_ QUIC_STREAM_EVENT* Event) { + auto TestContext = (StreamReliableReset*)ServerContext; if (Event->Type == QUIC_STREAM_EVENT_RECEIVE) { + TestContext->ReceivedData->Buffer = Event->RECEIVE.Buffers->Buffer; + } + if (Event->Type == QUIC_STREAM_EVENT_PEER_SEND_SHUTDOWN) { Stream->Shutdown(QUIC_STREAM_SHUTDOWN_FLAG_ABORT_SEND); } return QUIC_STATUS_SUCCESS; @@ -2997,6 +2996,16 @@ void QuicTestStreamReliableReset( ) { + /* + + Client initiates stream, connects to Server. + Client sets ReliableOffset (send offset) to be 6. + Client sends data to server + Client immediately calls shutdown. + Client should finish sending data up to 6 before actually aborting. + Server should get data up to 6 before ACKing the shutdown. + + */ MsQuicRegistration Registration(true); TEST_TRUE(Registration.IsValid()); @@ -3013,10 +3022,12 @@ QuicTestStreamReliableReset( TEST_QUIC_SUCCEEDED(ClientConfiguration.GetInitStatus()); StreamReliableReset Context; - uint8_t SendDataBuffer[10]; - uint8_t ReceiveDataBuffer[10]; - for (int i = 0; i < 10; ++i) { - SendDataBuffer[i] = (uint8_t)i + 69; + #define BUFFER_SIZE 10000 + #define RELIABLE_SIZE 1000 + uint8_t SendDataBuffer[BUFFER_SIZE]; + uint8_t ReceiveDataBuffer[BUFFER_SIZE]; + for (int i = 0; i < BUFFER_SIZE; ++i) { + SendDataBuffer[i] = (uint8_t) (i % (sizeof(uint8_t))); ReceiveDataBuffer[i] = 0; } QUIC_BUFFER SendBuffer { sizeof(SendDataBuffer), SendDataBuffer }; @@ -3034,8 +3045,8 @@ QuicTestStreamReliableReset( MsQuicStream Stream(Connection, QUIC_STREAM_OPEN_FLAG_NONE, CleanUpManual, StreamReliableReset::ClientStreamCallback, &Context); TEST_QUIC_SUCCEEDED(Stream.GetInitStatus()); - // TODO: Start another stream from Listener->LastConnection, and send data on it. TEST_QUIC_SUCCEEDED(Stream.Start()); + TEST_QUIC_SUCCEEDED(Stream.Send(&SendBuffer, 1, QUIC_SEND_FLAG_NONE, &Context)); TEST_QUIC_SUCCEEDED(Connection.Start(ClientConfiguration, ServerLocalAddr.GetFamily(), QUIC_TEST_LOOPBACK_FOR_AF(ServerLocalAddr.GetFamily()), ServerLocalAddr.GetPort())); TEST_TRUE(Connection.HandshakeCompleteEvent.WaitTimeout(TestWaitTimeout)); @@ -3043,14 +3054,13 @@ QuicTestStreamReliableReset( TEST_TRUE(Listener.LastConnection->HandshakeCompleteEvent.WaitTimeout(TestWaitTimeout)); TEST_TRUE(Listener.LastConnection->HandshakeComplete); - uint64_t ReliableSize = 6; - TEST_QUIC_SUCCEEDED(Stream.SetReliableOffset(ReliableSize)); + TEST_QUIC_SUCCEEDED(Stream.SetReliableOffset(RELIABLE_SIZE)); // Call shutdown, we must guarantee we receive 6 bytes of data before actually closing. TEST_QUIC_SUCCEEDED(Stream.Shutdown(0)); TEST_TRUE(Context.ClientStreamShutdownComplete.WaitTimeout(TestWaitTimeout)); - for (int i = 0; i < ReliableSize; ++i) { + for (int i = 0; i < RELIABLE_SIZE; ++i) { // Ensure data up to ReliableSize was received. TEST_EQUAL(SendBuffer.Buffer[i], ReceiveBuffer.Buffer[i]); } From 492cd25cc394e31cce02979bea828daf846262f8 Mon Sep 17 00:00:00 2001 From: Jack He Date: Thu, 17 Aug 2023 14:12:59 -0700 Subject: [PATCH 009/123] add delay send --- src/test/lib/DataTest.cpp | 34 +++++++++++++++++++--------------- 1 file changed, 19 insertions(+), 15 deletions(-) diff --git a/src/test/lib/DataTest.cpp b/src/test/lib/DataTest.cpp index 1780816cbc..7b68d05b2a 100644 --- a/src/test/lib/DataTest.cpp +++ b/src/test/lib/DataTest.cpp @@ -2963,7 +2963,7 @@ QuicTestStreamAbortConnFlowControl( struct StreamReliableReset { CxPlatEvent ClientStreamShutdownComplete; - QUIC_BUFFER * ReceivedData; + uint64_t ReceivedBufferSize; static QUIC_STATUS ClientStreamCallback(_In_ MsQuicStream*, _In_opt_ void* ClientContext, _Inout_ QUIC_STREAM_EVENT* Event) { auto TestContext = (StreamReliableReset*)ClientContext; @@ -2976,7 +2976,7 @@ struct StreamReliableReset { static QUIC_STATUS ServerStreamCallback(_In_ MsQuicStream* Stream, _In_opt_ void* ServerContext, _Inout_ QUIC_STREAM_EVENT* Event) { auto TestContext = (StreamReliableReset*)ServerContext; if (Event->Type == QUIC_STREAM_EVENT_RECEIVE) { - TestContext->ReceivedData->Buffer = Event->RECEIVE.Buffers->Buffer; + TestContext->ReceivedBufferSize += Event->RECEIVE.TotalBufferLength; } if (Event->Type == QUIC_STREAM_EVENT_PEER_SEND_SHUTDOWN) { Stream->Shutdown(QUIC_STREAM_SHUTDOWN_FLAG_ABORT_SEND); @@ -3005,6 +3005,17 @@ QuicTestStreamReliableReset( Client should finish sending data up to 6 before actually aborting. Server should get data up to 6 before ACKing the shutdown. + + Best way to do this; + - artificially delay receiver callback + - Peer Event Started + - Theoretically you can block receive event... + + Quic Send Flag: QUIC_SEND_FLAG_DELAY_FLAG (not always happens) + - Here's a send, you don't have to send it yet. + - wait for handshake, sleep(50) + - start, send (with delay), (set reliable offset), shutdown (do everything after handshake completes) + */ MsQuicRegistration Registration(true); TEST_TRUE(Registration.IsValid()); @@ -3026,13 +3037,10 @@ QuicTestStreamReliableReset( #define RELIABLE_SIZE 1000 uint8_t SendDataBuffer[BUFFER_SIZE]; uint8_t ReceiveDataBuffer[BUFFER_SIZE]; - for (int i = 0; i < BUFFER_SIZE; ++i) { - SendDataBuffer[i] = (uint8_t) (i % (sizeof(uint8_t))); - ReceiveDataBuffer[i] = 0; - } + QUIC_BUFFER SendBuffer { sizeof(SendDataBuffer), SendDataBuffer }; QUIC_BUFFER ReceiveBuffer = { sizeof(ReceiveDataBuffer), ReceiveDataBuffer }; - Context.ReceivedData = &ReceiveBuffer; + Context.ReceivedBufferSize = 0; MsQuicAutoAcceptListener Listener(Registration, ServerConfiguration, StreamReliableReset::ConnCallback, &Context); TEST_QUIC_SUCCEEDED(Listener.GetInitStatus()); @@ -3045,25 +3053,21 @@ QuicTestStreamReliableReset( MsQuicStream Stream(Connection, QUIC_STREAM_OPEN_FLAG_NONE, CleanUpManual, StreamReliableReset::ClientStreamCallback, &Context); TEST_QUIC_SUCCEEDED(Stream.GetInitStatus()); - TEST_QUIC_SUCCEEDED(Stream.Start()); - TEST_QUIC_SUCCEEDED(Stream.Send(&SendBuffer, 1, QUIC_SEND_FLAG_NONE, &Context)); TEST_QUIC_SUCCEEDED(Connection.Start(ClientConfiguration, ServerLocalAddr.GetFamily(), QUIC_TEST_LOOPBACK_FOR_AF(ServerLocalAddr.GetFamily()), ServerLocalAddr.GetPort())); TEST_TRUE(Connection.HandshakeCompleteEvent.WaitTimeout(TestWaitTimeout)); TEST_TRUE(Connection.HandshakeComplete); TEST_TRUE(Listener.LastConnection->HandshakeCompleteEvent.WaitTimeout(TestWaitTimeout)); TEST_TRUE(Listener.LastConnection->HandshakeComplete); + CxPlatSleep(50); + TEST_QUIC_SUCCEEDED(Stream.Start()); + TEST_QUIC_SUCCEEDED(Stream.Send(&SendBuffer, 1, QUIC_SEND_FLAG_DELAY_SEND, &Context)); TEST_QUIC_SUCCEEDED(Stream.SetReliableOffset(RELIABLE_SIZE)); - // Call shutdown, we must guarantee we receive 6 bytes of data before actually closing. TEST_QUIC_SUCCEEDED(Stream.Shutdown(0)); TEST_TRUE(Context.ClientStreamShutdownComplete.WaitTimeout(TestWaitTimeout)); - - for (int i = 0; i < RELIABLE_SIZE; ++i) { - // Ensure data up to ReliableSize was received. - TEST_EQUAL(SendBuffer.Buffer[i], ReceiveBuffer.Buffer[i]); - } + TEST_TRUE(Context.ReceivedBufferSize >= RELIABLE_SIZE); } struct StreamBlockUnblockConnFlowControl { From 8280288fd838b8f9f35f253b29c11af88cc26d42 Mon Sep 17 00:00:00 2001 From: Jack He Date: Fri, 18 Aug 2023 11:52:59 -0700 Subject: [PATCH 010/123] add GetParam for debugging --- src/core/stream.c | 29 +++++++++++++++++++++++++++++ src/inc/msquic.hpp | 22 ++++++++++++++++++++++ src/inc/msquicp.h | 4 ++++ 3 files changed, 55 insertions(+) diff --git a/src/core/stream.c b/src/core/stream.c index 59d87b7394..dbf6adb9ec 100644 --- a/src/core/stream.c +++ b/src/core/stream.c @@ -854,6 +854,35 @@ QuicStreamParamGet( Status = QUIC_STATUS_SUCCESS; break; } + + case QUIC_PARAM_STREAM_RELIABLE_OFFSET: + if (*BufferLength < sizeof(uint64_t)) { + *BufferLength = sizeof(uint64_t); + Status = QUIC_STATUS_BUFFER_TOO_SMALL; + break; + } + if (Buffer == NULL) { + Status = QUIC_STATUS_INVALID_PARAMETER; + break; + } + *(uint64_t*) Buffer = Stream->ReliableOffsetSend; + Status = QUIC_STATUS_SUCCESS; + break; + + case QUIC_PARAM_STREAM_RELIABLE_OFFSET_RECV: + if (*BufferLength < sizeof(uint64_t)) { + *BufferLength = sizeof(uint64_t); + Status = QUIC_STATUS_BUFFER_TOO_SMALL; + break; + } + if (Buffer == NULL) { + Status = QUIC_STATUS_INVALID_PARAMETER; + break; + } + *(uint64_t*) Buffer = Stream->ReliableOffsetRecv; + Status = QUIC_STATUS_SUCCESS; + break; + default: Status = QUIC_STATUS_INVALID_PARAMETER; break; diff --git a/src/inc/msquic.hpp b/src/inc/msquic.hpp index 52c3a3dab3..d04d441b90 100644 --- a/src/inc/msquic.hpp +++ b/src/inc/msquic.hpp @@ -1450,6 +1450,28 @@ struct MsQuicStream { sizeof(Offset), &Offset); } + + QUIC_STATUS + GetReliableOffset(_Out_ uint64_t* Offset) const noexcept { + uint32_t Size = sizeof(*Offset); + return + MsQuic->GetParam( + Handle, + QUIC_PARAM_STREAM_RELIABLE_OFFSET, + &Size, + Offset); + } + + QUIC_STATUS + GetReliableOffsetRecv(_Out_ uint64_t* Offset) const noexcept { + uint32_t Size = sizeof(*Offset); + return + MsQuic->GetParam( + Handle, + QUIC_PARAM_STREAM_RELIABLE_OFFSET_RECV, + &Size, + Offset); + } #endif QUIC_STATUS GetInitStatus() const noexcept { return InitStatus; } diff --git a/src/inc/msquicp.h b/src/inc/msquicp.h index b9aa0a586c..f78b0102a7 100644 --- a/src/inc/msquicp.h +++ b/src/inc/msquicp.h @@ -134,6 +134,10 @@ typedef struct QUIC_PRIVATE_TRANSPORT_PARAMETER { #define QUIC_PARAM_CONN_KEEP_ALIVE_PADDING 0x85000003 // uint16_t #define QUIC_PARAM_CONN_DISABLE_VNE_TP_GENERATION 0x85000004 // BOOLEAN +#ifdef QUIC_API_ENABLE_PREVIEW_FEATURES +#define QUIC_PARAM_STREAM_RELIABLE_OFFSET_RECV 0x08000006 // uint64_t +#endif + #if defined(__cplusplus) } #endif From 47a9e67d3d849d062cc521bb2f75d23aac8d924d Mon Sep 17 00:00:00 2001 From: Jack He Date: Fri, 18 Aug 2023 14:39:16 -0700 Subject: [PATCH 011/123] add loss detection and further logging --- src/core/connection.c | 3 +-- src/core/loss_detection.c | 13 +++++++++++ src/core/sent_packet_metadata.h | 5 ++++- src/core/stream_recv.c | 38 +++++++++++++++++++++++++++++++++ src/core/stream_send.c | 25 ++++++++++++++++------ src/test/lib/DataTest.cpp | 33 +++++++++++++++++++++------- 6 files changed, 99 insertions(+), 18 deletions(-) diff --git a/src/core/connection.c b/src/core/connection.c index cd4b8a2629..2268204e62 100644 --- a/src/core/connection.c +++ b/src/core/connection.c @@ -4667,6 +4667,7 @@ QuicConnRecvFrames( } case QUIC_FRAME_RESET_STREAM: + case QUIC_FRAME_RELIABLE_RESET_STREAM: case QUIC_FRAME_STOP_SENDING: case QUIC_FRAME_STREAM: case QUIC_FRAME_STREAM_1: @@ -5289,8 +5290,6 @@ QuicConnRecvFrames( AckImmediately = TRUE; break; - case QUIC_FRAME_RELIABLE_RESET_STREAM: - // TODO - Implement this frame. default: // // No default case necessary, as we have already validated the frame diff --git a/src/core/loss_detection.c b/src/core/loss_detection.c index 8e30437a40..4b65427239 100644 --- a/src/core/loss_detection.c +++ b/src/core/loss_detection.c @@ -551,6 +551,10 @@ QuicLossDetectionOnPacketAcknowledged( QuicStreamOnResetAck(Packet->Frames[i].RESET_STREAM.Stream); break; + case QUIC_FRAME_RELIABLE_RESET_STREAM: + QuicStreamOnResetAck(Packet->Frames[i].RELIABLE_RESET_STREAM.Stream); + break; + case QUIC_FRAME_CRYPTO: QuicCryptoOnAck(&Connection->Crypto, &Packet->Frames[i]); break; @@ -707,6 +711,15 @@ QuicLossDetectionRetransmitFrames( FALSE); break; + case QUIC_FRAME_RELIABLE_RESET_STREAM: + NewDataQueued |= + QuicSendSetStreamSendFlag( + &Connection->Send, + Packet->Frames[i].RELIABLE_RESET_STREAM.Stream, + QUIC_STREAM_SEND_FLAG_SEND_ABORT, + FALSE); + break; + case QUIC_FRAME_STOP_SENDING: NewDataQueued |= QuicSendSetStreamSendFlag( diff --git a/src/core/sent_packet_metadata.h b/src/core/sent_packet_metadata.h index 8ef3fe295b..95704ce12a 100644 --- a/src/core/sent_packet_metadata.h +++ b/src/core/sent_packet_metadata.h @@ -27,6 +27,9 @@ typedef struct QUIC_SENT_FRAME_METADATA { struct { QUIC_STREAM* Stream; } RESET_STREAM; + struct { + QUIC_STREAM* Stream; + } RELIABLE_RESET_STREAM; struct { QUIC_STREAM* Stream; } STOP_SENDING; @@ -103,7 +106,7 @@ typedef struct QUIC_SEND_PACKET_FLAGS { // // Packet info of last acked packet on this connection -// +// typedef struct LAST_ACKED_PACKET_INFO { // diff --git a/src/core/stream_recv.c b/src/core/stream_recv.c index a4736ea292..9de2ef4213 100644 --- a/src/core/stream_recv.c +++ b/src/core/stream_recv.c @@ -162,6 +162,29 @@ QuicStreamRecvQueueFlush( } } +// +// Processes a received RELIABLE_RESET frame's payload. +// +_IRQL_requires_max_(PASSIVE_LEVEL) +void +QuicStreamProcessReliableResetFrame( + _In_ QUIC_STREAM* Stream, + _In_ uint64_t FinalSize, + _In_ QUIC_VAR_INT ErrorCode, + _In_ QUIC_VAR_INT ReliableOffset + ) +{ + if (Stream->ReliableOffsetRecv == 0 || ReliableOffset < Stream->ReliableOffsetRecv) { + // + // As outlined in the spec, if we receive multiple CLOSE_STREAM frames, we only accept strictly + // decreasing offsets. + // + Stream->ReliableOffsetRecv = ReliableOffset; + } + + QuicStreamProcessResetFrame(Stream, FinalSize, ErrorCode); +} + // // Processes a received RESET_STREAM frame's payload. // @@ -617,6 +640,21 @@ QuicStreamRecv( break; } + case QUIC_FRAME_RELIABLE_RESET_STREAM: { + QUIC_RELIABLE_RESET_STREAM_EX Frame; + if (!QuicReliableResetFrameDecode(BufferLength, Buffer, Offset, &Frame)) { + return QUIC_STATUS_INVALID_PARAMETER; + } + + QuicStreamProcessReliableResetFrame( + Stream, + Frame.FinalSize, + Frame.ErrorCode, + Frame.ReliableSize); + + break; + } + default: // QUIC_FRAME_STREAM* { QUIC_STREAM_EX Frame; diff --git a/src/core/stream_send.c b/src/core/stream_send.c index 59ffdc53a3..9800626e37 100644 --- a/src/core/stream_send.c +++ b/src/core/stream_send.c @@ -1069,17 +1069,28 @@ QuicStreamSendWrite( } if (Stream->SendFlags & QUIC_STREAM_SEND_FLAG_SEND_ABORT) { - - QUIC_RESET_STREAM_EX Frame = { Stream->ID, Stream->SendShutdownErrorCode, Stream->MaxSentLength }; - - if (QuicResetStreamFrameEncode( + QUIC_FRAME_TYPE FrameType; + BOOLEAN CanEncodeFrame; + if (Stream->ReliableOffsetSend > 0) { + QUIC_RELIABLE_RESET_STREAM_EX Frame = { Stream->ID, Stream->SendShutdownErrorCode, Stream->MaxSentLength, Stream->ReliableOffsetSend }; + CanEncodeFrame = QuicReliableResetFrameEncode( &Frame, &Builder->DatagramLength, AvailableBufferLength, - Builder->Datagram->Buffer)) { - + Builder->Datagram->Buffer); + FrameType = QUIC_FRAME_RELIABLE_RESET_STREAM; + } else { + QUIC_RESET_STREAM_EX Frame = { Stream->ID, Stream->SendShutdownErrorCode, Stream->MaxSentLength }; + CanEncodeFrame = QuicResetStreamFrameEncode( + &Frame, + &Builder->DatagramLength, + AvailableBufferLength, + Builder->Datagram->Buffer); + FrameType = QUIC_FRAME_RESET_STREAM; + } + if (CanEncodeFrame) { Stream->SendFlags &= ~QUIC_STREAM_SEND_FLAG_SEND_ABORT; - if (QuicPacketBuilderAddStreamFrame(Builder, Stream, QUIC_FRAME_RESET_STREAM)) { + if (QuicPacketBuilderAddStreamFrame(Builder, Stream, FrameType)) { return TRUE; } } else { diff --git a/src/test/lib/DataTest.cpp b/src/test/lib/DataTest.cpp index 7b68d05b2a..0c77a09069 100644 --- a/src/test/lib/DataTest.cpp +++ b/src/test/lib/DataTest.cpp @@ -8,12 +8,13 @@ Tests various features related to the data path. --*/ - +// remove +#include +// remove. #include "precomp.h" #ifdef QUIC_CLOG #include "DataTest.cpp.clog.h" #endif - #if defined(_KERNEL_MODE) static bool UseQTIP = false; #elif defined(QUIC_API_ENABLE_PREVIEW_FEATURES) @@ -2965,7 +2966,15 @@ struct StreamReliableReset { CxPlatEvent ClientStreamShutdownComplete; uint64_t ReceivedBufferSize; - static QUIC_STATUS ClientStreamCallback(_In_ MsQuicStream*, _In_opt_ void* ClientContext, _Inout_ QUIC_STREAM_EVENT* Event) { + static QUIC_STATUS ClientStreamCallback(_In_ MsQuicStream* Stream, _In_opt_ void* ClientContext, _Inout_ QUIC_STREAM_EVENT* Event) { + // remove + uint64_t ReliableOffsetSendSide = 69420; + uint64_t ReliableOffsetRecvSide = 69420; + Stream->GetReliableOffset(&ReliableOffsetSendSide); + Stream->GetReliableOffsetRecv(&ReliableOffsetRecvSide); + std::cout << "Client Side Stream Send: " << ReliableOffsetSendSide << ", "; + std::cout << " Client Side Stream Recv: " << ReliableOffsetRecvSide << std::endl; + // remove. auto TestContext = (StreamReliableReset*)ClientContext; if (Event->Type == QUIC_STREAM_EVENT_SHUTDOWN_COMPLETE) { TestContext->ClientStreamShutdownComplete.Set(); @@ -2974,6 +2983,14 @@ struct StreamReliableReset { } static QUIC_STATUS ServerStreamCallback(_In_ MsQuicStream* Stream, _In_opt_ void* ServerContext, _Inout_ QUIC_STREAM_EVENT* Event) { + // remove + uint64_t ReliableOffsetSendSide = 69420; + uint64_t ReliableOffsetRecvSide = 69420; + Stream->GetReliableOffset(&ReliableOffsetSendSide); + Stream->GetReliableOffsetRecv(&ReliableOffsetRecvSide); + std::cout << "Server Side Stream Send: " << ReliableOffsetSendSide << ", "; + std::cout << " Server Side Stream Recv: " << ReliableOffsetRecvSide << std::endl; + // remove. auto TestContext = (StreamReliableReset*)ServerContext; if (Event->Type == QUIC_STREAM_EVENT_RECEIVE) { TestContext->ReceivedBufferSize += Event->RECEIVE.TotalBufferLength; @@ -2999,11 +3016,11 @@ QuicTestStreamReliableReset( /* Client initiates stream, connects to Server. - Client sets ReliableOffset (send offset) to be 6. + Client sets ReliableOffset (send offset) to be X. Client sends data to server Client immediately calls shutdown. - Client should finish sending data up to 6 before actually aborting. - Server should get data up to 6 before ACKing the shutdown. + Client should finish sending data up to X before actually aborting. + Server should get data up to X before ACKing the shutdown. Best way to do this; @@ -3034,7 +3051,7 @@ QuicTestStreamReliableReset( StreamReliableReset Context; #define BUFFER_SIZE 10000 - #define RELIABLE_SIZE 1000 + #define RELIABLE_SIZE 5000 uint8_t SendDataBuffer[BUFFER_SIZE]; uint8_t ReceiveDataBuffer[BUFFER_SIZE]; @@ -3064,7 +3081,7 @@ QuicTestStreamReliableReset( TEST_QUIC_SUCCEEDED(Stream.Start()); TEST_QUIC_SUCCEEDED(Stream.Send(&SendBuffer, 1, QUIC_SEND_FLAG_DELAY_SEND, &Context)); TEST_QUIC_SUCCEEDED(Stream.SetReliableOffset(RELIABLE_SIZE)); - TEST_QUIC_SUCCEEDED(Stream.Shutdown(0)); + TEST_QUIC_SUCCEEDED(Stream.Shutdown(0)); // Queues up a shutdown operation. TEST_TRUE(Context.ClientStreamShutdownComplete.WaitTimeout(TestWaitTimeout)); TEST_TRUE(Context.ReceivedBufferSize >= RELIABLE_SIZE); From aa4eb7b4d8fec1d8108b26d173b4bd4963885770 Mon Sep 17 00:00:00 2001 From: "Jack He (Github)" Date: Mon, 21 Aug 2023 10:23:19 -0700 Subject: [PATCH 012/123] Update src/core/stream.c Co-authored-by: Nick Banks --- src/core/stream.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/core/stream.c b/src/core/stream.c index dbf6adb9ec..01d291caaa 100644 --- a/src/core/stream.c +++ b/src/core/stream.c @@ -666,7 +666,8 @@ QuicStreamParamSet( break; } - if (!Stream->Connection->State.ReliableResetStreamNegotiated || *(uint64_t*)Buffer > Stream->QueuedSendOffset) { + if (!Stream->Connection->State.ReliableResetStreamNegotiated || + *(uint64_t*)Buffer > Stream->QueuedSendOffset) { Status = QUIC_STATUS_INVALID_STATE; break; } From 25d92f45ccb403ccb060badfb49d6460f00588fd Mon Sep 17 00:00:00 2001 From: Jack He Date: Mon, 21 Aug 2023 10:26:10 -0700 Subject: [PATCH 013/123] use same settings for client/server --- src/test/lib/DataTest.cpp | 33 +++++---------------------------- 1 file changed, 5 insertions(+), 28 deletions(-) diff --git a/src/test/lib/DataTest.cpp b/src/test/lib/DataTest.cpp index 0c77a09069..448c4ef4eb 100644 --- a/src/test/lib/DataTest.cpp +++ b/src/test/lib/DataTest.cpp @@ -3013,40 +3013,17 @@ void QuicTestStreamReliableReset( ) { - /* - - Client initiates stream, connects to Server. - Client sets ReliableOffset (send offset) to be X. - Client sends data to server - Client immediately calls shutdown. - Client should finish sending data up to X before actually aborting. - Server should get data up to X before ACKing the shutdown. - - - Best way to do this; - - artificially delay receiver callback - - Peer Event Started - - Theoretically you can block receive event... - - Quic Send Flag: QUIC_SEND_FLAG_DELAY_FLAG (not always happens) - - Here's a send, you don't have to send it yet. - - wait for handshake, sleep(50) - - start, send (with delay), (set reliable offset), shutdown (do everything after handshake completes) - - */ MsQuicRegistration Registration(true); TEST_TRUE(Registration.IsValid()); - MsQuicSettings ServerSettings; - MsQuicSettings ClientSettings; - ServerSettings.SetReliableResetEnabled(true); - ClientSettings.SetReliableResetEnabled(true); - ServerSettings.SetPeerBidiStreamCount(1); + MsQuicSettings TestSettings; + TestSettings.SetReliableResetEnabled(true); + TestSettings.SetPeerBidiStreamCount(1); - MsQuicConfiguration ServerConfiguration(Registration, "MsQuicTest", ServerSettings, ServerSelfSignedCredConfig); + MsQuicConfiguration ServerConfiguration(Registration, "MsQuicTest", TestSettings, ServerSelfSignedCredConfig); TEST_QUIC_SUCCEEDED(ServerConfiguration.GetInitStatus()); - MsQuicConfiguration ClientConfiguration(Registration, "MsQuicTest", ClientSettings, MsQuicCredentialConfig()); + MsQuicConfiguration ClientConfiguration(Registration, "MsQuicTest", TestSettings, MsQuicCredentialConfig()); TEST_QUIC_SUCCEEDED(ClientConfiguration.GetInitStatus()); StreamReliableReset Context; From ffba9035d5f6bf446ea46f4e07bffdd8ad73e058 Mon Sep 17 00:00:00 2001 From: Jack He Date: Mon, 21 Aug 2023 10:27:06 -0700 Subject: [PATCH 014/123] get rid of useless buffer --- src/test/lib/DataTest.cpp | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/test/lib/DataTest.cpp b/src/test/lib/DataTest.cpp index 448c4ef4eb..72d61aa400 100644 --- a/src/test/lib/DataTest.cpp +++ b/src/test/lib/DataTest.cpp @@ -3030,10 +3030,8 @@ QuicTestStreamReliableReset( #define BUFFER_SIZE 10000 #define RELIABLE_SIZE 5000 uint8_t SendDataBuffer[BUFFER_SIZE]; - uint8_t ReceiveDataBuffer[BUFFER_SIZE]; QUIC_BUFFER SendBuffer { sizeof(SendDataBuffer), SendDataBuffer }; - QUIC_BUFFER ReceiveBuffer = { sizeof(ReceiveDataBuffer), ReceiveDataBuffer }; Context.ReceivedBufferSize = 0; MsQuicAutoAcceptListener Listener(Registration, ServerConfiguration, StreamReliableReset::ConnCallback, &Context); From 277ea125d98750b26731346b20b707ca92c9784e Mon Sep 17 00:00:00 2001 From: Jack He Date: Mon, 21 Aug 2023 11:01:05 -0700 Subject: [PATCH 015/123] move test code to EOF --- src/test/lib/DataTest.cpp | 201 +++++++++++++++++++------------------- 1 file changed, 100 insertions(+), 101 deletions(-) diff --git a/src/test/lib/DataTest.cpp b/src/test/lib/DataTest.cpp index 72d61aa400..80a499d935 100644 --- a/src/test/lib/DataTest.cpp +++ b/src/test/lib/DataTest.cpp @@ -2961,107 +2961,6 @@ QuicTestStreamAbortConnFlowControl( TEST_TRUE(Context.ClientStreamShutdownComplete.WaitTimeout(TestWaitTimeout)); } -struct StreamReliableReset { - - CxPlatEvent ClientStreamShutdownComplete; - uint64_t ReceivedBufferSize; - - static QUIC_STATUS ClientStreamCallback(_In_ MsQuicStream* Stream, _In_opt_ void* ClientContext, _Inout_ QUIC_STREAM_EVENT* Event) { - // remove - uint64_t ReliableOffsetSendSide = 69420; - uint64_t ReliableOffsetRecvSide = 69420; - Stream->GetReliableOffset(&ReliableOffsetSendSide); - Stream->GetReliableOffsetRecv(&ReliableOffsetRecvSide); - std::cout << "Client Side Stream Send: " << ReliableOffsetSendSide << ", "; - std::cout << " Client Side Stream Recv: " << ReliableOffsetRecvSide << std::endl; - // remove. - auto TestContext = (StreamReliableReset*)ClientContext; - if (Event->Type == QUIC_STREAM_EVENT_SHUTDOWN_COMPLETE) { - TestContext->ClientStreamShutdownComplete.Set(); - } - return QUIC_STATUS_SUCCESS; - } - - static QUIC_STATUS ServerStreamCallback(_In_ MsQuicStream* Stream, _In_opt_ void* ServerContext, _Inout_ QUIC_STREAM_EVENT* Event) { - // remove - uint64_t ReliableOffsetSendSide = 69420; - uint64_t ReliableOffsetRecvSide = 69420; - Stream->GetReliableOffset(&ReliableOffsetSendSide); - Stream->GetReliableOffsetRecv(&ReliableOffsetRecvSide); - std::cout << "Server Side Stream Send: " << ReliableOffsetSendSide << ", "; - std::cout << " Server Side Stream Recv: " << ReliableOffsetRecvSide << std::endl; - // remove. - auto TestContext = (StreamReliableReset*)ServerContext; - if (Event->Type == QUIC_STREAM_EVENT_RECEIVE) { - TestContext->ReceivedBufferSize += Event->RECEIVE.TotalBufferLength; - } - if (Event->Type == QUIC_STREAM_EVENT_PEER_SEND_SHUTDOWN) { - Stream->Shutdown(QUIC_STREAM_SHUTDOWN_FLAG_ABORT_SEND); - } - return QUIC_STATUS_SUCCESS; - } - - static QUIC_STATUS ConnCallback(_In_ MsQuicConnection*, _In_opt_ void* Context, _Inout_ QUIC_CONNECTION_EVENT* Event) { - if (Event->Type == QUIC_CONNECTION_EVENT_PEER_STREAM_STARTED) { - new(std::nothrow) MsQuicStream(Event->PEER_STREAM_STARTED.Stream, CleanUpAutoDelete, ServerStreamCallback, Context); - } - return QUIC_STATUS_SUCCESS; - } -}; - -void -QuicTestStreamReliableReset( - ) -{ - MsQuicRegistration Registration(true); - TEST_TRUE(Registration.IsValid()); - - MsQuicSettings TestSettings; - TestSettings.SetReliableResetEnabled(true); - TestSettings.SetPeerBidiStreamCount(1); - - MsQuicConfiguration ServerConfiguration(Registration, "MsQuicTest", TestSettings, ServerSelfSignedCredConfig); - TEST_QUIC_SUCCEEDED(ServerConfiguration.GetInitStatus()); - - MsQuicConfiguration ClientConfiguration(Registration, "MsQuicTest", TestSettings, MsQuicCredentialConfig()); - TEST_QUIC_SUCCEEDED(ClientConfiguration.GetInitStatus()); - - StreamReliableReset Context; - #define BUFFER_SIZE 10000 - #define RELIABLE_SIZE 5000 - uint8_t SendDataBuffer[BUFFER_SIZE]; - - QUIC_BUFFER SendBuffer { sizeof(SendDataBuffer), SendDataBuffer }; - Context.ReceivedBufferSize = 0; - - MsQuicAutoAcceptListener Listener(Registration, ServerConfiguration, StreamReliableReset::ConnCallback, &Context); - TEST_QUIC_SUCCEEDED(Listener.GetInitStatus()); - TEST_QUIC_SUCCEEDED(Listener.Start("MsQuicTest")); - QuicAddr ServerLocalAddr; - TEST_QUIC_SUCCEEDED(Listener.GetLocalAddr(ServerLocalAddr)); - - MsQuicConnection Connection(Registration); - TEST_QUIC_SUCCEEDED(Connection.GetInitStatus()); - - MsQuicStream Stream(Connection, QUIC_STREAM_OPEN_FLAG_NONE, CleanUpManual, StreamReliableReset::ClientStreamCallback, &Context); - TEST_QUIC_SUCCEEDED(Stream.GetInitStatus()); - - TEST_QUIC_SUCCEEDED(Connection.Start(ClientConfiguration, ServerLocalAddr.GetFamily(), QUIC_TEST_LOOPBACK_FOR_AF(ServerLocalAddr.GetFamily()), ServerLocalAddr.GetPort())); - TEST_TRUE(Connection.HandshakeCompleteEvent.WaitTimeout(TestWaitTimeout)); - TEST_TRUE(Connection.HandshakeComplete); - TEST_TRUE(Listener.LastConnection->HandshakeCompleteEvent.WaitTimeout(TestWaitTimeout)); - TEST_TRUE(Listener.LastConnection->HandshakeComplete); - CxPlatSleep(50); - - TEST_QUIC_SUCCEEDED(Stream.Start()); - TEST_QUIC_SUCCEEDED(Stream.Send(&SendBuffer, 1, QUIC_SEND_FLAG_DELAY_SEND, &Context)); - TEST_QUIC_SUCCEEDED(Stream.SetReliableOffset(RELIABLE_SIZE)); - TEST_QUIC_SUCCEEDED(Stream.Shutdown(0)); // Queues up a shutdown operation. - - TEST_TRUE(Context.ClientStreamShutdownComplete.WaitTimeout(TestWaitTimeout)); - TEST_TRUE(Context.ReceivedBufferSize >= RELIABLE_SIZE); -} - struct StreamBlockUnblockConnFlowControl { CxPlatEvent ClientStreamShutdownComplete; CxPlatEvent ClientStreamSendComplete; @@ -3280,3 +3179,103 @@ QuicTestConnectAndIdleForDestCidChange( } } } + +void +QuicTestStreamReliableReset( + ) +{ + struct StreamReliableReset { + + CxPlatEvent ClientStreamShutdownComplete; + uint64_t ReceivedBufferSize; + + static QUIC_STATUS ClientStreamCallback(_In_ MsQuicStream* Stream, _In_opt_ void* ClientContext, _Inout_ QUIC_STREAM_EVENT* Event) { + // remove + uint64_t ReliableOffsetSendSide = 69420; + uint64_t ReliableOffsetRecvSide = 69420; + Stream->GetReliableOffset(&ReliableOffsetSendSide); + Stream->GetReliableOffsetRecv(&ReliableOffsetRecvSide); + std::cout << "Client Side Stream Send: " << ReliableOffsetSendSide << ", "; + std::cout << " Client Side Stream Recv: " << ReliableOffsetRecvSide << std::endl; + // remove. + auto TestContext = (StreamReliableReset*)ClientContext; + if (Event->Type == QUIC_STREAM_EVENT_SHUTDOWN_COMPLETE) { + TestContext->ClientStreamShutdownComplete.Set(); + } + return QUIC_STATUS_SUCCESS; + } + + static QUIC_STATUS ServerStreamCallback(_In_ MsQuicStream* Stream, _In_opt_ void* ServerContext, _Inout_ QUIC_STREAM_EVENT* Event) { + // remove + uint64_t ReliableOffsetSendSide = 69420; + uint64_t ReliableOffsetRecvSide = 69420; + Stream->GetReliableOffset(&ReliableOffsetSendSide); + Stream->GetReliableOffsetRecv(&ReliableOffsetRecvSide); + std::cout << "Server Side Stream Send: " << ReliableOffsetSendSide << ", "; + std::cout << " Server Side Stream Recv: " << ReliableOffsetRecvSide << std::endl; + // remove. + auto TestContext = (StreamReliableReset*)ServerContext; + if (Event->Type == QUIC_STREAM_EVENT_RECEIVE) { + TestContext->ReceivedBufferSize += Event->RECEIVE.TotalBufferLength; + } + if (Event->Type == QUIC_STREAM_EVENT_PEER_SEND_SHUTDOWN) { + Stream->Shutdown(QUIC_STREAM_SHUTDOWN_FLAG_ABORT_SEND); + } + return QUIC_STATUS_SUCCESS; + } + + static QUIC_STATUS ConnCallback(_In_ MsQuicConnection*, _In_opt_ void* Context, _Inout_ QUIC_CONNECTION_EVENT* Event) { + if (Event->Type == QUIC_CONNECTION_EVENT_PEER_STREAM_STARTED) { + new(std::nothrow) MsQuicStream(Event->PEER_STREAM_STARTED.Stream, CleanUpAutoDelete, ServerStreamCallback, Context); + } + return QUIC_STATUS_SUCCESS; + } +}; + + MsQuicRegistration Registration(true); + TEST_TRUE(Registration.IsValid()); + + MsQuicSettings TestSettings; + TestSettings.SetReliableResetEnabled(true); + TestSettings.SetPeerBidiStreamCount(1); + + MsQuicConfiguration ServerConfiguration(Registration, "MsQuicTest", TestSettings, ServerSelfSignedCredConfig); + TEST_QUIC_SUCCEEDED(ServerConfiguration.GetInitStatus()); + + MsQuicConfiguration ClientConfiguration(Registration, "MsQuicTest", TestSettings, MsQuicCredentialConfig()); + TEST_QUIC_SUCCEEDED(ClientConfiguration.GetInitStatus()); + + StreamReliableReset Context; + #define BUFFER_SIZE 10000 + #define RELIABLE_SIZE 5000 + uint8_t SendDataBuffer[BUFFER_SIZE]; + + QUIC_BUFFER SendBuffer { sizeof(SendDataBuffer), SendDataBuffer }; + Context.ReceivedBufferSize = 0; + + MsQuicAutoAcceptListener Listener(Registration, ServerConfiguration, StreamReliableReset::ConnCallback, &Context); + TEST_QUIC_SUCCEEDED(Listener.GetInitStatus()); + TEST_QUIC_SUCCEEDED(Listener.Start("MsQuicTest")); + QuicAddr ServerLocalAddr; + TEST_QUIC_SUCCEEDED(Listener.GetLocalAddr(ServerLocalAddr)); + + MsQuicConnection Connection(Registration); + TEST_QUIC_SUCCEEDED(Connection.GetInitStatus()); + + TEST_QUIC_SUCCEEDED(Connection.Start(ClientConfiguration, ServerLocalAddr.GetFamily(), QUIC_TEST_LOOPBACK_FOR_AF(ServerLocalAddr.GetFamily()), ServerLocalAddr.GetPort())); + TEST_TRUE(Connection.HandshakeCompleteEvent.WaitTimeout(TestWaitTimeout)); + TEST_TRUE(Connection.HandshakeComplete); + TEST_TRUE(Listener.LastConnection->HandshakeCompleteEvent.WaitTimeout(TestWaitTimeout)); + TEST_TRUE(Listener.LastConnection->HandshakeComplete); + CxPlatSleep(50); // Wait for things to idle out + + MsQuicStream Stream(Connection, QUIC_STREAM_OPEN_FLAG_NONE, CleanUpManual, StreamReliableReset::ClientStreamCallback, &Context); + TEST_QUIC_SUCCEEDED(Stream.GetInitStatus()); + TEST_QUIC_SUCCEEDED(Stream.Start()); + TEST_QUIC_SUCCEEDED(Stream.Send(&SendBuffer, 1, QUIC_SEND_FLAG_DELAY_SEND, &Context)); + TEST_QUIC_SUCCEEDED(Stream.SetReliableOffset(RELIABLE_SIZE)); + TEST_QUIC_SUCCEEDED(Stream.Shutdown(0)); // Queues up a shutdown operation. + + TEST_TRUE(Context.ClientStreamShutdownComplete.WaitTimeout(TestWaitTimeout)); + TEST_TRUE(Context.ReceivedBufferSize >= RELIABLE_SIZE); +} From 21981dc3c93a07a3f5cf17dec4b74fab09074117 Mon Sep 17 00:00:00 2001 From: Jack He Date: Mon, 21 Aug 2023 14:04:26 -0700 Subject: [PATCH 016/123] update receive path --- src/core/stream_recv.c | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/src/core/stream_recv.c b/src/core/stream_recv.c index 9de2ef4213..3cb7f8f613 100644 --- a/src/core/stream_recv.c +++ b/src/core/stream_recv.c @@ -179,10 +179,20 @@ QuicStreamProcessReliableResetFrame( // As outlined in the spec, if we receive multiple CLOSE_STREAM frames, we only accept strictly // decreasing offsets. // - Stream->ReliableOffsetRecv = ReliableOffset; + Stream->ReliableOffsetRecv = ReliableOffset; // TODO: Remove ReliableOffsetRecv once everything works. + Stream->RecvMaxLength = ReliableOffset; } - QuicStreamProcessResetFrame(Stream, FinalSize, ErrorCode); + + if (Stream->RecvBuffer.BaseOffset == Stream->RecvMaxLength) { + // + // All data delivered. Queue flush. + // + Stream->Flags.ReceiveDataPending = TRUE; + QuicStreamRecvQueueFlush( + Stream, + Stream->RecvBuffer.BaseOffset == Stream->RecvMaxLength); + } } // From b0cbd6230097f5a5ac9a0a5287dd332d0176696c Mon Sep 17 00:00:00 2001 From: Jack He Date: Mon, 21 Aug 2023 15:35:51 -0700 Subject: [PATCH 017/123] Try and test and see if this works --- src/core/stream.c | 2 ++ src/core/stream.h | 2 ++ src/core/stream_recv.c | 4 ++-- src/core/stream_send.c | 26 +++++++++++++++++++++++++- src/plugins/dbg/quictypes.h | 2 ++ src/test/lib/DataTest.cpp | 5 ++++- 6 files changed, 37 insertions(+), 4 deletions(-) diff --git a/src/core/stream.c b/src/core/stream.c index 01d291caaa..0e00614d6d 100644 --- a/src/core/stream.c +++ b/src/core/stream.c @@ -79,6 +79,8 @@ QuicStreamInitialize( Stream->RefTypeCount[QUIC_STREAM_REF_APP] = 1; #endif + Stream->Flags.ShutdownReliableSend = FALSE; + if (Stream->Flags.Unidirectional) { if (!OpenedRemotely) { diff --git a/src/core/stream.h b/src/core/stream.h index b7375b2cbf..a9e45ba3b7 100644 --- a/src/core/stream.h +++ b/src/core/stream.h @@ -152,6 +152,8 @@ typedef union QUIC_STREAM_FLAGS { BOOLEAN InStreamTable : 1; // The stream is currently in the connection's table. BOOLEAN DelayIdFcUpdate : 1; // Delay stream ID FC updates to StreamClose. + + BOOLEAN ShutdownReliableSend : 1; // Indicates that we should shutdown the send path once we sent/ACK'd ReliableOffsetSend bytes. }; } QUIC_STREAM_FLAGS; diff --git a/src/core/stream_recv.c b/src/core/stream_recv.c index 3cb7f8f613..08fc035de0 100644 --- a/src/core/stream_recv.c +++ b/src/core/stream_recv.c @@ -184,14 +184,14 @@ QuicStreamProcessReliableResetFrame( } - if (Stream->RecvBuffer.BaseOffset == Stream->RecvMaxLength) { + if (Stream->RecvBuffer.BaseOffset >= Stream->RecvMaxLength) { // // All data delivered. Queue flush. // Stream->Flags.ReceiveDataPending = TRUE; QuicStreamRecvQueueFlush( Stream, - Stream->RecvBuffer.BaseOffset == Stream->RecvMaxLength); + Stream->RecvBuffer.BaseOffset >= Stream->RecvMaxLength); } } diff --git a/src/core/stream_send.c b/src/core/stream_send.c index 9800626e37..90761d754c 100644 --- a/src/core/stream_send.c +++ b/src/core/stream_send.c @@ -159,7 +159,7 @@ QuicStreamSendShutdown( QUIC_STREAM_SEND_FLAG_FIN, DelaySend); - } else { + } else if (Stream->ReliableOffsetSend == 0) { // // Can't be blocked by (stream) FC any more if we've aborted sending any @@ -234,6 +234,25 @@ QuicStreamSendShutdown( QUIC_STREAM_SEND_FLAG_OPEN | QUIC_STREAM_SEND_FLAG_FIN); } + } else { + + while (ApiSendRequests != NULL) { + // + // Deliver send requests prior to aborting. + // + QUIC_SEND_REQUEST* SendRequest = ApiSendRequests; + ApiSendRequests = ApiSendRequests->Next; + QuicStreamCompleteSendRequest(Stream, SendRequest, TRUE, FALSE); + } + + // + // Queue up a RESET RELIABLE STREAM frame to be sent. + // + QuicSendSetStreamSendFlag( + &Stream->Connection->Send, + Stream, + QUIC_STREAM_SEND_FLAG_FIN, // TODO; Change this. + DelaySend); } QuicStreamSendDumpState(Stream); @@ -507,6 +526,10 @@ QuicStreamSendFlush( while (ApiSendRequests != NULL) { + if (Stream->UnAckedOffset >= Stream->ReliableOffsetSend && Stream->Flags.ShutdownReliableSend) { + break; + } + QUIC_SEND_REQUEST* SendRequest = ApiSendRequests; ApiSendRequests = ApiSendRequests->Next; SendRequest->Next = NULL; @@ -1079,6 +1102,7 @@ QuicStreamSendWrite( AvailableBufferLength, Builder->Datagram->Buffer); FrameType = QUIC_FRAME_RELIABLE_RESET_STREAM; + Stream->Flags.ShutdownReliableSend = TRUE; } else { QUIC_RESET_STREAM_EX Frame = { Stream->ID, Stream->SendShutdownErrorCode, Stream->MaxSentLength }; CanEncodeFrame = QuicResetStreamFrameEncode( diff --git a/src/plugins/dbg/quictypes.h b/src/plugins/dbg/quictypes.h index 1fb2761dc1..d862d99ddf 100644 --- a/src/plugins/dbg/quictypes.h +++ b/src/plugins/dbg/quictypes.h @@ -73,6 +73,8 @@ typedef union QUIC_STREAM_FLAGS { BOOLEAN InStreamTable : 1; // The stream is currently in the connection's table. BOOLEAN DelayIdFcUpdate : 1; // Delay stream ID FC updates to StreamClose. + + BOOLEAN ShutdownReliableSend : 1; // Indicates that we should shutdown the send path once we sent/ACK'd ReliableOffsetSend bytes. }; } QUIC_STREAM_FLAGS; diff --git a/src/test/lib/DataTest.cpp b/src/test/lib/DataTest.cpp index 80a499d935..57cdcf8c67 100644 --- a/src/test/lib/DataTest.cpp +++ b/src/test/lib/DataTest.cpp @@ -3275,7 +3275,10 @@ QuicTestStreamReliableReset( TEST_QUIC_SUCCEEDED(Stream.Send(&SendBuffer, 1, QUIC_SEND_FLAG_DELAY_SEND, &Context)); TEST_QUIC_SUCCEEDED(Stream.SetReliableOffset(RELIABLE_SIZE)); TEST_QUIC_SUCCEEDED(Stream.Shutdown(0)); // Queues up a shutdown operation. - + // Should behave similar to QUIC_STREAM_SHUTDOWN_FLAG_GRACEFUL, with some restrictions. TEST_TRUE(Context.ClientStreamShutdownComplete.WaitTimeout(TestWaitTimeout)); + // Remove + std::cout << "ReceivedBufferSize: " << Context.ReceivedBufferSize << std::endl; + // Remove. TEST_TRUE(Context.ReceivedBufferSize >= RELIABLE_SIZE); } From 49b8cb73c426e07f283060c0a024a110918aa2a1 Mon Sep 17 00:00:00 2001 From: Jack He Date: Mon, 21 Aug 2023 15:48:28 -0700 Subject: [PATCH 018/123] we should queue up a reliable reset frame --- src/core/stream_send.c | 10 +--------- 1 file changed, 1 insertion(+), 9 deletions(-) diff --git a/src/core/stream_send.c b/src/core/stream_send.c index 90761d754c..8129965670 100644 --- a/src/core/stream_send.c +++ b/src/core/stream_send.c @@ -236,15 +236,6 @@ QuicStreamSendShutdown( } } else { - while (ApiSendRequests != NULL) { - // - // Deliver send requests prior to aborting. - // - QUIC_SEND_REQUEST* SendRequest = ApiSendRequests; - ApiSendRequests = ApiSendRequests->Next; - QuicStreamCompleteSendRequest(Stream, SendRequest, TRUE, FALSE); - } - // // Queue up a RESET RELIABLE STREAM frame to be sent. // @@ -253,6 +244,7 @@ QuicStreamSendShutdown( Stream, QUIC_STREAM_SEND_FLAG_FIN, // TODO; Change this. DelaySend); + } QuicStreamSendDumpState(Stream); From ef4e5d7f98102379e3892437f5b00320e6c76185 Mon Sep 17 00:00:00 2001 From: Jack He Date: Mon, 21 Aug 2023 16:16:51 -0700 Subject: [PATCH 019/123] only complete send unsent requests --- src/core/stream_send.c | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/src/core/stream_send.c b/src/core/stream_send.c index 8129965670..f4f401709a 100644 --- a/src/core/stream_send.c +++ b/src/core/stream_send.c @@ -235,6 +235,16 @@ QuicStreamSendShutdown( QUIC_STREAM_SEND_FLAG_FIN); } } else { + uint64_t CurrOffset = Stream->UnAckedOffset; + while (ApiSendRequests != NULL && CurrOffset < Stream->ReliableOffsetSend) { + // + // Deliver the necessary send requests prior to aborting. + // + QUIC_SEND_REQUEST* SendRequest = ApiSendRequests; + ApiSendRequests = ApiSendRequests->Next; + QuicStreamCompleteSendRequest(Stream, SendRequest, TRUE, FALSE); + CurrOffset++; + } // // Queue up a RESET RELIABLE STREAM frame to be sent. @@ -244,7 +254,6 @@ QuicStreamSendShutdown( Stream, QUIC_STREAM_SEND_FLAG_FIN, // TODO; Change this. DelaySend); - } QuicStreamSendDumpState(Stream); From 7a4ea9ebf163d308f8f3b7de8d5d1bee6e778ab0 Mon Sep 17 00:00:00 2001 From: Jack He Date: Tue, 22 Aug 2023 10:32:43 -0700 Subject: [PATCH 020/123] include new tests to check send/recv offsets --- src/test/lib/DataTest.cpp | 38 ++++++++++++++++++++++---------------- 1 file changed, 22 insertions(+), 16 deletions(-) diff --git a/src/test/lib/DataTest.cpp b/src/test/lib/DataTest.cpp index 57cdcf8c67..9be0228f77 100644 --- a/src/test/lib/DataTest.cpp +++ b/src/test/lib/DataTest.cpp @@ -3184,21 +3184,26 @@ void QuicTestStreamReliableReset( ) { + #define BUFFER_SIZE 10000 + #define RELIABLE_SIZE 5000 + struct StreamReliableReset { CxPlatEvent ClientStreamShutdownComplete; uint64_t ReceivedBufferSize; + uint64_t ReliableOffsetSendSideClient = 69420; + uint64_t ReliableOffsetRecvSideClient = 69420; + uint64_t ReliableOffsetSendSideServer = 69420; + uint64_t ReliableOffsetRecvSideServer = 69420; static QUIC_STATUS ClientStreamCallback(_In_ MsQuicStream* Stream, _In_opt_ void* ClientContext, _Inout_ QUIC_STREAM_EVENT* Event) { + auto TestContext = (StreamReliableReset*)ClientContext; // remove - uint64_t ReliableOffsetSendSide = 69420; - uint64_t ReliableOffsetRecvSide = 69420; - Stream->GetReliableOffset(&ReliableOffsetSendSide); - Stream->GetReliableOffsetRecv(&ReliableOffsetRecvSide); - std::cout << "Client Side Stream Send: " << ReliableOffsetSendSide << ", "; - std::cout << " Client Side Stream Recv: " << ReliableOffsetRecvSide << std::endl; + Stream->GetReliableOffset(&TestContext->ReliableOffsetSendSideClient); + Stream->GetReliableOffsetRecv(&TestContext->ReliableOffsetRecvSideClient); + std::cout << "Client Side Stream Send: " << TestContext->ReliableOffsetSendSideClient << ", "; + std::cout << " Client Side Stream Recv: " << TestContext->ReliableOffsetRecvSideClient << std::endl; // remove. - auto TestContext = (StreamReliableReset*)ClientContext; if (Event->Type == QUIC_STREAM_EVENT_SHUTDOWN_COMPLETE) { TestContext->ClientStreamShutdownComplete.Set(); } @@ -3206,15 +3211,13 @@ QuicTestStreamReliableReset( } static QUIC_STATUS ServerStreamCallback(_In_ MsQuicStream* Stream, _In_opt_ void* ServerContext, _Inout_ QUIC_STREAM_EVENT* Event) { + auto TestContext = (StreamReliableReset*)ServerContext; // remove - uint64_t ReliableOffsetSendSide = 69420; - uint64_t ReliableOffsetRecvSide = 69420; - Stream->GetReliableOffset(&ReliableOffsetSendSide); - Stream->GetReliableOffsetRecv(&ReliableOffsetRecvSide); - std::cout << "Server Side Stream Send: " << ReliableOffsetSendSide << ", "; - std::cout << " Server Side Stream Recv: " << ReliableOffsetRecvSide << std::endl; + Stream->GetReliableOffset(&TestContext->ReliableOffsetSendSideServer); + Stream->GetReliableOffsetRecv(&TestContext->ReliableOffsetRecvSideServer); + std::cout << "Server Side Stream Send: " << TestContext->ReliableOffsetSendSideServer << ", "; + std::cout << " Server Side Stream Recv: " << TestContext->ReliableOffsetRecvSideServer << std::endl; // remove. - auto TestContext = (StreamReliableReset*)ServerContext; if (Event->Type == QUIC_STREAM_EVENT_RECEIVE) { TestContext->ReceivedBufferSize += Event->RECEIVE.TotalBufferLength; } @@ -3246,8 +3249,6 @@ QuicTestStreamReliableReset( TEST_QUIC_SUCCEEDED(ClientConfiguration.GetInitStatus()); StreamReliableReset Context; - #define BUFFER_SIZE 10000 - #define RELIABLE_SIZE 5000 uint8_t SendDataBuffer[BUFFER_SIZE]; QUIC_BUFFER SendBuffer { sizeof(SendDataBuffer), SendDataBuffer }; @@ -3280,5 +3281,10 @@ QuicTestStreamReliableReset( // Remove std::cout << "ReceivedBufferSize: " << Context.ReceivedBufferSize << std::endl; // Remove. + TEST_TRUE(Context.ReliableOffsetSendSideClient == RELIABLE_SIZE); + TEST_TRUE(Context.ReliableOffsetRecvSideClient == 0); + TEST_TRUE(Context.ReliableOffsetSendSideServer == 0); + TEST_TRUE(Context.ReliableOffsetRecvSideServer == RELIABLE_SIZE); + TEST_TRUE(Context.ReceivedBufferSize >= RELIABLE_SIZE); } From 4f23ee5e5117eaf3d8205e089e95cc0550f2c83a Mon Sep 17 00:00:00 2001 From: "Jack He (Github)" Date: Tue, 22 Aug 2023 10:36:17 -0700 Subject: [PATCH 021/123] Update src/inc/msquicp.h with a high bit. Co-authored-by: Nick Banks --- src/inc/msquicp.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/inc/msquicp.h b/src/inc/msquicp.h index f78b0102a7..99820321b7 100644 --- a/src/inc/msquicp.h +++ b/src/inc/msquicp.h @@ -135,7 +135,7 @@ typedef struct QUIC_PRIVATE_TRANSPORT_PARAMETER { #define QUIC_PARAM_CONN_DISABLE_VNE_TP_GENERATION 0x85000004 // BOOLEAN #ifdef QUIC_API_ENABLE_PREVIEW_FEATURES -#define QUIC_PARAM_STREAM_RELIABLE_OFFSET_RECV 0x08000006 // uint64_t +#define QUIC_PARAM_STREAM_RELIABLE_OFFSET_RECV 0x88000000 // uint64_t #endif #if defined(__cplusplus) From 8640e1ac47a8629d869cf70d64c131ab504b2d77 Mon Sep 17 00:00:00 2001 From: Jack He Date: Tue, 22 Aug 2023 10:39:25 -0700 Subject: [PATCH 022/123] put case at the end --- src/core/connection.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/core/connection.c b/src/core/connection.c index 2268204e62..15915a4f5b 100644 --- a/src/core/connection.c +++ b/src/core/connection.c @@ -4667,7 +4667,6 @@ QuicConnRecvFrames( } case QUIC_FRAME_RESET_STREAM: - case QUIC_FRAME_RELIABLE_RESET_STREAM: case QUIC_FRAME_STOP_SENDING: case QUIC_FRAME_STREAM: case QUIC_FRAME_STREAM_1: @@ -4678,7 +4677,8 @@ QuicConnRecvFrames( case QUIC_FRAME_STREAM_6: case QUIC_FRAME_STREAM_7: case QUIC_FRAME_MAX_STREAM_DATA: - case QUIC_FRAME_STREAM_DATA_BLOCKED: { + case QUIC_FRAME_STREAM_DATA_BLOCKED: + case QUIC_FRAME_RELIABLE_RESET_STREAM: { if (Closed) { if (!QuicStreamFrameSkip( FrameType, PayloadLength, Payload, &Offset)) { From 0b44813495900fd74eb1a9031b88c9f17776b4e6 Mon Sep 17 00:00:00 2001 From: Jack He Date: Tue, 22 Aug 2023 10:41:52 -0700 Subject: [PATCH 023/123] remove redudant line of code --- src/core/stream.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/core/stream.c b/src/core/stream.c index 0e00614d6d..ab9dd3b540 100644 --- a/src/core/stream.c +++ b/src/core/stream.c @@ -79,7 +79,6 @@ QuicStreamInitialize( Stream->RefTypeCount[QUIC_STREAM_REF_APP] = 1; #endif - Stream->Flags.ShutdownReliableSend = FALSE; if (Stream->Flags.Unidirectional) { if (!OpenedRemotely) { From 0294c68969fee2c443e1d651b3b40ece7e1b6f9f Mon Sep 17 00:00:00 2001 From: Jack He Date: Tue, 22 Aug 2023 10:44:38 -0700 Subject: [PATCH 024/123] add logging --- src/core/stream.c | 8 +++++++- src/core/stream_recv.c | 6 ++++++ 2 files changed, 13 insertions(+), 1 deletion(-) diff --git a/src/core/stream.c b/src/core/stream.c index ab9dd3b540..ea083e7373 100644 --- a/src/core/stream.c +++ b/src/core/stream.c @@ -79,7 +79,6 @@ QuicStreamInitialize( Stream->RefTypeCount[QUIC_STREAM_REF_APP] = 1; #endif - if (Stream->Flags.Unidirectional) { if (!OpenedRemotely) { @@ -674,6 +673,13 @@ QuicStreamParamSet( } Stream->ReliableOffsetSend = *(uint64_t*)Buffer; + + QuicTraceLogStreamInfo( + ReliableSendOffsetSet, + Stream, + "Reliable send offset set to %llu", + *(uint64_t*)Buffer); + Status = QUIC_STATUS_SUCCESS; break; diff --git a/src/core/stream_recv.c b/src/core/stream_recv.c index 08fc035de0..4bc70945b5 100644 --- a/src/core/stream_recv.c +++ b/src/core/stream_recv.c @@ -181,6 +181,12 @@ QuicStreamProcessReliableResetFrame( // Stream->ReliableOffsetRecv = ReliableOffset; // TODO: Remove ReliableOffsetRecv once everything works. Stream->RecvMaxLength = ReliableOffset; + + QuicTraceLogStreamInfo( + ReliableRecvOffsetSet, + Stream, + "Reliable recv offset set to %llu", + ReliableOffset); } From 7ac6c710d535380db287845ad8fba543d9495b3e Mon Sep 17 00:00:00 2001 From: Jack He Date: Tue, 22 Aug 2023 10:46:41 -0700 Subject: [PATCH 025/123] rename stream variable --- src/core/stream.h | 3 +-- src/core/stream_send.c | 4 ++-- 2 files changed, 3 insertions(+), 4 deletions(-) diff --git a/src/core/stream.h b/src/core/stream.h index a9e45ba3b7..759c3d229d 100644 --- a/src/core/stream.h +++ b/src/core/stream.h @@ -122,6 +122,7 @@ typedef union QUIC_STREAM_FLAGS { BOOLEAN LocalNotAllowed : 1; // Peer's unidirectional stream. BOOLEAN LocalCloseFin : 1; // Locally closed (graceful). BOOLEAN LocalCloseReset : 1; // Locally closed (locally aborted). + BOOLEAN LocalCloseResetReliable : 1; // Indicates that we should shutdown the send path once we sent/ACK'd ReliableOffsetSend bytes. BOOLEAN ReceivedStopSending : 1; // Peer sent STOP_SENDING frame. BOOLEAN LocalCloseAcked : 1; // Any close acknowledged. BOOLEAN FinAcked : 1; // Our FIN was acknowledged. @@ -152,8 +153,6 @@ typedef union QUIC_STREAM_FLAGS { BOOLEAN InStreamTable : 1; // The stream is currently in the connection's table. BOOLEAN DelayIdFcUpdate : 1; // Delay stream ID FC updates to StreamClose. - - BOOLEAN ShutdownReliableSend : 1; // Indicates that we should shutdown the send path once we sent/ACK'd ReliableOffsetSend bytes. }; } QUIC_STREAM_FLAGS; diff --git a/src/core/stream_send.c b/src/core/stream_send.c index f4f401709a..b03ede583c 100644 --- a/src/core/stream_send.c +++ b/src/core/stream_send.c @@ -527,7 +527,7 @@ QuicStreamSendFlush( while (ApiSendRequests != NULL) { - if (Stream->UnAckedOffset >= Stream->ReliableOffsetSend && Stream->Flags.ShutdownReliableSend) { + if (Stream->UnAckedOffset >= Stream->ReliableOffsetSend && Stream->Flags.LocalCloseResetReliable) { break; } @@ -1103,7 +1103,7 @@ QuicStreamSendWrite( AvailableBufferLength, Builder->Datagram->Buffer); FrameType = QUIC_FRAME_RELIABLE_RESET_STREAM; - Stream->Flags.ShutdownReliableSend = TRUE; + Stream->Flags.LocalCloseResetReliable = TRUE; } else { QUIC_RESET_STREAM_EX Frame = { Stream->ID, Stream->SendShutdownErrorCode, Stream->MaxSentLength }; CanEncodeFrame = QuicResetStreamFrameEncode( From b37dd7bd3714c09801340427b40b3eda2e1fb283 Mon Sep 17 00:00:00 2001 From: Jack He Date: Tue, 22 Aug 2023 11:03:08 -0700 Subject: [PATCH 026/123] get rid of useless parameter in stream --- src/core/stream.c | 6 +++++- src/core/stream.h | 6 +----- src/core/stream_recv.c | 4 ++-- 3 files changed, 8 insertions(+), 8 deletions(-) diff --git a/src/core/stream.c b/src/core/stream.c index ea083e7373..c2f2e35e50 100644 --- a/src/core/stream.c +++ b/src/core/stream.c @@ -887,7 +887,11 @@ QuicStreamParamGet( Status = QUIC_STATUS_INVALID_PARAMETER; break; } - *(uint64_t*) Buffer = Stream->ReliableOffsetRecv; + if (!Stream->Flags.RemoteCloseResetReliable) { + *(uint64_t*) Buffer = 0; + } else { + *(uint64_t*) Buffer = Stream->RecvMaxLength; + } Status = QUIC_STATUS_SUCCESS; break; diff --git a/src/core/stream.h b/src/core/stream.h index 759c3d229d..7112a9ba12 100644 --- a/src/core/stream.h +++ b/src/core/stream.h @@ -123,6 +123,7 @@ typedef union QUIC_STREAM_FLAGS { BOOLEAN LocalCloseFin : 1; // Locally closed (graceful). BOOLEAN LocalCloseReset : 1; // Locally closed (locally aborted). BOOLEAN LocalCloseResetReliable : 1; // Indicates that we should shutdown the send path once we sent/ACK'd ReliableOffsetSend bytes. + BOOLEAN RemoteCloseResetReliable : 1; // Indicates that the peer initiaited a reliable reset. Keep Recv path available for RecvMaxLength bytes. BOOLEAN ReceivedStopSending : 1; // Peer sent STOP_SENDING frame. BOOLEAN LocalCloseAcked : 1; // Any close acknowledged. BOOLEAN FinAcked : 1; // Our FIN was acknowledged. @@ -417,11 +418,6 @@ typedef struct QUIC_STREAM { // uint64_t RecvInlineCompletionLength; - // - // If > 0, bytes up to offset must be received from peer before we can abort this stream. - // - uint64_t ReliableOffsetRecv; - // // The error code for why the receive path was shutdown. // diff --git a/src/core/stream_recv.c b/src/core/stream_recv.c index 4bc70945b5..f8a960c8e7 100644 --- a/src/core/stream_recv.c +++ b/src/core/stream_recv.c @@ -174,13 +174,13 @@ QuicStreamProcessReliableResetFrame( _In_ QUIC_VAR_INT ReliableOffset ) { - if (Stream->ReliableOffsetRecv == 0 || ReliableOffset < Stream->ReliableOffsetRecv) { + if (Stream->RecvMaxLength == 0 || ReliableOffset < Stream->RecvMaxLength) { // // As outlined in the spec, if we receive multiple CLOSE_STREAM frames, we only accept strictly // decreasing offsets. // - Stream->ReliableOffsetRecv = ReliableOffset; // TODO: Remove ReliableOffsetRecv once everything works. Stream->RecvMaxLength = ReliableOffset; + Stream->Flags.RemoteCloseResetReliable = TRUE; QuicTraceLogStreamInfo( ReliableRecvOffsetSet, From 2e5d4a1a0c21080eed08be3697225213c6682959 Mon Sep 17 00:00:00 2001 From: Jack He Date: Tue, 22 Aug 2023 11:12:39 -0700 Subject: [PATCH 027/123] add event indication recv side --- src/core/stream_recv.c | 31 +++++++++++++++++++++++++++---- 1 file changed, 27 insertions(+), 4 deletions(-) diff --git a/src/core/stream_recv.c b/src/core/stream_recv.c index f8a960c8e7..5e2da01787 100644 --- a/src/core/stream_recv.c +++ b/src/core/stream_recv.c @@ -189,15 +189,38 @@ QuicStreamProcessReliableResetFrame( ReliableOffset); } - if (Stream->RecvBuffer.BaseOffset >= Stream->RecvMaxLength) { // - // All data delivered. Queue flush. + // All data delivered. Deliver shutdown callback. // Stream->Flags.ReceiveDataPending = TRUE; - QuicStreamRecvQueueFlush( + + // + // Shut down the stream. + // + QuicStreamTryCompleteShutdown(Stream); + + // + // Remove any flags we shouldn't be sending now that the receive + // direction is closed. + // + QuicSendClearStreamSendFlag( + &Stream->Connection->Send, Stream, - Stream->RecvBuffer.BaseOffset >= Stream->RecvMaxLength); + QUIC_STREAM_SEND_FLAG_MAX_DATA | QUIC_STREAM_SEND_FLAG_RECV_ABORT); + + // + // Indicate to the app that the stream has been aborted by the peer. + // + QUIC_STREAM_EVENT Event; + Event.Type = QUIC_STREAM_EVENT_PEER_SEND_ABORTED; + Event.PEER_SEND_ABORTED.ErrorCode = ErrorCode; + QuicTraceLogStreamVerbose( + IndicatePeerSendAbort, + Stream, + "Indicating QUIC_STREAM_EVENT_PEER_SEND_ABORTED (0x%llX)", + ErrorCode); + (void)QuicStreamIndicateEvent(Stream, &Event); } } From dedeb16a326b7b21270015b6f7b2966c72d2a1fb Mon Sep 17 00:00:00 2001 From: Jack He Date: Tue, 22 Aug 2023 11:15:19 -0700 Subject: [PATCH 028/123] fail if local resets the send before setting offset --- src/core/stream.c | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/core/stream.c b/src/core/stream.c index c2f2e35e50..b5aa0c8414 100644 --- a/src/core/stream.c +++ b/src/core/stream.c @@ -672,6 +672,11 @@ QuicStreamParamSet( break; } + if (Stream->Flags.LocalCloseReset) { + Status = QUIC_STATUS_INVALID_STATE; + break; + } + Stream->ReliableOffsetSend = *(uint64_t*)Buffer; QuicTraceLogStreamInfo( From b5bcf5b08ee082d5bbb561740b275356e89059f6 Mon Sep 17 00:00:00 2001 From: Jack He Date: Tue, 22 Aug 2023 11:39:33 -0700 Subject: [PATCH 029/123] add checks and remove bad while loop --- src/core/stream_send.c | 20 ++++++++------------ 1 file changed, 8 insertions(+), 12 deletions(-) diff --git a/src/core/stream_send.c b/src/core/stream_send.c index b03ede583c..88aec58197 100644 --- a/src/core/stream_send.c +++ b/src/core/stream_send.c @@ -235,26 +235,23 @@ QuicStreamSendShutdown( QUIC_STREAM_SEND_FLAG_FIN); } } else { - uint64_t CurrOffset = Stream->UnAckedOffset; - while (ApiSendRequests != NULL && CurrOffset < Stream->ReliableOffsetSend) { + if (Stream->Flags.LocalCloseReset || Stream->Flags.LocalCloseFin) { // - // Deliver the necessary send requests prior to aborting. + // We have already closed the stream (graceful or abortive) so we + // can't reliably abort it. // - QUIC_SEND_REQUEST* SendRequest = ApiSendRequests; - ApiSendRequests = ApiSendRequests->Next; - QuicStreamCompleteSendRequest(Stream, SendRequest, TRUE, FALSE); - CurrOffset++; + goto Exit; } - + Stream->Flags.LocalCloseResetReliable = TRUE; // // Queue up a RESET RELIABLE STREAM frame to be sent. // QuicSendSetStreamSendFlag( &Stream->Connection->Send, Stream, - QUIC_STREAM_SEND_FLAG_FIN, // TODO; Change this. - DelaySend); - } + QUIC_STREAM_SEND_FLAG_SEND_ABORT, + FALSE); +} QuicStreamSendDumpState(Stream); @@ -1103,7 +1100,6 @@ QuicStreamSendWrite( AvailableBufferLength, Builder->Datagram->Buffer); FrameType = QUIC_FRAME_RELIABLE_RESET_STREAM; - Stream->Flags.LocalCloseResetReliable = TRUE; } else { QUIC_RESET_STREAM_EX Frame = { Stream->ID, Stream->SendShutdownErrorCode, Stream->MaxSentLength }; CanEncodeFrame = QuicResetStreamFrameEncode( From 510abc46a83f086126a4462a014b7ff9c0ccd2d8 Mon Sep 17 00:00:00 2001 From: Jack He Date: Tue, 22 Aug 2023 17:09:01 -0700 Subject: [PATCH 030/123] Add another unit test to send multiple times --- src/test/MsQuicTests.h | 9 +- src/test/bin/quic_gtest.cpp | 9 ++ src/test/bin/winkernel/control.cpp | 5 ++ src/test/lib/DataTest.cpp | 136 ++++++++++++++++++++++++++--- 4 files changed, 148 insertions(+), 11 deletions(-) diff --git a/src/test/MsQuicTests.h b/src/test/MsQuicTests.h index 878ff16436..795c4e6f83 100644 --- a/src/test/MsQuicTests.h +++ b/src/test/MsQuicTests.h @@ -534,6 +534,10 @@ void QuicTestStreamReliableReset( ); +void +QuicTestStreamReliableResetMultipleSends( +); + void QuicTestStreamBlockUnblockConnFlowControl( _In_ BOOLEAN Bidirectional @@ -1200,4 +1204,7 @@ typedef struct { #define IOCTL_QUIC_RUN_STREAM_RELIABLE_RESET \ QUIC_CTL_CODE(112, METHOD_BUFFERED, FILE_WRITE_DATA) -#define QUIC_MAX_IOCTL_FUNC_CODE 112 +#define IOCTL_QUIC_RUN_STREAM_RELIABLE_RESET_MULTIPLE_SENDS \ + QUIC_CTL_CODE(113, METHOD_BUFFERED, FILE_WRITE_DATA) + +#define QUIC_MAX_IOCTL_FUNC_CODE 113 diff --git a/src/test/bin/quic_gtest.cpp b/src/test/bin/quic_gtest.cpp index 4309f7d7da..60177f78a9 100644 --- a/src/test/bin/quic_gtest.cpp +++ b/src/test/bin/quic_gtest.cpp @@ -2073,6 +2073,15 @@ TEST(Misc, StreamReliableReset) { } } +TEST(Misc, StreamReliableResetMultipleSends) { + TestLogger Logger("StreamReliableResetMultipleSends"); + if (TestingKernelMode) { + ASSERT_TRUE(DriverClient.Run(IOCTL_QUIC_RUN_STREAM_RELIABLE_RESET_MULTIPLE_SENDS)); + } else { + QuicTestStreamReliableResetMultipleSends(); + } +} + TEST(Misc, StreamBlockUnblockUnidiConnFlowControl) { TestLogger Logger("StreamBlockUnblockUnidiConnFlowControl"); if (TestingKernelMode) { diff --git a/src/test/bin/winkernel/control.cpp b/src/test/bin/winkernel/control.cpp index bc847a09b0..a282c44e9c 100644 --- a/src/test/bin/winkernel/control.cpp +++ b/src/test/bin/winkernel/control.cpp @@ -484,6 +484,7 @@ size_t QUIC_IOCTL_BUFFER_SIZES[] = sizeof(QUIC_RUN_CUSTOM_CERT_VALIDATION), sizeof(QUIC_RUN_RELIABLE_RESET_NEGOTIATION), 0, + 0, }; CXPLAT_STATIC_ASSERT( @@ -1353,6 +1354,10 @@ QuicTestCtlEvtIoDeviceControl( case IOCTL_QUIC_RUN_STREAM_RELIABLE_RESET: QuicTestCtlRun(QuicTestStreamReliableReset()); break; + + case IOCTL_QUIC_RUN_STREAM_RELIABLE_RESET_MULTIPLE_SENDS: + QuicTestCtlRun(QuicTestStreamReliableResetMultipleSends()); + break; #endif default: Status = STATUS_NOT_IMPLEMENTED; diff --git a/src/test/lib/DataTest.cpp b/src/test/lib/DataTest.cpp index 9be0228f77..d0e07937d0 100644 --- a/src/test/lib/DataTest.cpp +++ b/src/test/lib/DataTest.cpp @@ -3199,10 +3199,10 @@ QuicTestStreamReliableReset( static QUIC_STATUS ClientStreamCallback(_In_ MsQuicStream* Stream, _In_opt_ void* ClientContext, _Inout_ QUIC_STREAM_EVENT* Event) { auto TestContext = (StreamReliableReset*)ClientContext; // remove - Stream->GetReliableOffset(&TestContext->ReliableOffsetSendSideClient); - Stream->GetReliableOffsetRecv(&TestContext->ReliableOffsetRecvSideClient); - std::cout << "Client Side Stream Send: " << TestContext->ReliableOffsetSendSideClient << ", "; - std::cout << " Client Side Stream Recv: " << TestContext->ReliableOffsetRecvSideClient << std::endl; + Stream->GetReliableOffset(&TestContext->ReliableOffsetSendSideClient); + Stream->GetReliableOffsetRecv(&TestContext->ReliableOffsetRecvSideClient); + std::cout << Event->Type << " Client Side Stream Send: " << TestContext->ReliableOffsetSendSideClient << ", "; + std::cout << " Client Side Stream Recv: " << TestContext->ReliableOffsetRecvSideClient << std::endl; // remove. if (Event->Type == QUIC_STREAM_EVENT_SHUTDOWN_COMPLETE) { TestContext->ClientStreamShutdownComplete.Set(); @@ -3213,11 +3213,11 @@ QuicTestStreamReliableReset( static QUIC_STATUS ServerStreamCallback(_In_ MsQuicStream* Stream, _In_opt_ void* ServerContext, _Inout_ QUIC_STREAM_EVENT* Event) { auto TestContext = (StreamReliableReset*)ServerContext; // remove - Stream->GetReliableOffset(&TestContext->ReliableOffsetSendSideServer); - Stream->GetReliableOffsetRecv(&TestContext->ReliableOffsetRecvSideServer); - std::cout << "Server Side Stream Send: " << TestContext->ReliableOffsetSendSideServer << ", "; - std::cout << " Server Side Stream Recv: " << TestContext->ReliableOffsetRecvSideServer << std::endl; - // remove. + Stream->GetReliableOffset(&TestContext->ReliableOffsetSendSideServer); + Stream->GetReliableOffsetRecv(&TestContext->ReliableOffsetRecvSideServer); + std::cout << Event->Type << " Server Side Stream Send: " << TestContext->ReliableOffsetSendSideServer << ", "; + std::cout << " Server Side Stream Recv: " << TestContext->ReliableOffsetRecvSideServer << std::endl; + // remove. if (Event->Type == QUIC_STREAM_EVENT_RECEIVE) { TestContext->ReceivedBufferSize += Event->RECEIVE.TotalBufferLength; } @@ -3270,6 +3270,9 @@ QuicTestStreamReliableReset( TEST_TRUE(Listener.LastConnection->HandshakeComplete); CxPlatSleep(50); // Wait for things to idle out + StreamReliableReset Context0; + MsQuicStream Stream0(Connection, QUIC_STREAM_OPEN_FLAG_NONE, CleanUpManual, StreamReliableReset::ClientStreamCallback, &Context0); + MsQuicStream Stream(Connection, QUIC_STREAM_OPEN_FLAG_NONE, CleanUpManual, StreamReliableReset::ClientStreamCallback, &Context); TEST_QUIC_SUCCEEDED(Stream.GetInitStatus()); TEST_QUIC_SUCCEEDED(Stream.Start()); @@ -3285,6 +3288,119 @@ QuicTestStreamReliableReset( TEST_TRUE(Context.ReliableOffsetRecvSideClient == 0); TEST_TRUE(Context.ReliableOffsetSendSideServer == 0); TEST_TRUE(Context.ReliableOffsetRecvSideServer == RELIABLE_SIZE); - TEST_TRUE(Context.ReceivedBufferSize >= RELIABLE_SIZE); } + + + +void +QuicTestStreamReliableResetMultipleSends( +) { + #define BUFFER_SIZE 10000 + #define RELIABLE_SIZE 5000 + + struct StreamReliableReset { + + CxPlatEvent ClientStreamShutdownComplete; + uint64_t ReceivedBufferSize; + uint64_t ReliableOffsetSendSideClient = 69420; + uint64_t ReliableOffsetRecvSideClient = 69420; + uint64_t ReliableOffsetSendSideServer = 69420; + uint64_t ReliableOffsetRecvSideServer = 69420; + + static QUIC_STATUS ClientStreamCallback(_In_ MsQuicStream* Stream, _In_opt_ void* ClientContext, _Inout_ QUIC_STREAM_EVENT* Event) { + auto TestContext = (StreamReliableReset*)ClientContext; + // remove + Stream->GetReliableOffset(&TestContext->ReliableOffsetSendSideClient); + Stream->GetReliableOffsetRecv(&TestContext->ReliableOffsetRecvSideClient); + std::cout << Event->Type << " Client Side Stream Send: " << TestContext->ReliableOffsetSendSideClient << ", "; + std::cout << " Client Side Stream Recv: " << TestContext->ReliableOffsetRecvSideClient << std::endl; + // remove. + if (Event->Type == QUIC_STREAM_EVENT_SHUTDOWN_COMPLETE) { + TestContext->ClientStreamShutdownComplete.Set(); + } + return QUIC_STATUS_SUCCESS; + } + + static QUIC_STATUS ServerStreamCallback(_In_ MsQuicStream* Stream, _In_opt_ void* ServerContext, _Inout_ QUIC_STREAM_EVENT* Event) { + auto TestContext = (StreamReliableReset*)ServerContext; + // remove + Stream->GetReliableOffset(&TestContext->ReliableOffsetSendSideServer); + Stream->GetReliableOffsetRecv(&TestContext->ReliableOffsetRecvSideServer); + std::cout << Event->Type << " Server Side Stream Send: " << TestContext->ReliableOffsetSendSideServer << ", "; + std::cout << " Server Side Stream Recv: " << TestContext->ReliableOffsetRecvSideServer << std::endl; + // remove. + if (Event->Type == QUIC_STREAM_EVENT_RECEIVE) { + TestContext->ReceivedBufferSize += Event->RECEIVE.TotalBufferLength; + } + if (Event->Type == QUIC_STREAM_EVENT_PEER_SEND_SHUTDOWN) { + Stream->Shutdown(QUIC_STREAM_SHUTDOWN_FLAG_ABORT_SEND); + } + return QUIC_STATUS_SUCCESS; + } + + static QUIC_STATUS ConnCallback(_In_ MsQuicConnection*, _In_opt_ void* Context, _Inout_ QUIC_CONNECTION_EVENT* Event) { + if (Event->Type == QUIC_CONNECTION_EVENT_PEER_STREAM_STARTED) { + new(std::nothrow) MsQuicStream(Event->PEER_STREAM_STARTED.Stream, CleanUpAutoDelete, ServerStreamCallback, Context); + } + return QUIC_STATUS_SUCCESS; + } +}; + + MsQuicRegistration Registration(true); + TEST_TRUE(Registration.IsValid()); + + MsQuicSettings TestSettings; + TestSettings.SetReliableResetEnabled(true); + TestSettings.SetPeerBidiStreamCount(1); + + MsQuicConfiguration ServerConfiguration(Registration, "MsQuicTest", TestSettings, ServerSelfSignedCredConfig); + TEST_QUIC_SUCCEEDED(ServerConfiguration.GetInitStatus()); + + MsQuicConfiguration ClientConfiguration(Registration, "MsQuicTest", TestSettings, MsQuicCredentialConfig()); + TEST_QUIC_SUCCEEDED(ClientConfiguration.GetInitStatus()); + + StreamReliableReset Context; + uint8_t SendDataBuffer[BUFFER_SIZE]; + + QUIC_BUFFER SendBuffer { sizeof(SendDataBuffer), SendDataBuffer }; + Context.ReceivedBufferSize = 0; + + MsQuicAutoAcceptListener Listener(Registration, ServerConfiguration, StreamReliableReset::ConnCallback, &Context); + TEST_QUIC_SUCCEEDED(Listener.GetInitStatus()); + TEST_QUIC_SUCCEEDED(Listener.Start("MsQuicTest")); + QuicAddr ServerLocalAddr; + TEST_QUIC_SUCCEEDED(Listener.GetLocalAddr(ServerLocalAddr)); + + MsQuicConnection Connection(Registration); + TEST_QUIC_SUCCEEDED(Connection.GetInitStatus()); + + TEST_QUIC_SUCCEEDED(Connection.Start(ClientConfiguration, ServerLocalAddr.GetFamily(), QUIC_TEST_LOOPBACK_FOR_AF(ServerLocalAddr.GetFamily()), ServerLocalAddr.GetPort())); + TEST_TRUE(Connection.HandshakeCompleteEvent.WaitTimeout(TestWaitTimeout)); + TEST_TRUE(Connection.HandshakeComplete); + TEST_TRUE(Listener.LastConnection->HandshakeCompleteEvent.WaitTimeout(TestWaitTimeout)); + TEST_TRUE(Listener.LastConnection->HandshakeComplete); + CxPlatSleep(50); // Wait for things to idle out + + StreamReliableReset Context0; + MsQuicStream Stream0(Connection, QUIC_STREAM_OPEN_FLAG_NONE, CleanUpManual, StreamReliableReset::ClientStreamCallback, &Context0); + + MsQuicStream Stream(Connection, QUIC_STREAM_OPEN_FLAG_NONE, CleanUpManual, StreamReliableReset::ClientStreamCallback, &Context); + TEST_QUIC_SUCCEEDED(Stream.GetInitStatus()); + TEST_QUIC_SUCCEEDED(Stream.Start()); + TEST_QUIC_SUCCEEDED(Stream.Send(&SendBuffer, 1, QUIC_SEND_FLAG_DELAY_SEND, &Context)); + TEST_QUIC_SUCCEEDED(Stream.Send(&SendBuffer, 1, QUIC_SEND_FLAG_DELAY_SEND, &Context)); + TEST_QUIC_SUCCEEDED(Stream.Send(&SendBuffer, 1, QUIC_SEND_FLAG_DELAY_SEND, &Context)); + TEST_QUIC_SUCCEEDED(Stream.SetReliableOffset(RELIABLE_SIZE)); + TEST_QUIC_SUCCEEDED(Stream.Shutdown(0)); // Queues up a shutdown operation. + // Should behave similar to QUIC_STREAM_SHUTDOWN_FLAG_GRACEFUL, with some restrictions. + TEST_TRUE(Context.ClientStreamShutdownComplete.WaitTimeout(TestWaitTimeout)); + // Remove + std::cout << "ReceivedBufferSize: " << Context.ReceivedBufferSize << std::endl; + // Remove. + TEST_TRUE(Context.ReliableOffsetSendSideClient == RELIABLE_SIZE); + TEST_TRUE(Context.ReliableOffsetRecvSideClient == 0); + TEST_TRUE(Context.ReliableOffsetSendSideServer == 0); + TEST_TRUE(Context.ReliableOffsetRecvSideServer == RELIABLE_SIZE); + TEST_TRUE(Context.ReceivedBufferSize >= RELIABLE_SIZE); +} \ No newline at end of file From bd7fd86446dcc20db8b4c2d0a029ab7fe2bfcea2 Mon Sep 17 00:00:00 2001 From: Jack He Date: Tue, 22 Aug 2023 17:19:02 -0700 Subject: [PATCH 031/123] ack path update: ensure we only close send path if enough bytes get ack'd --- src/core/loss_detection.c | 2 +- src/core/stream.h | 9 ++++++ src/core/stream_send.c | 60 ++++++++++++++++++++++++++++++++++++++- 3 files changed, 69 insertions(+), 2 deletions(-) diff --git a/src/core/loss_detection.c b/src/core/loss_detection.c index 4b65427239..545a59c0be 100644 --- a/src/core/loss_detection.c +++ b/src/core/loss_detection.c @@ -552,7 +552,7 @@ QuicLossDetectionOnPacketAcknowledged( break; case QUIC_FRAME_RELIABLE_RESET_STREAM: - QuicStreamOnResetAck(Packet->Frames[i].RELIABLE_RESET_STREAM.Stream); + QuicStreamOnResetReliableAck(Packet->Frames[i].RELIABLE_RESET_STREAM.Stream); break; case QUIC_FRAME_CRYPTO: diff --git a/src/core/stream.h b/src/core/stream.h index 7112a9ba12..29aa4e2a69 100644 --- a/src/core/stream.h +++ b/src/core/stream.h @@ -910,6 +910,15 @@ QuicStreamOnResetAck( _In_ QUIC_STREAM* Stream ); +// +// Called when an ACK is received for a RELIABLE_RESET frame we sent. +// +_IRQL_requires_max_(PASSIVE_LEVEL) +void +QuicStreamOnResetReliableAck( + _In_ QUIC_STREAM* Stream + ); + // // Dumps send state to the logs. // diff --git a/src/core/stream_send.c b/src/core/stream_send.c index 88aec58197..9c74dabade 100644 --- a/src/core/stream_send.c +++ b/src/core/stream_send.c @@ -235,7 +235,7 @@ QuicStreamSendShutdown( QUIC_STREAM_SEND_FLAG_FIN); } } else { - if (Stream->Flags.LocalCloseReset || Stream->Flags.LocalCloseFin) { + if (Stream->Flags.LocalCloseReset) { // // We have already closed the stream (graceful or abortive) so we // can't reliably abort it. @@ -243,6 +243,7 @@ QuicStreamSendShutdown( goto Exit; } Stream->Flags.LocalCloseResetReliable = TRUE; + Stream->SendShutdownErrorCode = ErrorCode; // // Queue up a RESET RELIABLE STREAM frame to be sent. // @@ -1509,6 +1510,38 @@ QuicStreamOnAck( } } + // + // If this stream has been reset reliably, we only close if we have received enough bytes. + // + BOOLEAN ReliableResetShutdown = !Stream->Flags.LocalCloseAcked && Stream->Flags.LocalCloseResetReliable && Stream->UnAckedOffset >= Stream->ReliableOffsetSend; + if (ReliableResetShutdown) { + Stream->Flags.LocalCloseAcked = TRUE; + QuicTraceEvent( + StreamSendState, + "[strm][%p] Send State: %hhu", + Stream, + QuicStreamSendGetState(Stream)); + // + // Cleanup. + // + // while (Stream->SendRequests) { + // QUIC_SEND_REQUEST* Req = Stream->SendRequests; + // // + // // Ignore requests that should have been completed, i.e., < ReliableOffsetSend + // // + // if (Req->StreamOffset + Req->TotalLength < Stream->ReliableOffsetSend) { + // break; + // } + // Stream->SendRequests = Req->Next; + // if (Stream->SendRequests == NULL) { + // Stream->SendRequestsTail = &Stream->SendRequests; + // } + // QuicStreamCompleteSendRequest(Stream, Req, FALSE, TRUE); + // } + QuicStreamTryCompleteShutdown(Stream); + QuicStreamIndicateSendShutdownComplete(Stream, FALSE); + } + if (!QuicStreamHasPendingStreamData(Stream)) { // // Make sure the stream isn't queued to send any stream data. @@ -1545,6 +1578,31 @@ QuicStreamOnResetAck( } } +_IRQL_requires_max_(PASSIVE_LEVEL) +void +QuicStreamOnResetReliableAck( + _In_ QUIC_STREAM* Stream +) { + if (Stream->UnAckedOffset >= Stream->ReliableOffsetSend && !Stream->Flags.LocalCloseAcked) { + Stream->Flags.LocalCloseAcked = TRUE; + QuicTraceEvent( + StreamSendState, + "[strm][%p] Send State: %hhu", + Stream, + QuicStreamSendGetState(Stream)); + // + // Cleanup. + // + // while (Stream->SendRequests) { + // QUIC_SEND_REQUEST* Req = Stream->SendRequests; + // Stream->SendRequests = Stream->SendRequests->Next; + // QuicStreamCompleteSendRequest(Stream, Req, TRUE, TRUE); + // } + QuicStreamTryCompleteShutdown(Stream); + QuicStreamIndicateSendShutdownComplete(Stream, FALSE); + } +} + _IRQL_requires_max_(PASSIVE_LEVEL) void QuicStreamSendDumpState( From 6d58b12217ab0f77a6afdbd88f26c6dc07307d30 Mon Sep 17 00:00:00 2001 From: Jack He Date: Wed, 23 Aug 2023 12:02:27 -0700 Subject: [PATCH 032/123] update tests and validate other paths --- src/core/stream.h | 9 +++++++ src/core/stream_send.c | 55 +++++++++++++++++++++------------------ src/test/lib/DataTest.cpp | 23 +++++++--------- 3 files changed, 49 insertions(+), 38 deletions(-) diff --git a/src/core/stream.h b/src/core/stream.h index 29aa4e2a69..db0e6f8edb 100644 --- a/src/core/stream.h +++ b/src/core/stream.h @@ -919,6 +919,15 @@ QuicStreamOnResetReliableAck( _In_ QUIC_STREAM* Stream ); +// +// Cleanups up state once we finish processing a RELIABLE_RESET frame. +// +_IRQL_requires_max_(PASSIVE_LEVEL) +void +QuicStreamCleanupReliableReset( + _In_ QUIC_STREAM* Stream + ); + // // Dumps send state to the logs. // diff --git a/src/core/stream_send.c b/src/core/stream_send.c index 9c74dabade..713c31668c 100644 --- a/src/core/stream_send.c +++ b/src/core/stream_send.c @@ -1521,24 +1521,8 @@ QuicStreamOnAck( "[strm][%p] Send State: %hhu", Stream, QuicStreamSendGetState(Stream)); - // - // Cleanup. - // - // while (Stream->SendRequests) { - // QUIC_SEND_REQUEST* Req = Stream->SendRequests; - // // - // // Ignore requests that should have been completed, i.e., < ReliableOffsetSend - // // - // if (Req->StreamOffset + Req->TotalLength < Stream->ReliableOffsetSend) { - // break; - // } - // Stream->SendRequests = Req->Next; - // if (Stream->SendRequests == NULL) { - // Stream->SendRequestsTail = &Stream->SendRequests; - // } - // QuicStreamCompleteSendRequest(Stream, Req, FALSE, TRUE); - // } QuicStreamTryCompleteShutdown(Stream); + QuicStreamCleanupReliableReset(Stream); QuicStreamIndicateSendShutdownComplete(Stream, FALSE); } @@ -1560,6 +1544,34 @@ QuicStreamOnAck( QuicStreamValidateRecoveryState(Stream); } +_IRQL_requires_max_(PASSIVE_LEVEL) +void +QuicStreamCleanupReliableReset( + _In_ QUIC_STREAM* Stream +) { + // + // Cleanup. Cancels all send requests with offsets after ReliableOffsetSend. + // Assume this function gets called only when we're about to close the SEND + // Path of this stream once sufficient data has been received and ACK'd by the peer. + // + while (Stream->SendRequests) { + QUIC_SEND_REQUEST* Req = Stream->SendRequests; + // + // Ignore send requests that should have been ACK'd, i.e., < ReliableOffsetSend + // + if (Req->StreamOffset + Req->TotalLength < Stream->ReliableOffsetSend) { + continue; + } + Stream->SendRequests = Req->Next; + if (Stream->SendRequests == NULL) { + Stream->SendRequestsTail = &Stream->SendRequests; + } + QuicStreamCompleteSendRequest(Stream, Req, FALSE, TRUE); + } + QuicStreamSendDumpState(Stream); + QuicStreamValidateRecoveryState(Stream); +} + _IRQL_requires_max_(PASSIVE_LEVEL) void QuicStreamOnResetAck( @@ -1590,14 +1602,7 @@ QuicStreamOnResetReliableAck( "[strm][%p] Send State: %hhu", Stream, QuicStreamSendGetState(Stream)); - // - // Cleanup. - // - // while (Stream->SendRequests) { - // QUIC_SEND_REQUEST* Req = Stream->SendRequests; - // Stream->SendRequests = Stream->SendRequests->Next; - // QuicStreamCompleteSendRequest(Stream, Req, TRUE, TRUE); - // } + QuicStreamCleanupReliableReset(Stream); QuicStreamTryCompleteShutdown(Stream); QuicStreamIndicateSendShutdownComplete(Stream, FALSE); } diff --git a/src/test/lib/DataTest.cpp b/src/test/lib/DataTest.cpp index d0e07937d0..4c415608b9 100644 --- a/src/test/lib/DataTest.cpp +++ b/src/test/lib/DataTest.cpp @@ -3185,7 +3185,7 @@ QuicTestStreamReliableReset( ) { #define BUFFER_SIZE 10000 - #define RELIABLE_SIZE 5000 + #define RELIABLE_SIZE 1 struct StreamReliableReset { @@ -3217,7 +3217,7 @@ QuicTestStreamReliableReset( Stream->GetReliableOffsetRecv(&TestContext->ReliableOffsetRecvSideServer); std::cout << Event->Type << " Server Side Stream Send: " << TestContext->ReliableOffsetSendSideServer << ", "; std::cout << " Server Side Stream Recv: " << TestContext->ReliableOffsetRecvSideServer << std::endl; - // remove. + // remove. if (Event->Type == QUIC_STREAM_EVENT_RECEIVE) { TestContext->ReceivedBufferSize += Event->RECEIVE.TotalBufferLength; } @@ -3284,10 +3284,10 @@ QuicTestStreamReliableReset( // Remove std::cout << "ReceivedBufferSize: " << Context.ReceivedBufferSize << std::endl; // Remove. - TEST_TRUE(Context.ReliableOffsetSendSideClient == RELIABLE_SIZE); - TEST_TRUE(Context.ReliableOffsetRecvSideClient == 0); - TEST_TRUE(Context.ReliableOffsetSendSideServer == 0); - TEST_TRUE(Context.ReliableOffsetRecvSideServer == RELIABLE_SIZE); + // TEST_TRUE(Context.ReliableOffsetSendSideClient == RELIABLE_SIZE); + // TEST_TRUE(Context.ReliableOffsetRecvSideClient == 0); + // TEST_TRUE(Context.ReliableOffsetSendSideServer == 0); + // TEST_TRUE(Context.ReliableOffsetRecvSideServer == RELIABLE_SIZE); TEST_TRUE(Context.ReceivedBufferSize >= RELIABLE_SIZE); } @@ -3296,9 +3296,6 @@ QuicTestStreamReliableReset( void QuicTestStreamReliableResetMultipleSends( ) { - #define BUFFER_SIZE 10000 - #define RELIABLE_SIZE 5000 - struct StreamReliableReset { CxPlatEvent ClientStreamShutdownComplete; @@ -3398,9 +3395,9 @@ QuicTestStreamReliableResetMultipleSends( // Remove std::cout << "ReceivedBufferSize: " << Context.ReceivedBufferSize << std::endl; // Remove. - TEST_TRUE(Context.ReliableOffsetSendSideClient == RELIABLE_SIZE); - TEST_TRUE(Context.ReliableOffsetRecvSideClient == 0); - TEST_TRUE(Context.ReliableOffsetSendSideServer == 0); - TEST_TRUE(Context.ReliableOffsetRecvSideServer == RELIABLE_SIZE); + // TEST_TRUE(Context.ReliableOffsetSendSideClient == RELIABLE_SIZE); + // TEST_TRUE(Context.ReliableOffsetRecvSideClient == 0); + // TEST_TRUE(Context.ReliableOffsetSendSideServer == 0); + // TEST_TRUE(Context.ReliableOffsetRecvSideServer == RELIABLE_SIZE); TEST_TRUE(Context.ReceivedBufferSize >= RELIABLE_SIZE); } \ No newline at end of file From b9f02e619f2b78c966f797a49f1a614b92f4b07b Mon Sep 17 00:00:00 2001 From: Jack He Date: Thu, 24 Aug 2023 01:25:24 -0700 Subject: [PATCH 033/123] add further logging --- src/test/lib/DataTest.cpp | 41 +++++++++++++++++++++++++-------------- 1 file changed, 26 insertions(+), 15 deletions(-) diff --git a/src/test/lib/DataTest.cpp b/src/test/lib/DataTest.cpp index 4c415608b9..3b1a71c230 100644 --- a/src/test/lib/DataTest.cpp +++ b/src/test/lib/DataTest.cpp @@ -3180,12 +3180,23 @@ QuicTestConnectAndIdleForDestCidChange( } } +std::vector IHateC = {"QUIC_STREAM_EVENT_START_COMPLETE", + "QUIC_STREAM_EVENT_RECEIVE", + "QUIC_STREAM_EVENT_SEND_COMPLETE", + "QUIC_STREAM_EVENT_PEER_SEND_SHUTDOWN", + "QUIC_STREAM_EVENT_PEER_SEND_ABORTED", + "QUIC_STREAM_EVENT_PEER_RECEIVE_ABORTED", + "QUIC_STREAM_EVENT_SEND_SHUTDOWN_COMPLETE", + "QUIC_STREAM_EVENT_SHUTDOWN_COMPLETE", + "QUIC_STREAM_EVENT_IDEAL_SEND_BUFFER_SIZE", + "QUIC_STREAM_EVENT_PEER_ACCEPTED"}; + void QuicTestStreamReliableReset( ) { #define BUFFER_SIZE 10000 - #define RELIABLE_SIZE 1 + #define RELIABLE_SIZE 5000 struct StreamReliableReset { @@ -3201,7 +3212,7 @@ QuicTestStreamReliableReset( // remove Stream->GetReliableOffset(&TestContext->ReliableOffsetSendSideClient); Stream->GetReliableOffsetRecv(&TestContext->ReliableOffsetRecvSideClient); - std::cout << Event->Type << " Client Side Stream Send: " << TestContext->ReliableOffsetSendSideClient << ", "; + std::cout << IHateC[Event->Type] << " Client Side Stream Send: " << TestContext->ReliableOffsetSendSideClient << ", "; std::cout << " Client Side Stream Recv: " << TestContext->ReliableOffsetRecvSideClient << std::endl; // remove. if (Event->Type == QUIC_STREAM_EVENT_SHUTDOWN_COMPLETE) { @@ -3215,7 +3226,7 @@ QuicTestStreamReliableReset( // remove Stream->GetReliableOffset(&TestContext->ReliableOffsetSendSideServer); Stream->GetReliableOffsetRecv(&TestContext->ReliableOffsetRecvSideServer); - std::cout << Event->Type << " Server Side Stream Send: " << TestContext->ReliableOffsetSendSideServer << ", "; + std::cout << IHateC[Event->Type] << " Server Side Stream Send: " << TestContext->ReliableOffsetSendSideServer << ", "; std::cout << " Server Side Stream Recv: " << TestContext->ReliableOffsetRecvSideServer << std::endl; // remove. if (Event->Type == QUIC_STREAM_EVENT_RECEIVE) { @@ -3282,12 +3293,12 @@ QuicTestStreamReliableReset( // Should behave similar to QUIC_STREAM_SHUTDOWN_FLAG_GRACEFUL, with some restrictions. TEST_TRUE(Context.ClientStreamShutdownComplete.WaitTimeout(TestWaitTimeout)); // Remove - std::cout << "ReceivedBufferSize: " << Context.ReceivedBufferSize << std::endl; + std::cout << ">>>>>>>>>>> ReceivedBufferSize: " << Context.ReceivedBufferSize << std::endl; // Remove. - // TEST_TRUE(Context.ReliableOffsetSendSideClient == RELIABLE_SIZE); - // TEST_TRUE(Context.ReliableOffsetRecvSideClient == 0); - // TEST_TRUE(Context.ReliableOffsetSendSideServer == 0); - // TEST_TRUE(Context.ReliableOffsetRecvSideServer == RELIABLE_SIZE); + TEST_TRUE(Context.ReliableOffsetSendSideClient == RELIABLE_SIZE); + TEST_TRUE(Context.ReliableOffsetRecvSideClient == 0); + TEST_TRUE(Context.ReliableOffsetSendSideServer == 0); + TEST_TRUE(Context.ReliableOffsetRecvSideServer == RELIABLE_SIZE); TEST_TRUE(Context.ReceivedBufferSize >= RELIABLE_SIZE); } @@ -3310,7 +3321,7 @@ QuicTestStreamReliableResetMultipleSends( // remove Stream->GetReliableOffset(&TestContext->ReliableOffsetSendSideClient); Stream->GetReliableOffsetRecv(&TestContext->ReliableOffsetRecvSideClient); - std::cout << Event->Type << " Client Side Stream Send: " << TestContext->ReliableOffsetSendSideClient << ", "; + std::cout << IHateC[Event->Type] << " Client Side Stream Send: " << TestContext->ReliableOffsetSendSideClient << ", "; std::cout << " Client Side Stream Recv: " << TestContext->ReliableOffsetRecvSideClient << std::endl; // remove. if (Event->Type == QUIC_STREAM_EVENT_SHUTDOWN_COMPLETE) { @@ -3321,10 +3332,10 @@ QuicTestStreamReliableResetMultipleSends( static QUIC_STATUS ServerStreamCallback(_In_ MsQuicStream* Stream, _In_opt_ void* ServerContext, _Inout_ QUIC_STREAM_EVENT* Event) { auto TestContext = (StreamReliableReset*)ServerContext; - // remove + // remove Stream->GetReliableOffset(&TestContext->ReliableOffsetSendSideServer); Stream->GetReliableOffsetRecv(&TestContext->ReliableOffsetRecvSideServer); - std::cout << Event->Type << " Server Side Stream Send: " << TestContext->ReliableOffsetSendSideServer << ", "; + std::cout << IHateC[Event->Type] << " Server Side Stream Send: " << TestContext->ReliableOffsetSendSideServer << ", "; std::cout << " Server Side Stream Recv: " << TestContext->ReliableOffsetRecvSideServer << std::endl; // remove. if (Event->Type == QUIC_STREAM_EVENT_RECEIVE) { @@ -3395,9 +3406,9 @@ QuicTestStreamReliableResetMultipleSends( // Remove std::cout << "ReceivedBufferSize: " << Context.ReceivedBufferSize << std::endl; // Remove. - // TEST_TRUE(Context.ReliableOffsetSendSideClient == RELIABLE_SIZE); - // TEST_TRUE(Context.ReliableOffsetRecvSideClient == 0); - // TEST_TRUE(Context.ReliableOffsetSendSideServer == 0); - // TEST_TRUE(Context.ReliableOffsetRecvSideServer == RELIABLE_SIZE); + TEST_TRUE(Context.ReliableOffsetSendSideClient == RELIABLE_SIZE); + TEST_TRUE(Context.ReliableOffsetRecvSideClient == 0); + TEST_TRUE(Context.ReliableOffsetSendSideServer == 0); + TEST_TRUE(Context.ReliableOffsetRecvSideServer == RELIABLE_SIZE); TEST_TRUE(Context.ReceivedBufferSize >= RELIABLE_SIZE); } \ No newline at end of file From a9078aad5876ed2b3c700fe9e66db149b9f99e2b Mon Sep 17 00:00:00 2001 From: Jack He Date: Thu, 24 Aug 2023 02:33:15 -0700 Subject: [PATCH 034/123] update endoffset check --- src/core/library.c | 2 +- src/core/stream_recv.c | 36 +++++++++++++++++++++--------------- src/test/lib/DataTest.cpp | 8 +------- 3 files changed, 23 insertions(+), 23 deletions(-) diff --git a/src/core/library.c b/src/core/library.c index d3de6de5eb..c68b202d72 100644 --- a/src/core/library.c +++ b/src/core/library.c @@ -530,7 +530,7 @@ MsQuicLibraryUninitialize( // CXPLAT_DBG_ASSERT(PerfCounters[QUIC_PERF_COUNTER_CONN_ACTIVE] == 0); CXPLAT_DBG_ASSERT(PerfCounters[QUIC_PERF_COUNTER_CONN_CONNECTED] == 0); - CXPLAT_DBG_ASSERT(PerfCounters[QUIC_PERF_COUNTER_STRM_ACTIVE] == 0); + // CXPLAT_DBG_ASSERT(PerfCounters[QUIC_PERF_COUNTER_STRM_ACTIVE] == 0); This is bad. Remember to uncomment once we fix the issue. CXPLAT_DBG_ASSERT(PerfCounters[QUIC_PERF_COUNTER_CONN_QUEUE_DEPTH] == 0); CXPLAT_DBG_ASSERT(PerfCounters[QUIC_PERF_COUNTER_CONN_OPER_QUEUE_DEPTH] == 0); CXPLAT_DBG_ASSERT(PerfCounters[QUIC_PERF_COUNTER_WORK_OPER_QUEUE_DEPTH] == 0); diff --git a/src/core/stream_recv.c b/src/core/stream_recv.c index 5e2da01787..e29dc67cf6 100644 --- a/src/core/stream_recv.c +++ b/src/core/stream_recv.c @@ -193,7 +193,7 @@ QuicStreamProcessReliableResetFrame( // // All data delivered. Deliver shutdown callback. // - Stream->Flags.ReceiveDataPending = TRUE; + Stream->Flags.ReceiveDataPending = FALSE; // // Shut down the stream. @@ -208,19 +208,25 @@ QuicStreamProcessReliableResetFrame( &Stream->Connection->Send, Stream, QUIC_STREAM_SEND_FLAG_MAX_DATA | QUIC_STREAM_SEND_FLAG_RECV_ABORT); + } - // - // Indicate to the app that the stream has been aborted by the peer. - // - QUIC_STREAM_EVENT Event; - Event.Type = QUIC_STREAM_EVENT_PEER_SEND_ABORTED; - Event.PEER_SEND_ABORTED.ErrorCode = ErrorCode; - QuicTraceLogStreamVerbose( - IndicatePeerSendAbort, - Stream, - "Indicating QUIC_STREAM_EVENT_PEER_SEND_ABORTED (0x%llX)", - ErrorCode); - (void)QuicStreamIndicateEvent(Stream, &Event); + if (!Stream->Flags.RemoteCloseAcked) { + Stream->Flags.RemoteCloseAcked = TRUE; + Stream->Flags.ReceiveDataPending = TRUE; + if (!Stream->Flags.SentStopSending) { + // + // Indicate to the app that the stream has been aborted by the peer. + // + QUIC_STREAM_EVENT Event; + Event.Type = QUIC_STREAM_EVENT_PEER_SEND_ABORTED; + Event.PEER_SEND_ABORTED.ErrorCode = ErrorCode; + QuicTraceLogStreamVerbose( + IndicatePeerSendAbort, + Stream, + "Indicating QUIC_STREAM_EVENT_PEER_SEND_ABORTED (0x%llX)", + ErrorCode); + (void)QuicStreamIndicateEvent(Stream, &Event); + } } } @@ -342,7 +348,7 @@ QuicStreamProcessStopSendingFrame( _In_ QUIC_VAR_INT ErrorCode ) { - if (!Stream->Flags.LocalCloseAcked && !Stream->Flags.LocalCloseReset) { + if (!Stream->Flags.LocalCloseAcked && !Stream->Flags.LocalCloseReset && !Stream->Flags.LocalCloseResetReliable) { // // The STOP_SENDING frame only triggers a state change if we aren't // completely closed gracefully (i.e. our close has been acknowledged) @@ -442,7 +448,7 @@ QuicStreamProcessStreamFrame( goto Error; } - if (EndOffset > Stream->RecvMaxLength) { + if (EndOffset > Stream->RecvMaxLength && !Stream->Flags.RemoteCloseResetReliable) { // // Frame goes past the FIN. // diff --git a/src/test/lib/DataTest.cpp b/src/test/lib/DataTest.cpp index 3b1a71c230..c1a101079a 100644 --- a/src/test/lib/DataTest.cpp +++ b/src/test/lib/DataTest.cpp @@ -3281,9 +3281,6 @@ QuicTestStreamReliableReset( TEST_TRUE(Listener.LastConnection->HandshakeComplete); CxPlatSleep(50); // Wait for things to idle out - StreamReliableReset Context0; - MsQuicStream Stream0(Connection, QUIC_STREAM_OPEN_FLAG_NONE, CleanUpManual, StreamReliableReset::ClientStreamCallback, &Context0); - MsQuicStream Stream(Connection, QUIC_STREAM_OPEN_FLAG_NONE, CleanUpManual, StreamReliableReset::ClientStreamCallback, &Context); TEST_QUIC_SUCCEEDED(Stream.GetInitStatus()); TEST_QUIC_SUCCEEDED(Stream.Start()); @@ -3390,9 +3387,6 @@ QuicTestStreamReliableResetMultipleSends( TEST_TRUE(Listener.LastConnection->HandshakeComplete); CxPlatSleep(50); // Wait for things to idle out - StreamReliableReset Context0; - MsQuicStream Stream0(Connection, QUIC_STREAM_OPEN_FLAG_NONE, CleanUpManual, StreamReliableReset::ClientStreamCallback, &Context0); - MsQuicStream Stream(Connection, QUIC_STREAM_OPEN_FLAG_NONE, CleanUpManual, StreamReliableReset::ClientStreamCallback, &Context); TEST_QUIC_SUCCEEDED(Stream.GetInitStatus()); TEST_QUIC_SUCCEEDED(Stream.Start()); @@ -3404,7 +3398,7 @@ QuicTestStreamReliableResetMultipleSends( // Should behave similar to QUIC_STREAM_SHUTDOWN_FLAG_GRACEFUL, with some restrictions. TEST_TRUE(Context.ClientStreamShutdownComplete.WaitTimeout(TestWaitTimeout)); // Remove - std::cout << "ReceivedBufferSize: " << Context.ReceivedBufferSize << std::endl; + std::cout << ">>>>>>>>>>> ReceivedBufferSize: " << Context.ReceivedBufferSize << std::endl; // Remove. TEST_TRUE(Context.ReliableOffsetSendSideClient == RELIABLE_SIZE); TEST_TRUE(Context.ReliableOffsetRecvSideClient == 0); From d0af2eacf21adb31f7ea18eb7389a5ad327bbdb8 Mon Sep 17 00:00:00 2001 From: Jack He Date: Thu, 24 Aug 2023 02:54:38 -0700 Subject: [PATCH 035/123] better progress --- src/core/library.c | 2 +- src/core/stream.h | 1 + src/core/stream_recv.c | 13 +++++++++++++ 3 files changed, 15 insertions(+), 1 deletion(-) diff --git a/src/core/library.c b/src/core/library.c index c68b202d72..d3de6de5eb 100644 --- a/src/core/library.c +++ b/src/core/library.c @@ -530,7 +530,7 @@ MsQuicLibraryUninitialize( // CXPLAT_DBG_ASSERT(PerfCounters[QUIC_PERF_COUNTER_CONN_ACTIVE] == 0); CXPLAT_DBG_ASSERT(PerfCounters[QUIC_PERF_COUNTER_CONN_CONNECTED] == 0); - // CXPLAT_DBG_ASSERT(PerfCounters[QUIC_PERF_COUNTER_STRM_ACTIVE] == 0); This is bad. Remember to uncomment once we fix the issue. + CXPLAT_DBG_ASSERT(PerfCounters[QUIC_PERF_COUNTER_STRM_ACTIVE] == 0); CXPLAT_DBG_ASSERT(PerfCounters[QUIC_PERF_COUNTER_CONN_QUEUE_DEPTH] == 0); CXPLAT_DBG_ASSERT(PerfCounters[QUIC_PERF_COUNTER_CONN_OPER_QUEUE_DEPTH] == 0); CXPLAT_DBG_ASSERT(PerfCounters[QUIC_PERF_COUNTER_WORK_OPER_QUEUE_DEPTH] == 0); diff --git a/src/core/stream.h b/src/core/stream.h index db0e6f8edb..1454db1d27 100644 --- a/src/core/stream.h +++ b/src/core/stream.h @@ -142,6 +142,7 @@ typedef union QUIC_STREAM_FLAGS { BOOLEAN ReceiveDataPending : 1; // Data (or FIN) is queued and ready for delivery. BOOLEAN ReceiveCallPending : 1; // There is an uncompleted receive to the app. BOOLEAN ReceiveCallActive : 1; // There is an active receive to the app. + BOOLEAN ReceiveClosedReliable : 1; // We closed the stream on the Recv side from a Reliable reset frame. BOOLEAN SendDelayed : 1; // A delayed send is currently queued. BOOLEAN HandleSendShutdown : 1; // Send shutdown complete callback delivered. diff --git a/src/core/stream_recv.c b/src/core/stream_recv.c index e29dc67cf6..534508a724 100644 --- a/src/core/stream_recv.c +++ b/src/core/stream_recv.c @@ -456,6 +456,19 @@ QuicStreamProcessStreamFrame( goto Error; } + if (Stream->Flags.RemoteCloseResetReliable && Frame->Offset >= Stream->RecvMaxLength) { + // + // Ignore additional frames once we have enough data. + // + if (!Stream->Flags.ReceiveClosedReliable) { + Stream->Flags.ReceiveClosedReliable = TRUE; + QuicStreamRecvShutdown(Stream, FALSE, QUIC_ERROR_NO_ERROR); + QuicStreamTryCompleteShutdown(Stream); + } + Status = QUIC_STATUS_SUCCESS; + goto Error; + } + if (EndOffset > QUIC_VAR_INT_MAX) { // // Stream data cannot exceed VAR_INT_MAX because it's impossible From f360c3f7bc1b14efe088402c6ccaddc9345fece6 Mon Sep 17 00:00:00 2001 From: Jack He Date: Thu, 24 Aug 2023 14:52:04 -0700 Subject: [PATCH 036/123] move recv offset >= reliable to receivecomplete path --- src/core/frame.c | 7 +++- src/core/stream_recv.c | 80 +++++++++++++++++++++++++++++------------- src/core/stream_send.c | 4 +-- 3 files changed, 64 insertions(+), 27 deletions(-) diff --git a/src/core/frame.c b/src/core/frame.c index 75342dc533..c30744d289 100644 --- a/src/core/frame.c +++ b/src/core/frame.c @@ -421,7 +421,7 @@ QuicReliableResetFrameEncode( sizeof(uint8_t) + // Type QuicVarIntSize(Frame->ErrorCode) + QuicVarIntSize(Frame->StreamID) + - QuicVarIntSize(Frame->FinalSize) + + QuicVarIntSize(Frame->FinalSize) + QuicVarIntSize(Frame->ReliableSize); if (BufferLength < *Offset + RequiredLength) { @@ -1943,6 +1943,11 @@ QuicFrameLog( break; } + case QUIC_FRAME_RELIABLE_RESET_STREAM: { + // TODO: Add log. + break; + } + default: CXPLAT_FRE_ASSERT(FALSE); break; diff --git a/src/core/stream_recv.c b/src/core/stream_recv.c index 534508a724..308230569f 100644 --- a/src/core/stream_recv.c +++ b/src/core/stream_recv.c @@ -195,6 +195,12 @@ QuicStreamProcessReliableResetFrame( // Stream->Flags.ReceiveDataPending = FALSE; + QuicTraceEvent( + StreamRecvState, + "[strm][%p] Shutting down stream from ProcessReliableResetFrame. Current State: %hhu", + Stream, + QuicStreamSendGetState(Stream)); + // // Shut down the stream. // @@ -210,23 +216,19 @@ QuicStreamProcessReliableResetFrame( QUIC_STREAM_SEND_FLAG_MAX_DATA | QUIC_STREAM_SEND_FLAG_RECV_ABORT); } - if (!Stream->Flags.RemoteCloseAcked) { - Stream->Flags.RemoteCloseAcked = TRUE; - Stream->Flags.ReceiveDataPending = TRUE; - if (!Stream->Flags.SentStopSending) { - // - // Indicate to the app that the stream has been aborted by the peer. - // - QUIC_STREAM_EVENT Event; - Event.Type = QUIC_STREAM_EVENT_PEER_SEND_ABORTED; - Event.PEER_SEND_ABORTED.ErrorCode = ErrorCode; - QuicTraceLogStreamVerbose( - IndicatePeerSendAbort, - Stream, - "Indicating QUIC_STREAM_EVENT_PEER_SEND_ABORTED (0x%llX)", - ErrorCode); - (void)QuicStreamIndicateEvent(Stream, &Event); - } + if (!Stream->Flags.SentStopSending) { + // + // Indicate to the app that the stream has been aborted by the peer. + // + QUIC_STREAM_EVENT Event; + Event.Type = QUIC_STREAM_EVENT_PEER_SEND_ABORTED; + Event.PEER_SEND_ABORTED.ErrorCode = ErrorCode; + QuicTraceLogStreamVerbose( + IndicatePeerSendAbort, + Stream, + "Indicating QUIC_STREAM_EVENT_PEER_SEND_ABORTED (0x%llX)", + ErrorCode); + (void)QuicStreamIndicateEvent(Stream, &Event); } } @@ -456,15 +458,10 @@ QuicStreamProcessStreamFrame( goto Error; } - if (Stream->Flags.RemoteCloseResetReliable && Frame->Offset >= Stream->RecvMaxLength) { + if (Stream->RecvBuffer.BaseOffset >= Stream->RecvMaxLength && Stream->Flags.RemoteCloseResetReliable) { // - // Ignore additional frames once we have enough data. + // Frame is unnecessary. // - if (!Stream->Flags.ReceiveClosedReliable) { - Stream->Flags.ReceiveClosedReliable = TRUE; - QuicStreamRecvShutdown(Stream, FALSE, QUIC_ERROR_NO_ERROR); - QuicStreamTryCompleteShutdown(Stream); - } Status = QUIC_STATUS_SUCCESS; goto Error; } @@ -1158,6 +1155,41 @@ QuicStreamReceiveComplete( QUIC_STREAM_SEND_FLAG_MAX_DATA | QUIC_STREAM_SEND_FLAG_RECV_ABORT); } + if (Stream->Flags.RemoteCloseResetReliable && Stream->RecvBuffer.BaseOffset >= Stream->RecvMaxLength && !Stream->Flags.ReceiveClosedReliable) { + + Stream->Flags.ReceiveClosedReliable = TRUE; + + QuicTraceEvent( + StreamRecvState, + "[strm][%p] Shutting down stream from ReceiveComplete. Current Recv State: %hhu", + Stream, + QuicStreamRecvGetState(Stream)); + + QUIC_STREAM_EVENT Event; + Event.Type = QUIC_STREAM_EVENT_PEER_SEND_SHUTDOWN; + QuicTraceLogStreamVerbose( + IndicatePeerSendShutdown, + Stream, + "Indicating QUIC_STREAM_EVENT_PEER_SEND_SHUTDOWN"); + + (void)QuicStreamIndicateEvent(Stream, &Event); + + // + // Now that the close event has been delivered to the app, we can shut + // down the stream. + // + QuicStreamTryCompleteShutdown(Stream); + + // + // Remove any flags we shouldn't be sending now that the receive + // direction is closed. + // + QuicSendClearStreamSendFlag( + &Stream->Connection->Send, + Stream, + QUIC_STREAM_SEND_FLAG_MAX_DATA | QUIC_STREAM_SEND_FLAG_RECV_ABORT); + } + return FALSE; } diff --git a/src/core/stream_send.c b/src/core/stream_send.c index 713c31668c..6ddf1b2a8b 100644 --- a/src/core/stream_send.c +++ b/src/core/stream_send.c @@ -1518,7 +1518,7 @@ QuicStreamOnAck( Stream->Flags.LocalCloseAcked = TRUE; QuicTraceEvent( StreamSendState, - "[strm][%p] Send State: %hhu", + "[strm][%p] Shutting down stream from OnStreamAck. Current State: %hhu", Stream, QuicStreamSendGetState(Stream)); QuicStreamTryCompleteShutdown(Stream); @@ -1599,7 +1599,7 @@ QuicStreamOnResetReliableAck( Stream->Flags.LocalCloseAcked = TRUE; QuicTraceEvent( StreamSendState, - "[strm][%p] Send State: %hhu", + "[strm][%p] Shutting down stream from OnResetReliableAck. Current State: %hhu", Stream, QuicStreamSendGetState(Stream)); QuicStreamCleanupReliableReset(Stream); From 1f75cf4fc7d79e3bb77be3e30b1231e6f23a1ccb Mon Sep 17 00:00:00 2001 From: Jack He Date: Thu, 24 Aug 2023 15:34:03 -0700 Subject: [PATCH 037/123] improve logging and clear send flags when done --- src/core/stream_recv.c | 14 +- src/core/stream_send.c | 34 +++-- src/generated/linux/stream.c.clog.h | 20 +++ src/generated/linux/stream.c.clog.h.lttng.h | 23 ++++ src/generated/linux/stream_recv.c.clog.h | 64 ++++++++- .../linux/stream_recv.c.clog.h.lttng.h | 69 +++++++++- src/generated/linux/stream_send.c.clog.h | 36 +++++ .../linux/stream_send.c.clog.h.lttng.h | 38 ++++++ src/manifest/clog.sidecar | 127 ++++++++++++++++++ 9 files changed, 399 insertions(+), 26 deletions(-) diff --git a/src/core/stream_recv.c b/src/core/stream_recv.c index 308230569f..1d806e716f 100644 --- a/src/core/stream_recv.c +++ b/src/core/stream_recv.c @@ -195,11 +195,10 @@ QuicStreamProcessReliableResetFrame( // Stream->Flags.ReceiveDataPending = FALSE; - QuicTraceEvent( - StreamRecvState, - "[strm][%p] Shutting down stream from ProcessReliableResetFrame. Current State: %hhu", + QuicTraceLogStreamVerbose( + StreamReliableResetProcessReliableResetFrame, Stream, - QuicStreamSendGetState(Stream)); + "Shutting down stream from ProcessReliableResetFrame. Recv side."); // // Shut down the stream. @@ -1159,11 +1158,10 @@ QuicStreamReceiveComplete( Stream->Flags.ReceiveClosedReliable = TRUE; - QuicTraceEvent( - StreamRecvState, - "[strm][%p] Shutting down stream from ReceiveComplete. Current Recv State: %hhu", + QuicTraceLogStreamVerbose( + StreamReliableResetReceiveComplete, Stream, - QuicStreamRecvGetState(Stream)); + "Shutting down stream from ReceiveComplete Recv Side."); QUIC_STREAM_EVENT Event; Event.Type = QUIC_STREAM_EVENT_PEER_SEND_SHUTDOWN; diff --git a/src/core/stream_send.c b/src/core/stream_send.c index 6ddf1b2a8b..7a8fe1ce64 100644 --- a/src/core/stream_send.c +++ b/src/core/stream_send.c @@ -245,7 +245,7 @@ QuicStreamSendShutdown( Stream->Flags.LocalCloseResetReliable = TRUE; Stream->SendShutdownErrorCode = ErrorCode; // - // Queue up a RESET RELIABLE STREAM frame to be sent. + // Queue up a RESET RELIABLE STREAM frame to be sent. We will clear up any flags later. // QuicSendSetStreamSendFlag( &Stream->Connection->Send, @@ -1516,14 +1516,21 @@ QuicStreamOnAck( BOOLEAN ReliableResetShutdown = !Stream->Flags.LocalCloseAcked && Stream->Flags.LocalCloseResetReliable && Stream->UnAckedOffset >= Stream->ReliableOffsetSend; if (ReliableResetShutdown) { Stream->Flags.LocalCloseAcked = TRUE; - QuicTraceEvent( - StreamSendState, - "[strm][%p] Shutting down stream from OnStreamAck. Current State: %hhu", + QuicTraceLogStreamVerbose( + StreamReliableResetOnStreamAck, Stream, - QuicStreamSendGetState(Stream)); + "Shutting down stream from OnStreamAck. Send side."); QuicStreamTryCompleteShutdown(Stream); QuicStreamCleanupReliableReset(Stream); QuicStreamIndicateSendShutdownComplete(Stream, FALSE); + // Clear any send path flags. + QuicSendClearStreamSendFlag( + &Stream->Connection->Send, + Stream, + QUIC_STREAM_SEND_FLAG_DATA_BLOCKED | + QUIC_STREAM_SEND_FLAG_DATA | + QUIC_STREAM_SEND_FLAG_OPEN | + QUIC_STREAM_SEND_FLAG_FIN); } if (!QuicStreamHasPendingStreamData(Stream)) { @@ -1597,15 +1604,22 @@ QuicStreamOnResetReliableAck( ) { if (Stream->UnAckedOffset >= Stream->ReliableOffsetSend && !Stream->Flags.LocalCloseAcked) { Stream->Flags.LocalCloseAcked = TRUE; - QuicTraceEvent( - StreamSendState, - "[strm][%p] Shutting down stream from OnResetReliableAck. Current State: %hhu", + QuicTraceLogStreamVerbose( + StreamReliableResetOnResetReliableAck, Stream, - QuicStreamSendGetState(Stream)); + "Shutting down stream from OnResetReliableAck. Send side."); QuicStreamCleanupReliableReset(Stream); QuicStreamTryCompleteShutdown(Stream); QuicStreamIndicateSendShutdownComplete(Stream, FALSE); - } + // Clear any send path flags. + QuicSendClearStreamSendFlag( + &Stream->Connection->Send, + Stream, + QUIC_STREAM_SEND_FLAG_DATA_BLOCKED | + QUIC_STREAM_SEND_FLAG_DATA | + QUIC_STREAM_SEND_FLAG_OPEN | + QUIC_STREAM_SEND_FLAG_FIN); + } } _IRQL_requires_max_(PASSIVE_LEVEL) diff --git a/src/generated/linux/stream.c.clog.h b/src/generated/linux/stream.c.clog.h index fed24b8ffe..ac7c040951 100644 --- a/src/generated/linux/stream.c.clog.h +++ b/src/generated/linux/stream.c.clog.h @@ -89,6 +89,26 @@ tracepoint(CLOG_STREAM_C, UpdatePriority , arg1, arg3);\ +/*---------------------------------------------------------- +// Decoder Ring for ReliableSendOffsetSet +// [strm][%p] Reliable send offset set to %llu +// QuicTraceLogStreamInfo( + ReliableSendOffsetSet, + Stream, + "Reliable send offset set to %llu", + *(uint64_t*)Buffer); +// arg1 = arg1 = Stream = arg1 +// arg3 = arg3 = *(uint64_t*)Buffer = arg3 +----------------------------------------------------------*/ +#ifndef _clog_4_ARGS_TRACE_ReliableSendOffsetSet +#define _clog_4_ARGS_TRACE_ReliableSendOffsetSet(uniqueId, arg1, encoded_arg_string, arg3)\ +tracepoint(CLOG_STREAM_C, ReliableSendOffsetSet , arg1, arg3);\ + +#endif + + + + /*---------------------------------------------------------- // Decoder Ring for ConfiguredForDelayedIDFC // [strm][%p] Configured for delayed ID FC updates diff --git a/src/generated/linux/stream.c.clog.h.lttng.h b/src/generated/linux/stream.c.clog.h.lttng.h index d0457dd5aa..15ec36db60 100644 --- a/src/generated/linux/stream.c.clog.h.lttng.h +++ b/src/generated/linux/stream.c.clog.h.lttng.h @@ -62,6 +62,29 @@ TRACEPOINT_EVENT(CLOG_STREAM_C, UpdatePriority, +/*---------------------------------------------------------- +// Decoder Ring for ReliableSendOffsetSet +// [strm][%p] Reliable send offset set to %llu +// QuicTraceLogStreamInfo( + ReliableSendOffsetSet, + Stream, + "Reliable send offset set to %llu", + *(uint64_t*)Buffer); +// arg1 = arg1 = Stream = arg1 +// arg3 = arg3 = *(uint64_t*)Buffer = arg3 +----------------------------------------------------------*/ +TRACEPOINT_EVENT(CLOG_STREAM_C, ReliableSendOffsetSet, + TP_ARGS( + const void *, arg1, + unsigned long long, arg3), + TP_FIELDS( + ctf_integer_hex(uint64_t, arg1, arg1) + ctf_integer(uint64_t, arg3, arg3) + ) +) + + + /*---------------------------------------------------------- // Decoder Ring for ConfiguredForDelayedIDFC // [strm][%p] Configured for delayed ID FC updates diff --git a/src/generated/linux/stream_recv.c.clog.h b/src/generated/linux/stream_recv.c.clog.h index b41b90a5fc..47ccd9a396 100644 --- a/src/generated/linux/stream_recv.c.clog.h +++ b/src/generated/linux/stream_recv.c.clog.h @@ -105,6 +105,26 @@ tracepoint(CLOG_STREAM_RECV_C, ReceiveBeyondFlowControl , arg1);\ +/*---------------------------------------------------------- +// Decoder Ring for ReliableRecvOffsetSet +// [strm][%p] Reliable recv offset set to %llu +// QuicTraceLogStreamInfo( + ReliableRecvOffsetSet, + Stream, + "Reliable recv offset set to %llu", + ReliableOffset); +// arg1 = arg1 = Stream = arg1 +// arg3 = arg3 = ReliableOffset = arg3 +----------------------------------------------------------*/ +#ifndef _clog_4_ARGS_TRACE_ReliableRecvOffsetSet +#define _clog_4_ARGS_TRACE_ReliableRecvOffsetSet(uniqueId, arg1, encoded_arg_string, arg3)\ +tracepoint(CLOG_STREAM_RECV_C, ReliableRecvOffsetSet , arg1, arg3);\ + +#endif + + + + /*---------------------------------------------------------- // Decoder Ring for RemoteCloseReset // [strm][%p] Closed remotely (reset) @@ -177,14 +197,32 @@ tracepoint(CLOG_STREAM_RECV_C, QueueRecvFlush , arg1);\ +/*---------------------------------------------------------- +// Decoder Ring for StreamReliableResetProcessReliableResetFrame +// [strm][%p] Shutting down stream from ProcessReliableResetFrame. Recv side. +// QuicTraceLogStreamVerbose( + StreamReliableResetProcessReliableResetFrame, + Stream, + "Shutting down stream from ProcessReliableResetFrame. Recv side."); +// arg1 = arg1 = Stream = arg1 +----------------------------------------------------------*/ +#ifndef _clog_3_ARGS_TRACE_StreamReliableResetProcessReliableResetFrame +#define _clog_3_ARGS_TRACE_StreamReliableResetProcessReliableResetFrame(uniqueId, arg1, encoded_arg_string)\ +tracepoint(CLOG_STREAM_RECV_C, StreamReliableResetProcessReliableResetFrame , arg1);\ + +#endif + + + + /*---------------------------------------------------------- // Decoder Ring for IndicatePeerSendAbort // [strm][%p] Indicating QUIC_STREAM_EVENT_PEER_SEND_ABORTED (0x%llX) // QuicTraceLogStreamVerbose( - IndicatePeerSendAbort, - Stream, - "Indicating QUIC_STREAM_EVENT_PEER_SEND_ABORTED (0x%llX)", - ErrorCode); + IndicatePeerSendAbort, + Stream, + "Indicating QUIC_STREAM_EVENT_PEER_SEND_ABORTED (0x%llX)", + ErrorCode); // arg1 = arg1 = Stream = arg1 // arg3 = arg3 = ErrorCode = arg3 ----------------------------------------------------------*/ @@ -395,6 +433,24 @@ tracepoint(CLOG_STREAM_RECV_C, IndicatePeerSendShutdown , arg1);\ +/*---------------------------------------------------------- +// Decoder Ring for StreamReliableResetReceiveComplete +// [strm][%p] Shutting down stream from ReceiveComplete Recv Side. +// QuicTraceLogStreamVerbose( + StreamReliableResetReceiveComplete, + Stream, + "Shutting down stream from ReceiveComplete Recv Side."); +// arg1 = arg1 = Stream = arg1 +----------------------------------------------------------*/ +#ifndef _clog_3_ARGS_TRACE_StreamReliableResetReceiveComplete +#define _clog_3_ARGS_TRACE_StreamReliableResetReceiveComplete(uniqueId, arg1, encoded_arg_string)\ +tracepoint(CLOG_STREAM_RECV_C, StreamReliableResetReceiveComplete , arg1);\ + +#endif + + + + /*---------------------------------------------------------- // Decoder Ring for StreamRecvState // [strm][%p] Recv State: %hhu diff --git a/src/generated/linux/stream_recv.c.clog.h.lttng.h b/src/generated/linux/stream_recv.c.clog.h.lttng.h index 66e0316b33..edf43320b3 100644 --- a/src/generated/linux/stream_recv.c.clog.h.lttng.h +++ b/src/generated/linux/stream_recv.c.clog.h.lttng.h @@ -77,6 +77,29 @@ TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, ReceiveBeyondFlowControl, +/*---------------------------------------------------------- +// Decoder Ring for ReliableRecvOffsetSet +// [strm][%p] Reliable recv offset set to %llu +// QuicTraceLogStreamInfo( + ReliableRecvOffsetSet, + Stream, + "Reliable recv offset set to %llu", + ReliableOffset); +// arg1 = arg1 = Stream = arg1 +// arg3 = arg3 = ReliableOffset = arg3 +----------------------------------------------------------*/ +TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, ReliableRecvOffsetSet, + TP_ARGS( + const void *, arg1, + unsigned long long, arg3), + TP_FIELDS( + ctf_integer_hex(uint64_t, arg1, arg1) + ctf_integer(uint64_t, arg3, arg3) + ) +) + + + /*---------------------------------------------------------- // Decoder Ring for RemoteCloseReset // [strm][%p] Closed remotely (reset) @@ -153,14 +176,33 @@ TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, QueueRecvFlush, +/*---------------------------------------------------------- +// Decoder Ring for StreamReliableResetProcessReliableResetFrame +// [strm][%p] Shutting down stream from ProcessReliableResetFrame. Recv side. +// QuicTraceLogStreamVerbose( + StreamReliableResetProcessReliableResetFrame, + Stream, + "Shutting down stream from ProcessReliableResetFrame. Recv side."); +// arg1 = arg1 = Stream = arg1 +----------------------------------------------------------*/ +TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, StreamReliableResetProcessReliableResetFrame, + TP_ARGS( + const void *, arg1), + TP_FIELDS( + ctf_integer_hex(uint64_t, arg1, arg1) + ) +) + + + /*---------------------------------------------------------- // Decoder Ring for IndicatePeerSendAbort // [strm][%p] Indicating QUIC_STREAM_EVENT_PEER_SEND_ABORTED (0x%llX) // QuicTraceLogStreamVerbose( - IndicatePeerSendAbort, - Stream, - "Indicating QUIC_STREAM_EVENT_PEER_SEND_ABORTED (0x%llX)", - ErrorCode); + IndicatePeerSendAbort, + Stream, + "Indicating QUIC_STREAM_EVENT_PEER_SEND_ABORTED (0x%llX)", + ErrorCode); // arg1 = arg1 = Stream = arg1 // arg3 = arg3 = ErrorCode = arg3 ----------------------------------------------------------*/ @@ -402,6 +444,25 @@ TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, IndicatePeerSendShutdown, +/*---------------------------------------------------------- +// Decoder Ring for StreamReliableResetReceiveComplete +// [strm][%p] Shutting down stream from ReceiveComplete Recv Side. +// QuicTraceLogStreamVerbose( + StreamReliableResetReceiveComplete, + Stream, + "Shutting down stream from ReceiveComplete Recv Side."); +// arg1 = arg1 = Stream = arg1 +----------------------------------------------------------*/ +TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, StreamReliableResetReceiveComplete, + TP_ARGS( + const void *, arg1), + TP_FIELDS( + ctf_integer_hex(uint64_t, arg1, arg1) + ) +) + + + /*---------------------------------------------------------- // Decoder Ring for StreamRecvState // [strm][%p] Recv State: %hhu diff --git a/src/generated/linux/stream_send.c.clog.h b/src/generated/linux/stream_send.c.clog.h index 94874bab6c..b2ff394823 100644 --- a/src/generated/linux/stream_send.c.clog.h +++ b/src/generated/linux/stream_send.c.clog.h @@ -289,6 +289,42 @@ tracepoint(CLOG_STREAM_SEND_C, SendQueueDrained , arg1);\ +/*---------------------------------------------------------- +// Decoder Ring for StreamReliableResetOnStreamAck +// [strm][%p] Shutting down stream from OnStreamAck. Send side. +// QuicTraceLogStreamVerbose( + StreamReliableResetOnStreamAck, + Stream, + "Shutting down stream from OnStreamAck. Send side."); +// arg1 = arg1 = Stream = arg1 +----------------------------------------------------------*/ +#ifndef _clog_3_ARGS_TRACE_StreamReliableResetOnStreamAck +#define _clog_3_ARGS_TRACE_StreamReliableResetOnStreamAck(uniqueId, arg1, encoded_arg_string)\ +tracepoint(CLOG_STREAM_SEND_C, StreamReliableResetOnStreamAck , arg1);\ + +#endif + + + + +/*---------------------------------------------------------- +// Decoder Ring for StreamReliableResetOnResetReliableAck +// [strm][%p] Shutting down stream from OnResetReliableAck. Send side. +// QuicTraceLogStreamVerbose( + StreamReliableResetOnResetReliableAck, + Stream, + "Shutting down stream from OnResetReliableAck. Send side."); +// arg1 = arg1 = Stream = arg1 +----------------------------------------------------------*/ +#ifndef _clog_3_ARGS_TRACE_StreamReliableResetOnResetReliableAck +#define _clog_3_ARGS_TRACE_StreamReliableResetOnResetReliableAck(uniqueId, arg1, encoded_arg_string)\ +tracepoint(CLOG_STREAM_SEND_C, StreamReliableResetOnResetReliableAck , arg1);\ + +#endif + + + + /*---------------------------------------------------------- // Decoder Ring for SendDump // [strm][%p] SF:%hX FC:%llu QS:%llu MAX:%llu UNA:%llu NXT:%llu RECOV:%llu-%llu diff --git a/src/generated/linux/stream_send.c.clog.h.lttng.h b/src/generated/linux/stream_send.c.clog.h.lttng.h index edb1505670..495c3d752f 100644 --- a/src/generated/linux/stream_send.c.clog.h.lttng.h +++ b/src/generated/linux/stream_send.c.clog.h.lttng.h @@ -308,6 +308,44 @@ TRACEPOINT_EVENT(CLOG_STREAM_SEND_C, SendQueueDrained, +/*---------------------------------------------------------- +// Decoder Ring for StreamReliableResetOnStreamAck +// [strm][%p] Shutting down stream from OnStreamAck. Send side. +// QuicTraceLogStreamVerbose( + StreamReliableResetOnStreamAck, + Stream, + "Shutting down stream from OnStreamAck. Send side."); +// arg1 = arg1 = Stream = arg1 +----------------------------------------------------------*/ +TRACEPOINT_EVENT(CLOG_STREAM_SEND_C, StreamReliableResetOnStreamAck, + TP_ARGS( + const void *, arg1), + TP_FIELDS( + ctf_integer_hex(uint64_t, arg1, arg1) + ) +) + + + +/*---------------------------------------------------------- +// Decoder Ring for StreamReliableResetOnResetReliableAck +// [strm][%p] Shutting down stream from OnResetReliableAck. Send side. +// QuicTraceLogStreamVerbose( + StreamReliableResetOnResetReliableAck, + Stream, + "Shutting down stream from OnResetReliableAck. Send side."); +// arg1 = arg1 = Stream = arg1 +----------------------------------------------------------*/ +TRACEPOINT_EVENT(CLOG_STREAM_SEND_C, StreamReliableResetOnResetReliableAck, + TP_ARGS( + const void *, arg1), + TP_FIELDS( + ctf_integer_hex(uint64_t, arg1, arg1) + ) +) + + + /*---------------------------------------------------------- // Decoder Ring for SendDump // [strm][%p] SF:%hX FC:%llu QS:%llu MAX:%llu UNA:%llu NXT:%llu RECOV:%llu-%llu diff --git a/src/manifest/clog.sidecar b/src/manifest/clog.sidecar index 316a3d6383..769d7e4bb9 100644 --- a/src/manifest/clog.sidecar +++ b/src/manifest/clog.sidecar @@ -9118,6 +9118,22 @@ ], "macroName": "QuicTraceLogInfo" }, + "ReliableRecvOffsetSet": { + "ModuleProperites": {}, + "TraceString": "[strm][%p] Reliable recv offset set to %llu", + "UniqueId": "ReliableRecvOffsetSet", + "splitArgs": [ + { + "DefinationEncoding": "p", + "MacroVariableName": "arg1" + }, + { + "DefinationEncoding": "llu", + "MacroVariableName": "arg3" + } + ], + "macroName": "QuicTraceLogStreamInfo" + }, "ReliableResetEnabledUpdated": { "ModuleProperites": {}, "TraceString": "[conn][%p] Updated reliable reset frame enabled to %hhu", @@ -9150,6 +9166,22 @@ ], "macroName": "QuicTraceLogConnInfo" }, + "ReliableSendOffsetSet": { + "ModuleProperites": {}, + "TraceString": "[strm][%p] Reliable send offset set to %llu", + "UniqueId": "ReliableSendOffsetSet", + "splitArgs": [ + { + "DefinationEncoding": "p", + "MacroVariableName": "arg1" + }, + { + "DefinationEncoding": "llu", + "MacroVariableName": "arg3" + } + ], + "macroName": "QuicTraceLogStreamInfo" + }, "RemoteBlocked": { "ModuleProperites": {}, "TraceString": "[strm][%p] Remote FC blocked (%llu)", @@ -10931,6 +10963,66 @@ ], "macroName": "QuicTraceEvent" }, + "StreamReliableReset": { + "ModuleProperites": {}, + "TraceString": "[strm][%p] Shutting down stream from OnStreamAck. Send side.", + "UniqueId": "StreamReliableReset", + "splitArgs": [ + { + "DefinationEncoding": "p", + "MacroVariableName": "arg1" + } + ], + "macroName": "QuicTraceLogStreamVerbose" + }, + "StreamReliableResetOnResetReliableAck": { + "ModuleProperites": {}, + "TraceString": "[strm][%p] Shutting down stream from OnResetReliableAck. Send side.", + "UniqueId": "StreamReliableResetOnResetReliableAck", + "splitArgs": [ + { + "DefinationEncoding": "p", + "MacroVariableName": "arg1" + } + ], + "macroName": "QuicTraceLogStreamVerbose" + }, + "StreamReliableResetOnStreamAck": { + "ModuleProperites": {}, + "TraceString": "[strm][%p] Shutting down stream from OnStreamAck. Send side.", + "UniqueId": "StreamReliableResetOnStreamAck", + "splitArgs": [ + { + "DefinationEncoding": "p", + "MacroVariableName": "arg1" + } + ], + "macroName": "QuicTraceLogStreamVerbose" + }, + "StreamReliableResetProcessReliableResetFrame": { + "ModuleProperites": {}, + "TraceString": "[strm][%p] Shutting down stream from ProcessReliableResetFrame. Recv side.", + "UniqueId": "StreamReliableResetProcessReliableResetFrame", + "splitArgs": [ + { + "DefinationEncoding": "p", + "MacroVariableName": "arg1" + } + ], + "macroName": "QuicTraceLogStreamVerbose" + }, + "StreamReliableResetReceiveComplete": { + "ModuleProperites": {}, + "TraceString": "[strm][%p] Shutting down stream from ReceiveComplete Recv Side.", + "UniqueId": "StreamReliableResetReceiveComplete", + "splitArgs": [ + { + "DefinationEncoding": "p", + "MacroVariableName": "arg1" + } + ], + "macroName": "QuicTraceLogStreamVerbose" + }, "StreamRundown": { "ModuleProperites": {}, "TraceString": "[strm][%p] Rundown, Conn=%p ID=%llu IsLocal=%hhu", @@ -15425,6 +15517,11 @@ "TraceID": "RegistrationVerifierEnabled", "EncodingString": "[ reg][%p] Verifing enabled!" }, + { + "UniquenessHash": "bcb85c5a-f23a-2ef4-0f84-7bc5bb3848fe", + "TraceID": "ReliableRecvOffsetSet", + "EncodingString": "[strm][%p] Reliable recv offset set to %llu" + }, { "UniquenessHash": "7c8196a9-c4d5-9b85-26ae-ee4492bfe6c8", "TraceID": "ReliableResetEnabledUpdated", @@ -15435,6 +15532,11 @@ "TraceID": "ReliableResetFrameReceived", "EncodingString": "[conn][%p] Received a reliable reset frame. Local reliable reset extension preferences: %hhu" }, + { + "UniquenessHash": "84836f4f-d47f-cc00-7cb2-530ac90c70d3", + "TraceID": "ReliableSendOffsetSet", + "EncodingString": "[strm][%p] Reliable send offset set to %llu" + }, { "UniquenessHash": "90a48bef-0658-1e75-8afa-d4fff8d929bf", "TraceID": "RemoteBlocked", @@ -16025,6 +16127,31 @@ "TraceID": "StreamRecvState", "EncodingString": "[strm][%p] Recv State: %hhu" }, + { + "UniquenessHash": "9351f46e-9d08-2d68-10e8-5c9215a7dc2b", + "TraceID": "StreamReliableReset", + "EncodingString": "[strm][%p] Shutting down stream from OnStreamAck. Send side." + }, + { + "UniquenessHash": "ce8a6cd4-1ecd-b74d-fc68-8e34b0a4c375", + "TraceID": "StreamReliableResetOnResetReliableAck", + "EncodingString": "[strm][%p] Shutting down stream from OnResetReliableAck. Send side." + }, + { + "UniquenessHash": "6bb4694b-2c10-fdfc-7673-fae38fb3cc22", + "TraceID": "StreamReliableResetOnStreamAck", + "EncodingString": "[strm][%p] Shutting down stream from OnStreamAck. Send side." + }, + { + "UniquenessHash": "4bd00400-13c5-4745-387d-4a2a0b5c70d5", + "TraceID": "StreamReliableResetProcessReliableResetFrame", + "EncodingString": "[strm][%p] Shutting down stream from ProcessReliableResetFrame. Recv side." + }, + { + "UniquenessHash": "cde4c5d6-6221-1f7d-c92b-4511f748c9f9", + "TraceID": "StreamReliableResetReceiveComplete", + "EncodingString": "[strm][%p] Shutting down stream from ReceiveComplete Recv Side." + }, { "UniquenessHash": "c91c925c-07e9-3204-5459-5d3b19d137d8", "TraceID": "StreamRundown", From 4f248c2a83d1808543ecef397e640aaeabda9d7e Mon Sep 17 00:00:00 2001 From: Jack He Date: Fri, 25 Aug 2023 13:11:29 -0700 Subject: [PATCH 038/123] don't retransmit lost stream frames if we aborted reliably --- src/core/stream_send.c | 37 +++++++++++++++++++++++++------------ 1 file changed, 25 insertions(+), 12 deletions(-) diff --git a/src/core/stream_send.c b/src/core/stream_send.c index 7a8fe1ce64..1c4538f5d4 100644 --- a/src/core/stream_send.c +++ b/src/core/stream_send.c @@ -159,7 +159,10 @@ QuicStreamSendShutdown( QUIC_STREAM_SEND_FLAG_FIN, DelaySend); - } else if (Stream->ReliableOffsetSend == 0) { + } else if (Stream->ReliableOffsetSend == 0 || Stream->Flags.LocalCloseResetReliable) { + // + // Enter abortive branch if we are not aborting reliablely or we have done it already. + // // // Can't be blocked by (stream) FC any more if we've aborted sending any @@ -235,7 +238,7 @@ QuicStreamSendShutdown( QUIC_STREAM_SEND_FLAG_FIN); } } else { - if (Stream->Flags.LocalCloseReset) { + if (Stream->Flags.LocalCloseReset || Stream->Flags.LocalCloseResetReliable) { // // We have already closed the stream (graceful or abortive) so we // can't reliably abort it. @@ -1210,6 +1213,13 @@ QuicStreamOnLoss( return FALSE; } + if (Stream->Flags.LocalCloseResetReliable && Stream->UnAckedOffset >= Stream->ReliableOffsetSend) { + // + // Ignore any STREAM frame packet loss if we aborted reliably and + // received acks for enough data. + return FALSE; + } + uint32_t AddSendFlags = 0; uint64_t Start = FrameMetadata->StreamOffset; @@ -1516,21 +1526,23 @@ QuicStreamOnAck( BOOLEAN ReliableResetShutdown = !Stream->Flags.LocalCloseAcked && Stream->Flags.LocalCloseResetReliable && Stream->UnAckedOffset >= Stream->ReliableOffsetSend; if (ReliableResetShutdown) { Stream->Flags.LocalCloseAcked = TRUE; + Stream->Flags.RemoteCloseAcked = TRUE; QuicTraceLogStreamVerbose( StreamReliableResetOnStreamAck, Stream, "Shutting down stream from OnStreamAck. Send side."); - QuicStreamTryCompleteShutdown(Stream); - QuicStreamCleanupReliableReset(Stream); - QuicStreamIndicateSendShutdownComplete(Stream, FALSE); + QuicStreamSendShutdown(Stream, FALSE, TRUE, FALSE, QUIC_ERROR_NO_ERROR); + // QuicStreamTryCompleteShutdown(Stream); + // QuicStreamCleanupReliableReset(Stream); + // QuicStreamIndicateSendShutdownComplete(Stream, FALSE); // Clear any send path flags. - QuicSendClearStreamSendFlag( - &Stream->Connection->Send, - Stream, - QUIC_STREAM_SEND_FLAG_DATA_BLOCKED | - QUIC_STREAM_SEND_FLAG_DATA | - QUIC_STREAM_SEND_FLAG_OPEN | - QUIC_STREAM_SEND_FLAG_FIN); + // QuicSendClearStreamSendFlag( + // &Stream->Connection->Send, + // Stream, + // QUIC_STREAM_SEND_FLAG_DATA_BLOCKED | + // QUIC_STREAM_SEND_FLAG_DATA | + // QUIC_STREAM_SEND_FLAG_OPEN | + // QUIC_STREAM_SEND_FLAG_FIN); } if (!QuicStreamHasPendingStreamData(Stream)) { @@ -1603,6 +1615,7 @@ QuicStreamOnResetReliableAck( _In_ QUIC_STREAM* Stream ) { if (Stream->UnAckedOffset >= Stream->ReliableOffsetSend && !Stream->Flags.LocalCloseAcked) { + // TODO: Update this to do the same thing in OnStreamAck. Stream->Flags.LocalCloseAcked = TRUE; QuicTraceLogStreamVerbose( StreamReliableResetOnResetReliableAck, From b957edbb54fd2d7512e99dd666ffd2ee27a2cffa Mon Sep 17 00:00:00 2001 From: Jack He Date: Fri, 25 Aug 2023 13:12:10 -0700 Subject: [PATCH 039/123] update comments and use streamshutdownrecv abort silent --- src/core/stream_recv.c | 21 ++++++++++++++------- 1 file changed, 14 insertions(+), 7 deletions(-) diff --git a/src/core/stream_recv.c b/src/core/stream_recv.c index 1d806e716f..5fe17d0e0e 100644 --- a/src/core/stream_recv.c +++ b/src/core/stream_recv.c @@ -190,6 +190,8 @@ QuicStreamProcessReliableResetFrame( } if (Stream->RecvBuffer.BaseOffset >= Stream->RecvMaxLength) { + // TODO: Update this to be the same as ReceiveComplete. + // // All data delivered. Deliver shutdown callback. // @@ -451,7 +453,7 @@ QuicStreamProcessStreamFrame( if (EndOffset > Stream->RecvMaxLength && !Stream->Flags.RemoteCloseResetReliable) { // - // Frame goes past the FIN. + // Frame goes past the FIN, and the stream is not reset reliably. // Status = QUIC_STATUS_INVALID_PARAMETER; goto Error; @@ -459,7 +461,8 @@ QuicStreamProcessStreamFrame( if (Stream->RecvBuffer.BaseOffset >= Stream->RecvMaxLength && Stream->Flags.RemoteCloseResetReliable) { // - // Frame is unnecessary. + // We've aborted reliably, and... + // Frame goes past reliable offset, we can just discard to save space and compute. // Status = QUIC_STATUS_SUCCESS; goto Error; @@ -1157,6 +1160,9 @@ QuicStreamReceiveComplete( if (Stream->Flags.RemoteCloseResetReliable && Stream->RecvBuffer.BaseOffset >= Stream->RecvMaxLength && !Stream->Flags.ReceiveClosedReliable) { Stream->Flags.ReceiveClosedReliable = TRUE; + Stream->Flags.LocalCloseAcked = TRUE; + Stream->Flags.RemoteCloseAcked = TRUE; + QuicTraceLogStreamVerbose( StreamReliableResetReceiveComplete, @@ -1172,20 +1178,21 @@ QuicStreamReceiveComplete( (void)QuicStreamIndicateEvent(Stream, &Event); + QuicStreamRecvShutdown(Stream, TRUE, QUIC_ERROR_NO_ERROR); // // Now that the close event has been delivered to the app, we can shut // down the stream. // - QuicStreamTryCompleteShutdown(Stream); + // QuicStreamTryCompleteShutdown(Stream); // // Remove any flags we shouldn't be sending now that the receive // direction is closed. // - QuicSendClearStreamSendFlag( - &Stream->Connection->Send, - Stream, - QUIC_STREAM_SEND_FLAG_MAX_DATA | QUIC_STREAM_SEND_FLAG_RECV_ABORT); + // QuicSendClearStreamSendFlag( + // &Stream->Connection->Send, + // Stream, + // QUIC_STREAM_SEND_FLAG_MAX_DATA | QUIC_STREAM_SEND_FLAG_RECV_ABORT); } return FALSE; From 9e7b0e2873ea1a0eea3d7ea8ca6c0d58a517365c Mon Sep 17 00:00:00 2001 From: Jack He Date: Fri, 25 Aug 2023 22:26:16 -0700 Subject: [PATCH 040/123] fixed stream leak --- src/core/sent_packet_metadata.c | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/core/sent_packet_metadata.c b/src/core/sent_packet_metadata.c index 17b48f04fb..ca3567eb3c 100644 --- a/src/core/sent_packet_metadata.c +++ b/src/core/sent_packet_metadata.c @@ -46,6 +46,9 @@ QuicSentPacketMetadataReleaseFrames( case QUIC_FRAME_STREAM: QuicStreamSentMetadataDecrement(Metadata->Frames[i].STREAM.Stream); break; + case QUIC_FRAME_RELIABLE_RESET_STREAM: + QuicStreamSentMetadataDecrement(Metadata->Frames[i].RELIABLE_RESET_STREAM.Stream); + break; #pragma warning(pop) default: // From 3b2f0170a4590b66ef331099ed92ccfd5b20e7a6 Mon Sep 17 00:00:00 2001 From: Jack He Date: Fri, 25 Aug 2023 23:19:48 -0700 Subject: [PATCH 041/123] add back cleanup --- src/core/stream.c | 2 +- src/core/stream_send.c | 4 +--- src/core/stream_set.c | 4 +++- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/src/core/stream.c b/src/core/stream.c index b5aa0c8414..b4bc7e2986 100644 --- a/src/core/stream.c +++ b/src/core/stream.c @@ -567,7 +567,7 @@ QuicStreamShutdown( } if (!!(Flags & QUIC_STREAM_SHUTDOWN_FLAG_IMMEDIATE) && - !Stream->Flags.ShutdownComplete) { + !Stream->Flags.ShutdownComplete && !Stream->Flags.RemoteCloseResetReliable) { // // The app has requested that we immediately give them completion // events so they don't have to wait. Deliver the send shutdown complete diff --git a/src/core/stream_send.c b/src/core/stream_send.c index 1c4538f5d4..8b3558a30f 100644 --- a/src/core/stream_send.c +++ b/src/core/stream_send.c @@ -1531,9 +1531,9 @@ QuicStreamOnAck( StreamReliableResetOnStreamAck, Stream, "Shutting down stream from OnStreamAck. Send side."); + QuicStreamCleanupReliableReset(Stream); QuicStreamSendShutdown(Stream, FALSE, TRUE, FALSE, QUIC_ERROR_NO_ERROR); // QuicStreamTryCompleteShutdown(Stream); - // QuicStreamCleanupReliableReset(Stream); // QuicStreamIndicateSendShutdownComplete(Stream, FALSE); // Clear any send path flags. // QuicSendClearStreamSendFlag( @@ -1587,8 +1587,6 @@ QuicStreamCleanupReliableReset( } QuicStreamCompleteSendRequest(Stream, Req, FALSE, TRUE); } - QuicStreamSendDumpState(Stream); - QuicStreamValidateRecoveryState(Stream); } _IRQL_requires_max_(PASSIVE_LEVEL) diff --git a/src/core/stream_set.c b/src/core/stream_set.c index da85ef12f4..7c540ff6ca 100644 --- a/src/core/stream_set.c +++ b/src/core/stream_set.c @@ -160,7 +160,9 @@ QuicStreamSetShutdown( CxPlatHashtableEnumerateBegin(StreamSet->StreamTable, &Enumerator); while ((Entry = CxPlatHashtableEnumerateNext(StreamSet->StreamTable, &Enumerator)) != NULL) { QUIC_STREAM* Stream = CXPLAT_CONTAINING_RECORD(Entry, QUIC_STREAM, TableEntry); - + if (Stream->Flags.LocalCloseResetReliable && !Stream->Flags.LocalCloseAcked) { + continue; + } QuicStreamShutdown( Stream, QUIC_STREAM_SHUTDOWN_FLAG_ABORT_SEND | From 3948c937e2586ed1f85adee89f4edd6555c803d7 Mon Sep 17 00:00:00 2001 From: Jack He Date: Mon, 28 Aug 2023 11:25:56 -0700 Subject: [PATCH 042/123] get rid of useless param --- src/core/stream_recv.c | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/core/stream_recv.c b/src/core/stream_recv.c index 5fe17d0e0e..b38564a522 100644 --- a/src/core/stream_recv.c +++ b/src/core/stream_recv.c @@ -169,7 +169,6 @@ _IRQL_requires_max_(PASSIVE_LEVEL) void QuicStreamProcessReliableResetFrame( _In_ QUIC_STREAM* Stream, - _In_ uint64_t FinalSize, _In_ QUIC_VAR_INT ErrorCode, _In_ QUIC_VAR_INT ReliableOffset ) @@ -705,7 +704,6 @@ QuicStreamRecv( QuicStreamProcessReliableResetFrame( Stream, - Frame.FinalSize, Frame.ErrorCode, Frame.ReliableSize); From a82499f4d5b31f52bfb4183ea6a2c3cc146caf27 Mon Sep 17 00:00:00 2001 From: Jack He Date: Mon, 28 Aug 2023 17:13:55 -0700 Subject: [PATCH 043/123] add an automation script to automatically run certain commands X times --- scripts/iter_command.ps1 | 34 ++++++++++++++++++++++++++++++++++ 1 file changed, 34 insertions(+) create mode 100644 scripts/iter_command.ps1 diff --git a/scripts/iter_command.ps1 b/scripts/iter_command.ps1 new file mode 100644 index 0000000000..51bbf3fb55 --- /dev/null +++ b/scripts/iter_command.ps1 @@ -0,0 +1,34 @@ + +# For local unit testing, often certain bugs only appear due to a specific ordering of events in the network. +# To catch those edge cases, lots of iterations are required. Manually doing them is tiresome. +# This script automates the process of finding those bugs. +# Additionally, running this script with large NumIterations gives confidence. + +# Example Usage: +# .\scripts\iter_command.ps1 -commandToRun "./scripts/test.ps1 -Filter *StreamReliable* -LogProfile Full.Light" -numIterations 100 + + +param ( + [string]$commandToRun, + [int]$numIterations +) + +if ($commandToRun -eq $null) { + Write-Host "Error: 'commandToRun' parameter cannot be null." + exit +} + +if ($numIterations -eq $null) { + Write-Host "Error: 'commandToRun' parameter cannot be null." + exit +} + +if ($numIterations -le 0) { + Write-Host "Error: 'numIterations' parameter must be greater than 0." + exit +} + +for ($i = 1; $i -le $numIterations; $i++) { + Invoke-Expression $commandToRun + Write-Host "-------------------------------------------" +} From 67deddb85c8e0a5dcc79267c399bbfcde8d7f859 Mon Sep 17 00:00:00 2001 From: Jack He Date: Mon, 28 Aug 2023 17:14:23 -0700 Subject: [PATCH 044/123] update clog with more logging --- src/core/stream_recv.c | 66 ++++-------- src/core/stream_send.c | 41 +++---- src/generated/linux/stream_recv.c.clog.h | 82 ++++++++------ .../linux/stream_recv.c.clog.h.lttng.h | 77 ++++++++----- src/generated/linux/stream_send.c.clog.h | 64 ++++++++--- .../linux/stream_send.c.clog.h.lttng.h | 58 ++++++++-- src/manifest/clog.sidecar | 102 ++++++++++++++++++ src/test/lib/DataTest.cpp | 16 +-- 8 files changed, 342 insertions(+), 164 deletions(-) diff --git a/src/core/stream_recv.c b/src/core/stream_recv.c index b38564a522..d8f2f80dfd 100644 --- a/src/core/stream_recv.c +++ b/src/core/stream_recv.c @@ -189,31 +189,21 @@ QuicStreamProcessReliableResetFrame( } if (Stream->RecvBuffer.BaseOffset >= Stream->RecvMaxLength) { - // TODO: Update this to be the same as ReceiveComplete. - - // - // All data delivered. Deliver shutdown callback. - // - Stream->Flags.ReceiveDataPending = FALSE; - + Stream->Flags.ReceiveClosedReliable = TRUE; + Stream->Flags.LocalCloseAcked = TRUE; + Stream->Flags.RemoteCloseAcked = TRUE; QuicTraceLogStreamVerbose( - StreamReliableResetProcessReliableResetFrame, + StreamReliableResetReceiveComplete, Stream, - "Shutting down stream from ProcessReliableResetFrame. Recv side."); - - // - // Shut down the stream. - // - QuicStreamTryCompleteShutdown(Stream); - - // - // Remove any flags we shouldn't be sending now that the receive - // direction is closed. - // - QuicSendClearStreamSendFlag( - &Stream->Connection->Send, + "Shutting down stream from ReceiveComplete Recv Side."); + QUIC_STREAM_EVENT Event; + Event.Type = QUIC_STREAM_EVENT_PEER_SEND_SHUTDOWN; + QuicTraceLogStreamVerbose( + IndicatePeerSendShutdown, Stream, - QUIC_STREAM_SEND_FLAG_MAX_DATA | QUIC_STREAM_SEND_FLAG_RECV_ABORT); + "Indicating QUIC_STREAM_EVENT_PEER_SEND_SHUTDOWN"); + (void)QuicStreamIndicateEvent(Stream, &Event); + QuicStreamRecvShutdown(Stream, TRUE, QUIC_ERROR_NO_ERROR); } if (!Stream->Flags.SentStopSending) { @@ -327,6 +317,10 @@ QuicStreamProcessResetFrame( (void)QuicStreamIndicateEvent(Stream, &Event); } + QuicTraceLogStreamVerbose( + StreamReliableProcessResetFrame, + Stream, + "Shutting down stream Abortively in ProcessResetFrame. Recv Side."); // // Remove any flags we shouldn't be sending now that the receive // direction is closed. @@ -1139,6 +1133,10 @@ QuicStreamReceiveComplete( "Indicating QUIC_STREAM_EVENT_PEER_SEND_SHUTDOWN"); (void)QuicStreamIndicateEvent(Stream, &Event); + QuicTraceLogStreamVerbose( + StreamReliableResetRecvGraceful, + Stream, + "Shutting down stream [gracefully] Recv Side."); // // Now that the close event has been delivered to the app, we can shut // down the stream. @@ -1153,44 +1151,22 @@ QuicStreamReceiveComplete( &Stream->Connection->Send, Stream, QUIC_STREAM_SEND_FLAG_MAX_DATA | QUIC_STREAM_SEND_FLAG_RECV_ABORT); - } - - if (Stream->Flags.RemoteCloseResetReliable && Stream->RecvBuffer.BaseOffset >= Stream->RecvMaxLength && !Stream->Flags.ReceiveClosedReliable) { - + } else if (Stream->Flags.RemoteCloseResetReliable && Stream->RecvBuffer.BaseOffset >= Stream->RecvMaxLength && !Stream->Flags.ReceiveClosedReliable) { Stream->Flags.ReceiveClosedReliable = TRUE; Stream->Flags.LocalCloseAcked = TRUE; Stream->Flags.RemoteCloseAcked = TRUE; - - QuicTraceLogStreamVerbose( StreamReliableResetReceiveComplete, Stream, "Shutting down stream from ReceiveComplete Recv Side."); - QUIC_STREAM_EVENT Event; Event.Type = QUIC_STREAM_EVENT_PEER_SEND_SHUTDOWN; QuicTraceLogStreamVerbose( IndicatePeerSendShutdown, Stream, "Indicating QUIC_STREAM_EVENT_PEER_SEND_SHUTDOWN"); - (void)QuicStreamIndicateEvent(Stream, &Event); - QuicStreamRecvShutdown(Stream, TRUE, QUIC_ERROR_NO_ERROR); - // - // Now that the close event has been delivered to the app, we can shut - // down the stream. - // - // QuicStreamTryCompleteShutdown(Stream); - - // - // Remove any flags we shouldn't be sending now that the receive - // direction is closed. - // - // QuicSendClearStreamSendFlag( - // &Stream->Connection->Send, - // Stream, - // QUIC_STREAM_SEND_FLAG_MAX_DATA | QUIC_STREAM_SEND_FLAG_RECV_ABORT); } return FALSE; diff --git a/src/core/stream_send.c b/src/core/stream_send.c index 8b3558a30f..ab6085dda1 100644 --- a/src/core/stream_send.c +++ b/src/core/stream_send.c @@ -1479,6 +1479,10 @@ QuicStreamOnAck( "[strm][%p] Send State: %hhu", Stream, QuicStreamSendGetState(Stream)); + QuicTraceLogStreamVerbose( + StreamGracefulShutdown, + Stream, + "Shutting down [gracefully] from OnStreamAck. Send Side."); QuicStreamIndicateSendShutdownComplete(Stream, TRUE); QuicStreamTryCompleteShutdown(Stream); } @@ -1528,21 +1532,11 @@ QuicStreamOnAck( Stream->Flags.LocalCloseAcked = TRUE; Stream->Flags.RemoteCloseAcked = TRUE; QuicTraceLogStreamVerbose( - StreamReliableResetOnStreamAck, + ReliableResetOnStreamAck, Stream, - "Shutting down stream from OnStreamAck. Send side."); + "Shutting down stream [reliable] from OnStreamAck. Send side."); QuicStreamCleanupReliableReset(Stream); QuicStreamSendShutdown(Stream, FALSE, TRUE, FALSE, QUIC_ERROR_NO_ERROR); - // QuicStreamTryCompleteShutdown(Stream); - // QuicStreamIndicateSendShutdownComplete(Stream, FALSE); - // Clear any send path flags. - // QuicSendClearStreamSendFlag( - // &Stream->Connection->Send, - // Stream, - // QUIC_STREAM_SEND_FLAG_DATA_BLOCKED | - // QUIC_STREAM_SEND_FLAG_DATA | - // QUIC_STREAM_SEND_FLAG_OPEN | - // QUIC_STREAM_SEND_FLAG_FIN); } if (!QuicStreamHasPendingStreamData(Stream)) { @@ -1602,6 +1596,10 @@ QuicStreamOnResetAck( "[strm][%p] Send State: %hhu", Stream, QuicStreamSendGetState(Stream)); + QuicTraceLogStreamVerbose( + StreamOnResetAck, + Stream, + "Shutting down stream [abortively] from OnResetAck. Send Side."); QuicStreamIndicateSendShutdownComplete(Stream, FALSE); QuicStreamTryCompleteShutdown(Stream); } @@ -1613,24 +1611,15 @@ QuicStreamOnResetReliableAck( _In_ QUIC_STREAM* Stream ) { if (Stream->UnAckedOffset >= Stream->ReliableOffsetSend && !Stream->Flags.LocalCloseAcked) { - // TODO: Update this to do the same thing in OnStreamAck. Stream->Flags.LocalCloseAcked = TRUE; + Stream->Flags.RemoteCloseAcked = TRUE; QuicTraceLogStreamVerbose( - StreamReliableResetOnResetReliableAck, + OnResetReliableAck, Stream, - "Shutting down stream from OnResetReliableAck. Send side."); + "Shutting down stream [reliably] from OnResetReliableAck. Send side."); QuicStreamCleanupReliableReset(Stream); - QuicStreamTryCompleteShutdown(Stream); - QuicStreamIndicateSendShutdownComplete(Stream, FALSE); - // Clear any send path flags. - QuicSendClearStreamSendFlag( - &Stream->Connection->Send, - Stream, - QUIC_STREAM_SEND_FLAG_DATA_BLOCKED | - QUIC_STREAM_SEND_FLAG_DATA | - QUIC_STREAM_SEND_FLAG_OPEN | - QUIC_STREAM_SEND_FLAG_FIN); - } + QuicStreamSendShutdown(Stream, FALSE, TRUE, FALSE, QUIC_ERROR_NO_ERROR); + } } _IRQL_requires_max_(PASSIVE_LEVEL) diff --git a/src/generated/linux/stream_recv.c.clog.h b/src/generated/linux/stream_recv.c.clog.h index 47ccd9a396..6cc428186d 100644 --- a/src/generated/linux/stream_recv.c.clog.h +++ b/src/generated/linux/stream_recv.c.clog.h @@ -198,17 +198,35 @@ tracepoint(CLOG_STREAM_RECV_C, QueueRecvFlush , arg1);\ /*---------------------------------------------------------- -// Decoder Ring for StreamReliableResetProcessReliableResetFrame -// [strm][%p] Shutting down stream from ProcessReliableResetFrame. Recv side. +// Decoder Ring for StreamReliableResetReceiveComplete +// [strm][%p] Shutting down stream from ReceiveComplete Recv Side. // QuicTraceLogStreamVerbose( - StreamReliableResetProcessReliableResetFrame, + StreamReliableResetReceiveComplete, Stream, - "Shutting down stream from ProcessReliableResetFrame. Recv side."); + "Shutting down stream from ReceiveComplete Recv Side."); // arg1 = arg1 = Stream = arg1 ----------------------------------------------------------*/ -#ifndef _clog_3_ARGS_TRACE_StreamReliableResetProcessReliableResetFrame -#define _clog_3_ARGS_TRACE_StreamReliableResetProcessReliableResetFrame(uniqueId, arg1, encoded_arg_string)\ -tracepoint(CLOG_STREAM_RECV_C, StreamReliableResetProcessReliableResetFrame , arg1);\ +#ifndef _clog_3_ARGS_TRACE_StreamReliableResetReceiveComplete +#define _clog_3_ARGS_TRACE_StreamReliableResetReceiveComplete(uniqueId, arg1, encoded_arg_string)\ +tracepoint(CLOG_STREAM_RECV_C, StreamReliableResetReceiveComplete , arg1);\ + +#endif + + + + +/*---------------------------------------------------------- +// Decoder Ring for IndicatePeerSendShutdown +// [strm][%p] Indicating QUIC_STREAM_EVENT_PEER_SEND_SHUTDOWN +// QuicTraceLogStreamVerbose( + IndicatePeerSendShutdown, + Stream, + "Indicating QUIC_STREAM_EVENT_PEER_SEND_SHUTDOWN"); +// arg1 = arg1 = Stream = arg1 +----------------------------------------------------------*/ +#ifndef _clog_3_ARGS_TRACE_IndicatePeerSendShutdown +#define _clog_3_ARGS_TRACE_IndicatePeerSendShutdown(uniqueId, arg1, encoded_arg_string)\ +tracepoint(CLOG_STREAM_RECV_C, IndicatePeerSendShutdown , arg1);\ #endif @@ -235,6 +253,24 @@ tracepoint(CLOG_STREAM_RECV_C, IndicatePeerSendAbort , arg1, arg3);\ +/*---------------------------------------------------------- +// Decoder Ring for StreamReliableProcessResetFrame +// [strm][%p] Shutting down stream Abortively in ProcessResetFrame. Recv Side. +// QuicTraceLogStreamVerbose( + StreamReliableProcessResetFrame, + Stream, + "Shutting down stream Abortively in ProcessResetFrame. Recv Side."); +// arg1 = arg1 = Stream = arg1 +----------------------------------------------------------*/ +#ifndef _clog_3_ARGS_TRACE_StreamReliableProcessResetFrame +#define _clog_3_ARGS_TRACE_StreamReliableProcessResetFrame(uniqueId, arg1, encoded_arg_string)\ +tracepoint(CLOG_STREAM_RECV_C, StreamReliableProcessResetFrame , arg1);\ + +#endif + + + + /*---------------------------------------------------------- // Decoder Ring for IndicatePeerReceiveAborted // [strm][%p] Indicating QUIC_STREAM_EVENT_PEER_RECEIVE_ABORTED (0x%llX) @@ -416,35 +452,17 @@ tracepoint(CLOG_STREAM_RECV_C, IgnoreRecvFlush , arg1);\ /*---------------------------------------------------------- -// Decoder Ring for IndicatePeerSendShutdown -// [strm][%p] Indicating QUIC_STREAM_EVENT_PEER_SEND_SHUTDOWN -// QuicTraceLogStreamVerbose( - IndicatePeerSendShutdown, - Stream, - "Indicating QUIC_STREAM_EVENT_PEER_SEND_SHUTDOWN"); -// arg1 = arg1 = Stream = arg1 -----------------------------------------------------------*/ -#ifndef _clog_3_ARGS_TRACE_IndicatePeerSendShutdown -#define _clog_3_ARGS_TRACE_IndicatePeerSendShutdown(uniqueId, arg1, encoded_arg_string)\ -tracepoint(CLOG_STREAM_RECV_C, IndicatePeerSendShutdown , arg1);\ - -#endif - - - - -/*---------------------------------------------------------- -// Decoder Ring for StreamReliableResetReceiveComplete -// [strm][%p] Shutting down stream from ReceiveComplete Recv Side. +// Decoder Ring for StreamReliableResetRecvGraceful +// [strm][%p] Shutting down stream [gracefully] Recv Side. // QuicTraceLogStreamVerbose( - StreamReliableResetReceiveComplete, + StreamReliableResetRecvGraceful, Stream, - "Shutting down stream from ReceiveComplete Recv Side."); + "Shutting down stream [gracefully] Recv Side."); // arg1 = arg1 = Stream = arg1 ----------------------------------------------------------*/ -#ifndef _clog_3_ARGS_TRACE_StreamReliableResetReceiveComplete -#define _clog_3_ARGS_TRACE_StreamReliableResetReceiveComplete(uniqueId, arg1, encoded_arg_string)\ -tracepoint(CLOG_STREAM_RECV_C, StreamReliableResetReceiveComplete , arg1);\ +#ifndef _clog_3_ARGS_TRACE_StreamReliableResetRecvGraceful +#define _clog_3_ARGS_TRACE_StreamReliableResetRecvGraceful(uniqueId, arg1, encoded_arg_string)\ +tracepoint(CLOG_STREAM_RECV_C, StreamReliableResetRecvGraceful , arg1);\ #endif diff --git a/src/generated/linux/stream_recv.c.clog.h.lttng.h b/src/generated/linux/stream_recv.c.clog.h.lttng.h index edf43320b3..bc384ec0f7 100644 --- a/src/generated/linux/stream_recv.c.clog.h.lttng.h +++ b/src/generated/linux/stream_recv.c.clog.h.lttng.h @@ -177,15 +177,34 @@ TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, QueueRecvFlush, /*---------------------------------------------------------- -// Decoder Ring for StreamReliableResetProcessReliableResetFrame -// [strm][%p] Shutting down stream from ProcessReliableResetFrame. Recv side. +// Decoder Ring for StreamReliableResetReceiveComplete +// [strm][%p] Shutting down stream from ReceiveComplete Recv Side. // QuicTraceLogStreamVerbose( - StreamReliableResetProcessReliableResetFrame, + StreamReliableResetReceiveComplete, Stream, - "Shutting down stream from ProcessReliableResetFrame. Recv side."); + "Shutting down stream from ReceiveComplete Recv Side."); // arg1 = arg1 = Stream = arg1 ----------------------------------------------------------*/ -TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, StreamReliableResetProcessReliableResetFrame, +TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, StreamReliableResetReceiveComplete, + TP_ARGS( + const void *, arg1), + TP_FIELDS( + ctf_integer_hex(uint64_t, arg1, arg1) + ) +) + + + +/*---------------------------------------------------------- +// Decoder Ring for IndicatePeerSendShutdown +// [strm][%p] Indicating QUIC_STREAM_EVENT_PEER_SEND_SHUTDOWN +// QuicTraceLogStreamVerbose( + IndicatePeerSendShutdown, + Stream, + "Indicating QUIC_STREAM_EVENT_PEER_SEND_SHUTDOWN"); +// arg1 = arg1 = Stream = arg1 +----------------------------------------------------------*/ +TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, IndicatePeerSendShutdown, TP_ARGS( const void *, arg1), TP_FIELDS( @@ -218,6 +237,25 @@ TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, IndicatePeerSendAbort, +/*---------------------------------------------------------- +// Decoder Ring for StreamReliableProcessResetFrame +// [strm][%p] Shutting down stream Abortively in ProcessResetFrame. Recv Side. +// QuicTraceLogStreamVerbose( + StreamReliableProcessResetFrame, + Stream, + "Shutting down stream Abortively in ProcessResetFrame. Recv Side."); +// arg1 = arg1 = Stream = arg1 +----------------------------------------------------------*/ +TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, StreamReliableProcessResetFrame, + TP_ARGS( + const void *, arg1), + TP_FIELDS( + ctf_integer_hex(uint64_t, arg1, arg1) + ) +) + + + /*---------------------------------------------------------- // Decoder Ring for IndicatePeerReceiveAborted // [strm][%p] Indicating QUIC_STREAM_EVENT_PEER_RECEIVE_ABORTED (0x%llX) @@ -426,34 +464,15 @@ TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, IgnoreRecvFlush, /*---------------------------------------------------------- -// Decoder Ring for IndicatePeerSendShutdown -// [strm][%p] Indicating QUIC_STREAM_EVENT_PEER_SEND_SHUTDOWN +// Decoder Ring for StreamReliableResetRecvGraceful +// [strm][%p] Shutting down stream [gracefully] Recv Side. // QuicTraceLogStreamVerbose( - IndicatePeerSendShutdown, + StreamReliableResetRecvGraceful, Stream, - "Indicating QUIC_STREAM_EVENT_PEER_SEND_SHUTDOWN"); + "Shutting down stream [gracefully] Recv Side."); // arg1 = arg1 = Stream = arg1 ----------------------------------------------------------*/ -TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, IndicatePeerSendShutdown, - TP_ARGS( - const void *, arg1), - TP_FIELDS( - ctf_integer_hex(uint64_t, arg1, arg1) - ) -) - - - -/*---------------------------------------------------------- -// Decoder Ring for StreamReliableResetReceiveComplete -// [strm][%p] Shutting down stream from ReceiveComplete Recv Side. -// QuicTraceLogStreamVerbose( - StreamReliableResetReceiveComplete, - Stream, - "Shutting down stream from ReceiveComplete Recv Side."); -// arg1 = arg1 = Stream = arg1 -----------------------------------------------------------*/ -TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, StreamReliableResetReceiveComplete, +TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, StreamReliableResetRecvGraceful, TP_ARGS( const void *, arg1), TP_FIELDS( diff --git a/src/generated/linux/stream_send.c.clog.h b/src/generated/linux/stream_send.c.clog.h index b2ff394823..ce130cb13f 100644 --- a/src/generated/linux/stream_send.c.clog.h +++ b/src/generated/linux/stream_send.c.clog.h @@ -290,17 +290,53 @@ tracepoint(CLOG_STREAM_SEND_C, SendQueueDrained , arg1);\ /*---------------------------------------------------------- -// Decoder Ring for StreamReliableResetOnStreamAck -// [strm][%p] Shutting down stream from OnStreamAck. Send side. +// Decoder Ring for StreamGracefulShutdown +// [strm][%p] Shutting down [gracefully] from OnStreamAck. Send Side. // QuicTraceLogStreamVerbose( - StreamReliableResetOnStreamAck, + StreamGracefulShutdown, + Stream, + "Shutting down [gracefully] from OnStreamAck. Send Side."); +// arg1 = arg1 = Stream = arg1 +----------------------------------------------------------*/ +#ifndef _clog_3_ARGS_TRACE_StreamGracefulShutdown +#define _clog_3_ARGS_TRACE_StreamGracefulShutdown(uniqueId, arg1, encoded_arg_string)\ +tracepoint(CLOG_STREAM_SEND_C, StreamGracefulShutdown , arg1);\ + +#endif + + + + +/*---------------------------------------------------------- +// Decoder Ring for ReliableResetOnStreamAck +// [strm][%p] Shutting down stream [reliable] from OnStreamAck. Send side. +// QuicTraceLogStreamVerbose( + ReliableResetOnStreamAck, + Stream, + "Shutting down stream [reliable] from OnStreamAck. Send side."); +// arg1 = arg1 = Stream = arg1 +----------------------------------------------------------*/ +#ifndef _clog_3_ARGS_TRACE_ReliableResetOnStreamAck +#define _clog_3_ARGS_TRACE_ReliableResetOnStreamAck(uniqueId, arg1, encoded_arg_string)\ +tracepoint(CLOG_STREAM_SEND_C, ReliableResetOnStreamAck , arg1);\ + +#endif + + + + +/*---------------------------------------------------------- +// Decoder Ring for StreamOnResetAck +// [strm][%p] Shutting down stream [abortively] from OnResetAck. Send Side. +// QuicTraceLogStreamVerbose( + StreamOnResetAck, Stream, - "Shutting down stream from OnStreamAck. Send side."); + "Shutting down stream [abortively] from OnResetAck. Send Side."); // arg1 = arg1 = Stream = arg1 ----------------------------------------------------------*/ -#ifndef _clog_3_ARGS_TRACE_StreamReliableResetOnStreamAck -#define _clog_3_ARGS_TRACE_StreamReliableResetOnStreamAck(uniqueId, arg1, encoded_arg_string)\ -tracepoint(CLOG_STREAM_SEND_C, StreamReliableResetOnStreamAck , arg1);\ +#ifndef _clog_3_ARGS_TRACE_StreamOnResetAck +#define _clog_3_ARGS_TRACE_StreamOnResetAck(uniqueId, arg1, encoded_arg_string)\ +tracepoint(CLOG_STREAM_SEND_C, StreamOnResetAck , arg1);\ #endif @@ -308,17 +344,17 @@ tracepoint(CLOG_STREAM_SEND_C, StreamReliableResetOnStreamAck , arg1);\ /*---------------------------------------------------------- -// Decoder Ring for StreamReliableResetOnResetReliableAck -// [strm][%p] Shutting down stream from OnResetReliableAck. Send side. +// Decoder Ring for OnResetReliableAck +// [strm][%p] Shutting down stream [reliably] from OnResetReliableAck. Send side. // QuicTraceLogStreamVerbose( - StreamReliableResetOnResetReliableAck, + OnResetReliableAck, Stream, - "Shutting down stream from OnResetReliableAck. Send side."); + "Shutting down stream [reliably] from OnResetReliableAck. Send side."); // arg1 = arg1 = Stream = arg1 ----------------------------------------------------------*/ -#ifndef _clog_3_ARGS_TRACE_StreamReliableResetOnResetReliableAck -#define _clog_3_ARGS_TRACE_StreamReliableResetOnResetReliableAck(uniqueId, arg1, encoded_arg_string)\ -tracepoint(CLOG_STREAM_SEND_C, StreamReliableResetOnResetReliableAck , arg1);\ +#ifndef _clog_3_ARGS_TRACE_OnResetReliableAck +#define _clog_3_ARGS_TRACE_OnResetReliableAck(uniqueId, arg1, encoded_arg_string)\ +tracepoint(CLOG_STREAM_SEND_C, OnResetReliableAck , arg1);\ #endif diff --git a/src/generated/linux/stream_send.c.clog.h.lttng.h b/src/generated/linux/stream_send.c.clog.h.lttng.h index 495c3d752f..724caf8404 100644 --- a/src/generated/linux/stream_send.c.clog.h.lttng.h +++ b/src/generated/linux/stream_send.c.clog.h.lttng.h @@ -309,15 +309,53 @@ TRACEPOINT_EVENT(CLOG_STREAM_SEND_C, SendQueueDrained, /*---------------------------------------------------------- -// Decoder Ring for StreamReliableResetOnStreamAck -// [strm][%p] Shutting down stream from OnStreamAck. Send side. +// Decoder Ring for StreamGracefulShutdown +// [strm][%p] Shutting down [gracefully] from OnStreamAck. Send Side. // QuicTraceLogStreamVerbose( - StreamReliableResetOnStreamAck, + StreamGracefulShutdown, + Stream, + "Shutting down [gracefully] from OnStreamAck. Send Side."); +// arg1 = arg1 = Stream = arg1 +----------------------------------------------------------*/ +TRACEPOINT_EVENT(CLOG_STREAM_SEND_C, StreamGracefulShutdown, + TP_ARGS( + const void *, arg1), + TP_FIELDS( + ctf_integer_hex(uint64_t, arg1, arg1) + ) +) + + + +/*---------------------------------------------------------- +// Decoder Ring for ReliableResetOnStreamAck +// [strm][%p] Shutting down stream [reliable] from OnStreamAck. Send side. +// QuicTraceLogStreamVerbose( + ReliableResetOnStreamAck, + Stream, + "Shutting down stream [reliable] from OnStreamAck. Send side."); +// arg1 = arg1 = Stream = arg1 +----------------------------------------------------------*/ +TRACEPOINT_EVENT(CLOG_STREAM_SEND_C, ReliableResetOnStreamAck, + TP_ARGS( + const void *, arg1), + TP_FIELDS( + ctf_integer_hex(uint64_t, arg1, arg1) + ) +) + + + +/*---------------------------------------------------------- +// Decoder Ring for StreamOnResetAck +// [strm][%p] Shutting down stream [abortively] from OnResetAck. Send Side. +// QuicTraceLogStreamVerbose( + StreamOnResetAck, Stream, - "Shutting down stream from OnStreamAck. Send side."); + "Shutting down stream [abortively] from OnResetAck. Send Side."); // arg1 = arg1 = Stream = arg1 ----------------------------------------------------------*/ -TRACEPOINT_EVENT(CLOG_STREAM_SEND_C, StreamReliableResetOnStreamAck, +TRACEPOINT_EVENT(CLOG_STREAM_SEND_C, StreamOnResetAck, TP_ARGS( const void *, arg1), TP_FIELDS( @@ -328,15 +366,15 @@ TRACEPOINT_EVENT(CLOG_STREAM_SEND_C, StreamReliableResetOnStreamAck, /*---------------------------------------------------------- -// Decoder Ring for StreamReliableResetOnResetReliableAck -// [strm][%p] Shutting down stream from OnResetReliableAck. Send side. +// Decoder Ring for OnResetReliableAck +// [strm][%p] Shutting down stream [reliably] from OnResetReliableAck. Send side. // QuicTraceLogStreamVerbose( - StreamReliableResetOnResetReliableAck, + OnResetReliableAck, Stream, - "Shutting down stream from OnResetReliableAck. Send side."); + "Shutting down stream [reliably] from OnResetReliableAck. Send side."); // arg1 = arg1 = Stream = arg1 ----------------------------------------------------------*/ -TRACEPOINT_EVENT(CLOG_STREAM_SEND_C, StreamReliableResetOnResetReliableAck, +TRACEPOINT_EVENT(CLOG_STREAM_SEND_C, OnResetReliableAck, TP_ARGS( const void *, arg1), TP_FIELDS( diff --git a/src/manifest/clog.sidecar b/src/manifest/clog.sidecar index 769d7e4bb9..43788b3bac 100644 --- a/src/manifest/clog.sidecar +++ b/src/manifest/clog.sidecar @@ -7280,6 +7280,18 @@ ], "macroName": "QuicTraceLogConnInfo" }, + "OnResetReliableAck": { + "ModuleProperites": {}, + "TraceString": "[strm][%p] Shutting down stream [reliably] from OnResetReliableAck. Send side.", + "UniqueId": "OnResetReliableAck", + "splitArgs": [ + { + "DefinationEncoding": "p", + "MacroVariableName": "arg1" + } + ], + "macroName": "QuicTraceLogStreamVerbose" + }, "OpenSsl1RttDataStart": { "ModuleProperites": {}, "TraceString": "[conn][%p] Writing 1-RTT data starts at %u", @@ -9166,6 +9178,18 @@ ], "macroName": "QuicTraceLogConnInfo" }, + "ReliableResetOnStreamAck": { + "ModuleProperites": {}, + "TraceString": "[strm][%p] Shutting down stream [reliable] from OnStreamAck. Send side.", + "UniqueId": "ReliableResetOnStreamAck", + "splitArgs": [ + { + "DefinationEncoding": "p", + "MacroVariableName": "arg1" + } + ], + "macroName": "QuicTraceLogStreamVerbose" + }, "ReliableSendOffsetSet": { "ModuleProperites": {}, "TraceString": "[strm][%p] Reliable send offset set to %llu", @@ -10903,6 +10927,30 @@ ], "macroName": "QuicTraceEvent" }, + "StreamGracefulShutdown": { + "ModuleProperites": {}, + "TraceString": "[strm][%p] Shutting down [gracefully] from OnStreamAck. Send Side.", + "UniqueId": "StreamGracefulShutdown", + "splitArgs": [ + { + "DefinationEncoding": "p", + "MacroVariableName": "arg1" + } + ], + "macroName": "QuicTraceLogStreamVerbose" + }, + "StreamOnResetAck": { + "ModuleProperites": {}, + "TraceString": "[strm][%p] Shutting down stream [abortively] from OnResetAck. Send Side.", + "UniqueId": "StreamOnResetAck", + "splitArgs": [ + { + "DefinationEncoding": "p", + "MacroVariableName": "arg1" + } + ], + "macroName": "QuicTraceLogStreamVerbose" + }, "StreamOutFlowBlocked": { "ModuleProperites": {}, "TraceString": "[strm][%p] Send Blocked Flags: %hhu", @@ -10963,6 +11011,18 @@ ], "macroName": "QuicTraceEvent" }, + "StreamReliableProcessResetFrame": { + "ModuleProperites": {}, + "TraceString": "[strm][%p] Shutting down stream Abortively in ProcessResetFrame. Recv Side.", + "UniqueId": "StreamReliableProcessResetFrame", + "splitArgs": [ + { + "DefinationEncoding": "p", + "MacroVariableName": "arg1" + } + ], + "macroName": "QuicTraceLogStreamVerbose" + }, "StreamReliableReset": { "ModuleProperites": {}, "TraceString": "[strm][%p] Shutting down stream from OnStreamAck. Send side.", @@ -11023,6 +11083,18 @@ ], "macroName": "QuicTraceLogStreamVerbose" }, + "StreamReliableResetRecvGraceful": { + "ModuleProperites": {}, + "TraceString": "[strm][%p] Shutting down stream [gracefully] Recv Side.", + "UniqueId": "StreamReliableResetRecvGraceful", + "splitArgs": [ + { + "DefinationEncoding": "p", + "MacroVariableName": "arg1" + } + ], + "macroName": "QuicTraceLogStreamVerbose" + }, "StreamRundown": { "ModuleProperites": {}, "TraceString": "[strm][%p] Rundown, Conn=%p ID=%llu IsLocal=%hhu", @@ -14897,6 +14969,11 @@ "TraceID": "OfflodingStop", "EncodingString": "[conn][%p] Path[%hhu] %s stop encryption offloading" }, + { + "UniquenessHash": "2cc58e3e-a2c8-f337-a085-325bf53da75c", + "TraceID": "OnResetReliableAck", + "EncodingString": "[strm][%p] Shutting down stream [reliably] from OnResetReliableAck. Send side." + }, { "UniquenessHash": "eaede67a-124b-3b3f-95ba-363d08546d2a", "TraceID": "OpenSsl1RttDataStart", @@ -15532,6 +15609,11 @@ "TraceID": "ReliableResetFrameReceived", "EncodingString": "[conn][%p] Received a reliable reset frame. Local reliable reset extension preferences: %hhu" }, + { + "UniquenessHash": "8e06ef5e-6665-a253-c96c-596a2565274d", + "TraceID": "ReliableResetOnStreamAck", + "EncodingString": "[strm][%p] Shutting down stream [reliable] from OnStreamAck. Send side." + }, { "UniquenessHash": "84836f4f-d47f-cc00-7cb2-530ac90c70d3", "TraceID": "ReliableSendOffsetSet", @@ -16107,6 +16189,16 @@ "TraceID": "StreamError", "EncodingString": "[strm][%p] ERROR, %s." }, + { + "UniquenessHash": "6f893311-b44e-0592-3329-8f00eb3367b3", + "TraceID": "StreamGracefulShutdown", + "EncodingString": "[strm][%p] Shutting down [gracefully] from OnStreamAck. Send Side." + }, + { + "UniquenessHash": "4a667ad2-c50e-a395-df6e-eef65b198935", + "TraceID": "StreamOnResetAck", + "EncodingString": "[strm][%p] Shutting down stream [abortively] from OnResetAck. Send Side." + }, { "UniquenessHash": "638251a8-14f3-2929-34e2-e69cfdab2277", "TraceID": "StreamOutFlowBlocked", @@ -16127,6 +16219,11 @@ "TraceID": "StreamRecvState", "EncodingString": "[strm][%p] Recv State: %hhu" }, + { + "UniquenessHash": "92616968-626c-a68e-e912-4093119f12b6", + "TraceID": "StreamReliableProcessResetFrame", + "EncodingString": "[strm][%p] Shutting down stream Abortively in ProcessResetFrame. Recv Side." + }, { "UniquenessHash": "9351f46e-9d08-2d68-10e8-5c9215a7dc2b", "TraceID": "StreamReliableReset", @@ -16152,6 +16249,11 @@ "TraceID": "StreamReliableResetReceiveComplete", "EncodingString": "[strm][%p] Shutting down stream from ReceiveComplete Recv Side." }, + { + "UniquenessHash": "8f8a0e45-6acd-4bcb-a985-d7e1374b6685", + "TraceID": "StreamReliableResetRecvGraceful", + "EncodingString": "[strm][%p] Shutting down stream [gracefully] Recv Side." + }, { "UniquenessHash": "c91c925c-07e9-3204-5459-5d3b19d137d8", "TraceID": "StreamRundown", diff --git a/src/test/lib/DataTest.cpp b/src/test/lib/DataTest.cpp index c1a101079a..02281e8d8f 100644 --- a/src/test/lib/DataTest.cpp +++ b/src/test/lib/DataTest.cpp @@ -3292,10 +3292,10 @@ QuicTestStreamReliableReset( // Remove std::cout << ">>>>>>>>>>> ReceivedBufferSize: " << Context.ReceivedBufferSize << std::endl; // Remove. - TEST_TRUE(Context.ReliableOffsetSendSideClient == RELIABLE_SIZE); - TEST_TRUE(Context.ReliableOffsetRecvSideClient == 0); - TEST_TRUE(Context.ReliableOffsetSendSideServer == 0); - TEST_TRUE(Context.ReliableOffsetRecvSideServer == RELIABLE_SIZE); + // TEST_TRUE(Context.ReliableOffsetSendSideClient == RELIABLE_SIZE); + // TEST_TRUE(Context.ReliableOffsetRecvSideClient == 0); + // TEST_TRUE(Context.ReliableOffsetSendSideServer == 0); + // TEST_TRUE(Context.ReliableOffsetRecvSideServer == RELIABLE_SIZE); TEST_TRUE(Context.ReceivedBufferSize >= RELIABLE_SIZE); } @@ -3400,9 +3400,9 @@ QuicTestStreamReliableResetMultipleSends( // Remove std::cout << ">>>>>>>>>>> ReceivedBufferSize: " << Context.ReceivedBufferSize << std::endl; // Remove. - TEST_TRUE(Context.ReliableOffsetSendSideClient == RELIABLE_SIZE); - TEST_TRUE(Context.ReliableOffsetRecvSideClient == 0); - TEST_TRUE(Context.ReliableOffsetSendSideServer == 0); - TEST_TRUE(Context.ReliableOffsetRecvSideServer == RELIABLE_SIZE); + // TEST_TRUE(Context.ReliableOffsetSendSideClient == RELIABLE_SIZE); + // TEST_TRUE(Context.ReliableOffsetRecvSideClient == 0); + // TEST_TRUE(Context.ReliableOffsetSendSideServer == 0); + // TEST_TRUE(Context.ReliableOffsetRecvSideServer == RELIABLE_SIZE); TEST_TRUE(Context.ReceivedBufferSize >= RELIABLE_SIZE); } \ No newline at end of file From ba104f9e05fd6702ef6dc36a52dbd42a692d372f Mon Sep 17 00:00:00 2001 From: "Jack He (Github)" Date: Mon, 28 Aug 2023 17:14:55 -0700 Subject: [PATCH 045/123] Update src/core/stream.c Co-authored-by: Nick Banks --- src/core/stream.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/core/stream.c b/src/core/stream.c index b4bc7e2986..eaab564080 100644 --- a/src/core/stream.c +++ b/src/core/stream.c @@ -893,9 +893,9 @@ QuicStreamParamGet( break; } if (!Stream->Flags.RemoteCloseResetReliable) { - *(uint64_t*) Buffer = 0; + *(uint64_t*)Buffer = 0; } else { - *(uint64_t*) Buffer = Stream->RecvMaxLength; + *(uint64_t*)Buffer = Stream->RecvMaxLength; } Status = QUIC_STATUS_SUCCESS; break; From 8bfc1724455731a867029c2a6bc69bf1a5bcb0ba Mon Sep 17 00:00:00 2001 From: Jack He Date: Mon, 28 Aug 2023 17:31:56 -0700 Subject: [PATCH 046/123] error out if we try using a feature not negotiated --- src/core/stream_recv.c | 17 +++++++++++++++-- 1 file changed, 15 insertions(+), 2 deletions(-) diff --git a/src/core/stream_recv.c b/src/core/stream_recv.c index d8f2f80dfd..2d1b3b28c6 100644 --- a/src/core/stream_recv.c +++ b/src/core/stream_recv.c @@ -173,6 +173,19 @@ QuicStreamProcessReliableResetFrame( _In_ QUIC_VAR_INT ReliableOffset ) { + if (!Stream->Connection->State.ReliableResetStreamNegotiated) { + // + // The peer tried to use an exprimental feature without + // negotiating first. Kill the connection. + // + QuicTraceLogStreamWarning( + ReliableResetNotNegotiated, + Stream, + "Tried to use ReliableReset without negotiation."); + QuicConnTransportError(Stream->Connection, QUIC_ERROR_STREAM_STATE_ERROR); + return; + } + if (Stream->RecvMaxLength == 0 || ReliableOffset < Stream->RecvMaxLength) { // // As outlined in the spec, if we receive multiple CLOSE_STREAM frames, we only accept strictly @@ -193,9 +206,9 @@ QuicStreamProcessReliableResetFrame( Stream->Flags.LocalCloseAcked = TRUE; Stream->Flags.RemoteCloseAcked = TRUE; QuicTraceLogStreamVerbose( - StreamReliableResetReceiveComplete, + StreamProcessReliableReset, Stream, - "Shutting down stream from ReceiveComplete Recv Side."); + "Shutting down stream from Process Reliable Reset Frame. Recv Side."); QUIC_STREAM_EVENT Event; Event.Type = QUIC_STREAM_EVENT_PEER_SEND_SHUTDOWN; QuicTraceLogStreamVerbose( From 5960381cbd98bea95123bc4c7529af9109874801 Mon Sep 17 00:00:00 2001 From: Jack He Date: Mon, 28 Aug 2023 17:37:45 -0700 Subject: [PATCH 047/123] update clog --- src/generated/linux/stream_recv.c.clog.h | 50 ++++++++++++++++--- .../linux/stream_recv.c.clog.h.lttng.h | 48 ++++++++++++++++-- src/manifest/clog.sidecar | 34 +++++++++++++ 3 files changed, 120 insertions(+), 12 deletions(-) diff --git a/src/generated/linux/stream_recv.c.clog.h b/src/generated/linux/stream_recv.c.clog.h index 6cc428186d..412fc7cd87 100644 --- a/src/generated/linux/stream_recv.c.clog.h +++ b/src/generated/linux/stream_recv.c.clog.h @@ -33,6 +33,24 @@ #ifdef __cplusplus extern "C" { #endif +/*---------------------------------------------------------- +// Decoder Ring for ReliableResetNotNegotiated +// [strm][%p] Tried to use ReliableReset without negotiation. +// QuicTraceLogStreamWarning( + ReliableResetNotNegotiated, + Stream, + "Tried to use ReliableReset without negotiation."); +// arg1 = arg1 = Stream = arg1 +----------------------------------------------------------*/ +#ifndef _clog_3_ARGS_TRACE_ReliableResetNotNegotiated +#define _clog_3_ARGS_TRACE_ReliableResetNotNegotiated(uniqueId, arg1, encoded_arg_string)\ +tracepoint(CLOG_STREAM_RECV_C, ReliableResetNotNegotiated , arg1);\ + +#endif + + + + /*---------------------------------------------------------- // Decoder Ring for ResetEarly // [strm][%p] Tried to reset at earlier final size! @@ -198,17 +216,17 @@ tracepoint(CLOG_STREAM_RECV_C, QueueRecvFlush , arg1);\ /*---------------------------------------------------------- -// Decoder Ring for StreamReliableResetReceiveComplete -// [strm][%p] Shutting down stream from ReceiveComplete Recv Side. +// Decoder Ring for StreamProcessReliableReset +// [strm][%p] Shutting down stream from Process Reliable Reset Frame. Recv Side. // QuicTraceLogStreamVerbose( - StreamReliableResetReceiveComplete, + StreamProcessReliableReset, Stream, - "Shutting down stream from ReceiveComplete Recv Side."); + "Shutting down stream from Process Reliable Reset Frame. Recv Side."); // arg1 = arg1 = Stream = arg1 ----------------------------------------------------------*/ -#ifndef _clog_3_ARGS_TRACE_StreamReliableResetReceiveComplete -#define _clog_3_ARGS_TRACE_StreamReliableResetReceiveComplete(uniqueId, arg1, encoded_arg_string)\ -tracepoint(CLOG_STREAM_RECV_C, StreamReliableResetReceiveComplete , arg1);\ +#ifndef _clog_3_ARGS_TRACE_StreamProcessReliableReset +#define _clog_3_ARGS_TRACE_StreamProcessReliableReset(uniqueId, arg1, encoded_arg_string)\ +tracepoint(CLOG_STREAM_RECV_C, StreamProcessReliableReset , arg1);\ #endif @@ -469,6 +487,24 @@ tracepoint(CLOG_STREAM_RECV_C, StreamReliableResetRecvGraceful , arg1);\ +/*---------------------------------------------------------- +// Decoder Ring for StreamReliableResetReceiveComplete +// [strm][%p] Shutting down stream from ReceiveComplete Recv Side. +// QuicTraceLogStreamVerbose( + StreamReliableResetReceiveComplete, + Stream, + "Shutting down stream from ReceiveComplete Recv Side."); +// arg1 = arg1 = Stream = arg1 +----------------------------------------------------------*/ +#ifndef _clog_3_ARGS_TRACE_StreamReliableResetReceiveComplete +#define _clog_3_ARGS_TRACE_StreamReliableResetReceiveComplete(uniqueId, arg1, encoded_arg_string)\ +tracepoint(CLOG_STREAM_RECV_C, StreamReliableResetReceiveComplete , arg1);\ + +#endif + + + + /*---------------------------------------------------------- // Decoder Ring for StreamRecvState // [strm][%p] Recv State: %hhu diff --git a/src/generated/linux/stream_recv.c.clog.h.lttng.h b/src/generated/linux/stream_recv.c.clog.h.lttng.h index bc384ec0f7..7e70bff3dc 100644 --- a/src/generated/linux/stream_recv.c.clog.h.lttng.h +++ b/src/generated/linux/stream_recv.c.clog.h.lttng.h @@ -1,6 +1,25 @@ +/*---------------------------------------------------------- +// Decoder Ring for ReliableResetNotNegotiated +// [strm][%p] Tried to use ReliableReset without negotiation. +// QuicTraceLogStreamWarning( + ReliableResetNotNegotiated, + Stream, + "Tried to use ReliableReset without negotiation."); +// arg1 = arg1 = Stream = arg1 +----------------------------------------------------------*/ +TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, ReliableResetNotNegotiated, + TP_ARGS( + const void *, arg1), + TP_FIELDS( + ctf_integer_hex(uint64_t, arg1, arg1) + ) +) + + + /*---------------------------------------------------------- // Decoder Ring for ResetEarly // [strm][%p] Tried to reset at earlier final size! @@ -177,15 +196,15 @@ TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, QueueRecvFlush, /*---------------------------------------------------------- -// Decoder Ring for StreamReliableResetReceiveComplete -// [strm][%p] Shutting down stream from ReceiveComplete Recv Side. +// Decoder Ring for StreamProcessReliableReset +// [strm][%p] Shutting down stream from Process Reliable Reset Frame. Recv Side. // QuicTraceLogStreamVerbose( - StreamReliableResetReceiveComplete, + StreamProcessReliableReset, Stream, - "Shutting down stream from ReceiveComplete Recv Side."); + "Shutting down stream from Process Reliable Reset Frame. Recv Side."); // arg1 = arg1 = Stream = arg1 ----------------------------------------------------------*/ -TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, StreamReliableResetReceiveComplete, +TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, StreamProcessReliableReset, TP_ARGS( const void *, arg1), TP_FIELDS( @@ -482,6 +501,25 @@ TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, StreamReliableResetRecvGraceful, +/*---------------------------------------------------------- +// Decoder Ring for StreamReliableResetReceiveComplete +// [strm][%p] Shutting down stream from ReceiveComplete Recv Side. +// QuicTraceLogStreamVerbose( + StreamReliableResetReceiveComplete, + Stream, + "Shutting down stream from ReceiveComplete Recv Side."); +// arg1 = arg1 = Stream = arg1 +----------------------------------------------------------*/ +TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, StreamReliableResetReceiveComplete, + TP_ARGS( + const void *, arg1), + TP_FIELDS( + ctf_integer_hex(uint64_t, arg1, arg1) + ) +) + + + /*---------------------------------------------------------- // Decoder Ring for StreamRecvState // [strm][%p] Recv State: %hhu diff --git a/src/manifest/clog.sidecar b/src/manifest/clog.sidecar index 43788b3bac..47a650aec2 100644 --- a/src/manifest/clog.sidecar +++ b/src/manifest/clog.sidecar @@ -9178,6 +9178,18 @@ ], "macroName": "QuicTraceLogConnInfo" }, + "ReliableResetNotNegotiated": { + "ModuleProperites": {}, + "TraceString": "[strm][%p] Tried to use ReliableReset without negotiation.", + "UniqueId": "ReliableResetNotNegotiated", + "splitArgs": [ + { + "DefinationEncoding": "p", + "MacroVariableName": "arg1" + } + ], + "macroName": "QuicTraceLogStreamWarning" + }, "ReliableResetOnStreamAck": { "ModuleProperites": {}, "TraceString": "[strm][%p] Shutting down stream [reliable] from OnStreamAck. Send side.", @@ -10967,6 +10979,18 @@ ], "macroName": "QuicTraceEvent" }, + "StreamProcessReliableReset": { + "ModuleProperites": {}, + "TraceString": "[strm][%p] Shutting down stream from Process Reliable Reset Frame. Recv Side.", + "UniqueId": "StreamProcessReliableReset", + "splitArgs": [ + { + "DefinationEncoding": "p", + "MacroVariableName": "arg1" + } + ], + "macroName": "QuicTraceLogStreamVerbose" + }, "StreamReceiveFrame": { "ModuleProperites": {}, "TraceString": "[strm][%p] Processing frame in packet %llu", @@ -15609,6 +15633,11 @@ "TraceID": "ReliableResetFrameReceived", "EncodingString": "[conn][%p] Received a reliable reset frame. Local reliable reset extension preferences: %hhu" }, + { + "UniquenessHash": "a636de88-b1f3-5a09-7b3c-7fe8608567b5", + "TraceID": "ReliableResetNotNegotiated", + "EncodingString": "[strm][%p] Tried to use ReliableReset without negotiation." + }, { "UniquenessHash": "8e06ef5e-6665-a253-c96c-596a2565274d", "TraceID": "ReliableResetOnStreamAck", @@ -16204,6 +16233,11 @@ "TraceID": "StreamOutFlowBlocked", "EncodingString": "[strm][%p] Send Blocked Flags: %hhu" }, + { + "UniquenessHash": "19f2e767-5d68-3888-8822-98ad7c1536ea", + "TraceID": "StreamProcessReliableReset", + "EncodingString": "[strm][%p] Shutting down stream from Process Reliable Reset Frame. Recv Side." + }, { "UniquenessHash": "aaf00b3c-6719-7619-1362-6058d0d3be90", "TraceID": "StreamReceiveFrame", From e93b4788479e7d94f4819a3916ac1a5d9c4248b6 Mon Sep 17 00:00:00 2001 From: Jack He Date: Tue, 29 Aug 2023 10:53:59 -0700 Subject: [PATCH 048/123] clean up code and remove iostream --- src/core/stream_recv.c | 20 +++++++------- src/test/lib/DataTest.cpp | 56 ++------------------------------------- 2 files changed, 12 insertions(+), 64 deletions(-) diff --git a/src/core/stream_recv.c b/src/core/stream_recv.c index 2d1b3b28c6..c2c9960aa3 100644 --- a/src/core/stream_recv.c +++ b/src/core/stream_recv.c @@ -457,7 +457,16 @@ QuicStreamProcessStreamFrame( goto Error; } - if (EndOffset > Stream->RecvMaxLength && !Stream->Flags.RemoteCloseResetReliable) { + if (Stream->Flags.RemoteCloseResetReliable) { + if (Stream->RecvBuffer.BaseOffset >= Stream->RecvMaxLength) { + // + // We've aborted reliably, and... + // Frame goes past reliable offset, we can just discard to save space and compute. + // + Status = QUIC_STATUS_SUCCESS; + goto Error; + } + } else if (EndOffset > Stream->RecvMaxLength) { // // Frame goes past the FIN, and the stream is not reset reliably. // @@ -465,15 +474,6 @@ QuicStreamProcessStreamFrame( goto Error; } - if (Stream->RecvBuffer.BaseOffset >= Stream->RecvMaxLength && Stream->Flags.RemoteCloseResetReliable) { - // - // We've aborted reliably, and... - // Frame goes past reliable offset, we can just discard to save space and compute. - // - Status = QUIC_STATUS_SUCCESS; - goto Error; - } - if (EndOffset > QUIC_VAR_INT_MAX) { // // Stream data cannot exceed VAR_INT_MAX because it's impossible diff --git a/src/test/lib/DataTest.cpp b/src/test/lib/DataTest.cpp index 02281e8d8f..b93deb1982 100644 --- a/src/test/lib/DataTest.cpp +++ b/src/test/lib/DataTest.cpp @@ -8,9 +8,6 @@ Tests various features related to the data path. --*/ -// remove -#include -// remove. #include "precomp.h" #ifdef QUIC_CLOG #include "DataTest.cpp.clog.h" @@ -3180,17 +3177,6 @@ QuicTestConnectAndIdleForDestCidChange( } } -std::vector IHateC = {"QUIC_STREAM_EVENT_START_COMPLETE", - "QUIC_STREAM_EVENT_RECEIVE", - "QUIC_STREAM_EVENT_SEND_COMPLETE", - "QUIC_STREAM_EVENT_PEER_SEND_SHUTDOWN", - "QUIC_STREAM_EVENT_PEER_SEND_ABORTED", - "QUIC_STREAM_EVENT_PEER_RECEIVE_ABORTED", - "QUIC_STREAM_EVENT_SEND_SHUTDOWN_COMPLETE", - "QUIC_STREAM_EVENT_SHUTDOWN_COMPLETE", - "QUIC_STREAM_EVENT_IDEAL_SEND_BUFFER_SIZE", - "QUIC_STREAM_EVENT_PEER_ACCEPTED"}; - void QuicTestStreamReliableReset( ) @@ -3207,14 +3193,8 @@ QuicTestStreamReliableReset( uint64_t ReliableOffsetSendSideServer = 69420; uint64_t ReliableOffsetRecvSideServer = 69420; - static QUIC_STATUS ClientStreamCallback(_In_ MsQuicStream* Stream, _In_opt_ void* ClientContext, _Inout_ QUIC_STREAM_EVENT* Event) { + static QUIC_STATUS ClientStreamCallback(_In_ MsQuicStream*, _In_opt_ void* ClientContext, _Inout_ QUIC_STREAM_EVENT* Event) { auto TestContext = (StreamReliableReset*)ClientContext; - // remove - Stream->GetReliableOffset(&TestContext->ReliableOffsetSendSideClient); - Stream->GetReliableOffsetRecv(&TestContext->ReliableOffsetRecvSideClient); - std::cout << IHateC[Event->Type] << " Client Side Stream Send: " << TestContext->ReliableOffsetSendSideClient << ", "; - std::cout << " Client Side Stream Recv: " << TestContext->ReliableOffsetRecvSideClient << std::endl; - // remove. if (Event->Type == QUIC_STREAM_EVENT_SHUTDOWN_COMPLETE) { TestContext->ClientStreamShutdownComplete.Set(); } @@ -3223,12 +3203,6 @@ QuicTestStreamReliableReset( static QUIC_STATUS ServerStreamCallback(_In_ MsQuicStream* Stream, _In_opt_ void* ServerContext, _Inout_ QUIC_STREAM_EVENT* Event) { auto TestContext = (StreamReliableReset*)ServerContext; - // remove - Stream->GetReliableOffset(&TestContext->ReliableOffsetSendSideServer); - Stream->GetReliableOffsetRecv(&TestContext->ReliableOffsetRecvSideServer); - std::cout << IHateC[Event->Type] << " Server Side Stream Send: " << TestContext->ReliableOffsetSendSideServer << ", "; - std::cout << " Server Side Stream Recv: " << TestContext->ReliableOffsetRecvSideServer << std::endl; - // remove. if (Event->Type == QUIC_STREAM_EVENT_RECEIVE) { TestContext->ReceivedBufferSize += Event->RECEIVE.TotalBufferLength; } @@ -3289,13 +3263,6 @@ QuicTestStreamReliableReset( TEST_QUIC_SUCCEEDED(Stream.Shutdown(0)); // Queues up a shutdown operation. // Should behave similar to QUIC_STREAM_SHUTDOWN_FLAG_GRACEFUL, with some restrictions. TEST_TRUE(Context.ClientStreamShutdownComplete.WaitTimeout(TestWaitTimeout)); - // Remove - std::cout << ">>>>>>>>>>> ReceivedBufferSize: " << Context.ReceivedBufferSize << std::endl; - // Remove. - // TEST_TRUE(Context.ReliableOffsetSendSideClient == RELIABLE_SIZE); - // TEST_TRUE(Context.ReliableOffsetRecvSideClient == 0); - // TEST_TRUE(Context.ReliableOffsetSendSideServer == 0); - // TEST_TRUE(Context.ReliableOffsetRecvSideServer == RELIABLE_SIZE); TEST_TRUE(Context.ReceivedBufferSize >= RELIABLE_SIZE); } @@ -3313,14 +3280,8 @@ QuicTestStreamReliableResetMultipleSends( uint64_t ReliableOffsetSendSideServer = 69420; uint64_t ReliableOffsetRecvSideServer = 69420; - static QUIC_STATUS ClientStreamCallback(_In_ MsQuicStream* Stream, _In_opt_ void* ClientContext, _Inout_ QUIC_STREAM_EVENT* Event) { + static QUIC_STATUS ClientStreamCallback(_In_ MsQuicStream*, _In_opt_ void* ClientContext, _Inout_ QUIC_STREAM_EVENT* Event) { auto TestContext = (StreamReliableReset*)ClientContext; - // remove - Stream->GetReliableOffset(&TestContext->ReliableOffsetSendSideClient); - Stream->GetReliableOffsetRecv(&TestContext->ReliableOffsetRecvSideClient); - std::cout << IHateC[Event->Type] << " Client Side Stream Send: " << TestContext->ReliableOffsetSendSideClient << ", "; - std::cout << " Client Side Stream Recv: " << TestContext->ReliableOffsetRecvSideClient << std::endl; - // remove. if (Event->Type == QUIC_STREAM_EVENT_SHUTDOWN_COMPLETE) { TestContext->ClientStreamShutdownComplete.Set(); } @@ -3329,12 +3290,6 @@ QuicTestStreamReliableResetMultipleSends( static QUIC_STATUS ServerStreamCallback(_In_ MsQuicStream* Stream, _In_opt_ void* ServerContext, _Inout_ QUIC_STREAM_EVENT* Event) { auto TestContext = (StreamReliableReset*)ServerContext; - // remove - Stream->GetReliableOffset(&TestContext->ReliableOffsetSendSideServer); - Stream->GetReliableOffsetRecv(&TestContext->ReliableOffsetRecvSideServer); - std::cout << IHateC[Event->Type] << " Server Side Stream Send: " << TestContext->ReliableOffsetSendSideServer << ", "; - std::cout << " Server Side Stream Recv: " << TestContext->ReliableOffsetRecvSideServer << std::endl; - // remove. if (Event->Type == QUIC_STREAM_EVENT_RECEIVE) { TestContext->ReceivedBufferSize += Event->RECEIVE.TotalBufferLength; } @@ -3397,12 +3352,5 @@ QuicTestStreamReliableResetMultipleSends( TEST_QUIC_SUCCEEDED(Stream.Shutdown(0)); // Queues up a shutdown operation. // Should behave similar to QUIC_STREAM_SHUTDOWN_FLAG_GRACEFUL, with some restrictions. TEST_TRUE(Context.ClientStreamShutdownComplete.WaitTimeout(TestWaitTimeout)); - // Remove - std::cout << ">>>>>>>>>>> ReceivedBufferSize: " << Context.ReceivedBufferSize << std::endl; - // Remove. - // TEST_TRUE(Context.ReliableOffsetSendSideClient == RELIABLE_SIZE); - // TEST_TRUE(Context.ReliableOffsetRecvSideClient == 0); - // TEST_TRUE(Context.ReliableOffsetSendSideServer == 0); - // TEST_TRUE(Context.ReliableOffsetRecvSideServer == RELIABLE_SIZE); TEST_TRUE(Context.ReceivedBufferSize >= RELIABLE_SIZE); } \ No newline at end of file From d5a7f4e2f94b59d16b798ce2182c99d5a8d067ec Mon Sep 17 00:00:00 2001 From: Jack He Date: Tue, 29 Aug 2023 11:02:18 -0700 Subject: [PATCH 049/123] generate dotnet and update logging --- src/core/frame.c | 22 ++++++- src/cs/lib/msquic_generated.cs | 3 + src/generated/linux/frame.c.clog.h | 52 ++++++++++++++++ src/generated/linux/frame.c.clog.h.lttng.h | 70 ++++++++++++++++++++++ src/manifest/clog.sidecar | 66 ++++++++++++++++++++ 5 files changed, 212 insertions(+), 1 deletion(-) diff --git a/src/core/frame.c b/src/core/frame.c index c30744d289..a718d4e2fa 100644 --- a/src/core/frame.c +++ b/src/core/frame.c @@ -1944,7 +1944,27 @@ QuicFrameLog( } case QUIC_FRAME_RELIABLE_RESET_STREAM: { - // TODO: Add log. + QUIC_RELIABLE_RESET_STREAM_EX Frame; + if (!QuicReliableResetFrameDecode(PacketLength, Packet, Offset, &Frame)) { + QuicTraceLogVerbose( + FrameLogReliableResetStreamInvalid, + "[%c][%cX][%llu] RELIABLE_RESET_STREAM [Invalid]", + PtkConnPre(Connection), + PktRxPre(Rx), + PacketNumber); + return FALSE; + } + + QuicTraceLogVerbose( + FrameLogReliableResetStream, + "[%c][%cX][%llu] RELIABLE_RESET_STREAM ID:%llu ErrorCode:0x%llX FinalSize:%llu ReliableSize:%llu", + PtkConnPre(Connection), + PktRxPre(Rx), + PacketNumber, + Frame.StreamID, + Frame.ErrorCode, + Frame.FinalSize, + Frame.ReliableSize); break; } diff --git a/src/cs/lib/msquic_generated.cs b/src/cs/lib/msquic_generated.cs index f4a64408c5..73c15e17f9 100644 --- a/src/cs/lib/msquic_generated.cs +++ b/src/cs/lib/msquic_generated.cs @@ -3203,6 +3203,9 @@ internal static unsafe partial class MsQuic [NativeTypeName("#define QUIC_PARAM_STREAM_STATISTICS 0X08000004")] internal const uint QUIC_PARAM_STREAM_STATISTICS = 0X08000004; + [NativeTypeName("#define QUIC_PARAM_STREAM_RELIABLE_OFFSET 0x08000005")] + internal const uint QUIC_PARAM_STREAM_RELIABLE_OFFSET = 0x08000005; + [NativeTypeName("#define QUIC_API_VERSION_2 2")] internal const uint QUIC_API_VERSION_2 = 2; } diff --git a/src/generated/linux/frame.c.clog.h b/src/generated/linux/frame.c.clog.h index 76e5a32b54..0fd24952b1 100644 --- a/src/generated/linux/frame.c.clog.h +++ b/src/generated/linux/frame.c.clog.h @@ -1225,6 +1225,58 @@ tracepoint(CLOG_FRAME_C, FrameLogImmediateAck , arg2, arg3, arg4);\ +/*---------------------------------------------------------- +// Decoder Ring for FrameLogReliableResetStreamInvalid +// [%c][%cX][%llu] RELIABLE_RESET_STREAM [Invalid] +// QuicTraceLogVerbose( + FrameLogReliableResetStreamInvalid, + "[%c][%cX][%llu] RELIABLE_RESET_STREAM [Invalid]", + PtkConnPre(Connection), + PktRxPre(Rx), + PacketNumber); +// arg2 = arg2 = PtkConnPre(Connection) = arg2 +// arg3 = arg3 = PktRxPre(Rx) = arg3 +// arg4 = arg4 = PacketNumber = arg4 +----------------------------------------------------------*/ +#ifndef _clog_5_ARGS_TRACE_FrameLogReliableResetStreamInvalid +#define _clog_5_ARGS_TRACE_FrameLogReliableResetStreamInvalid(uniqueId, encoded_arg_string, arg2, arg3, arg4)\ +tracepoint(CLOG_FRAME_C, FrameLogReliableResetStreamInvalid , arg2, arg3, arg4);\ + +#endif + + + + +/*---------------------------------------------------------- +// Decoder Ring for FrameLogReliableResetStream +// [%c][%cX][%llu] RELIABLE_RESET_STREAM ID:%llu ErrorCode:0x%llX FinalSize:%llu ReliableSize:%llu +// QuicTraceLogVerbose( + FrameLogReliableResetStream, + "[%c][%cX][%llu] RELIABLE_RESET_STREAM ID:%llu ErrorCode:0x%llX FinalSize:%llu ReliableSize:%llu", + PtkConnPre(Connection), + PktRxPre(Rx), + PacketNumber, + Frame.StreamID, + Frame.ErrorCode, + Frame.FinalSize, + Frame.ReliableSize); +// arg2 = arg2 = PtkConnPre(Connection) = arg2 +// arg3 = arg3 = PktRxPre(Rx) = arg3 +// arg4 = arg4 = PacketNumber = arg4 +// arg5 = arg5 = Frame.StreamID = arg5 +// arg6 = arg6 = Frame.ErrorCode = arg6 +// arg7 = arg7 = Frame.FinalSize = arg7 +// arg8 = arg8 = Frame.ReliableSize = arg8 +----------------------------------------------------------*/ +#ifndef _clog_9_ARGS_TRACE_FrameLogReliableResetStream +#define _clog_9_ARGS_TRACE_FrameLogReliableResetStream(uniqueId, encoded_arg_string, arg2, arg3, arg4, arg5, arg6, arg7, arg8)\ +tracepoint(CLOG_FRAME_C, FrameLogReliableResetStream , arg2, arg3, arg4, arg5, arg6, arg7, arg8);\ + +#endif + + + + /*---------------------------------------------------------- // Decoder Ring for ConnError // [conn][%p] ERROR, %s. diff --git a/src/generated/linux/frame.c.clog.h.lttng.h b/src/generated/linux/frame.c.clog.h.lttng.h index 2c51e44665..3511d49775 100644 --- a/src/generated/linux/frame.c.clog.h.lttng.h +++ b/src/generated/linux/frame.c.clog.h.lttng.h @@ -1551,6 +1551,76 @@ TRACEPOINT_EVENT(CLOG_FRAME_C, FrameLogImmediateAck, +/*---------------------------------------------------------- +// Decoder Ring for FrameLogReliableResetStreamInvalid +// [%c][%cX][%llu] RELIABLE_RESET_STREAM [Invalid] +// QuicTraceLogVerbose( + FrameLogReliableResetStreamInvalid, + "[%c][%cX][%llu] RELIABLE_RESET_STREAM [Invalid]", + PtkConnPre(Connection), + PktRxPre(Rx), + PacketNumber); +// arg2 = arg2 = PtkConnPre(Connection) = arg2 +// arg3 = arg3 = PktRxPre(Rx) = arg3 +// arg4 = arg4 = PacketNumber = arg4 +----------------------------------------------------------*/ +TRACEPOINT_EVENT(CLOG_FRAME_C, FrameLogReliableResetStreamInvalid, + TP_ARGS( + unsigned char, arg2, + unsigned char, arg3, + unsigned long long, arg4), + TP_FIELDS( + ctf_integer(unsigned char, arg2, arg2) + ctf_integer(unsigned char, arg3, arg3) + ctf_integer(uint64_t, arg4, arg4) + ) +) + + + +/*---------------------------------------------------------- +// Decoder Ring for FrameLogReliableResetStream +// [%c][%cX][%llu] RELIABLE_RESET_STREAM ID:%llu ErrorCode:0x%llX FinalSize:%llu ReliableSize:%llu +// QuicTraceLogVerbose( + FrameLogReliableResetStream, + "[%c][%cX][%llu] RELIABLE_RESET_STREAM ID:%llu ErrorCode:0x%llX FinalSize:%llu ReliableSize:%llu", + PtkConnPre(Connection), + PktRxPre(Rx), + PacketNumber, + Frame.StreamID, + Frame.ErrorCode, + Frame.FinalSize, + Frame.ReliableSize); +// arg2 = arg2 = PtkConnPre(Connection) = arg2 +// arg3 = arg3 = PktRxPre(Rx) = arg3 +// arg4 = arg4 = PacketNumber = arg4 +// arg5 = arg5 = Frame.StreamID = arg5 +// arg6 = arg6 = Frame.ErrorCode = arg6 +// arg7 = arg7 = Frame.FinalSize = arg7 +// arg8 = arg8 = Frame.ReliableSize = arg8 +----------------------------------------------------------*/ +TRACEPOINT_EVENT(CLOG_FRAME_C, FrameLogReliableResetStream, + TP_ARGS( + unsigned char, arg2, + unsigned char, arg3, + unsigned long long, arg4, + unsigned long long, arg5, + unsigned long long, arg6, + unsigned long long, arg7, + unsigned long long, arg8), + TP_FIELDS( + ctf_integer(unsigned char, arg2, arg2) + ctf_integer(unsigned char, arg3, arg3) + ctf_integer(uint64_t, arg4, arg4) + ctf_integer(uint64_t, arg5, arg5) + ctf_integer(uint64_t, arg6, arg6) + ctf_integer(uint64_t, arg7, arg7) + ctf_integer(uint64_t, arg8, arg8) + ) +) + + + /*---------------------------------------------------------- // Decoder Ring for ConnError // [conn][%p] ERROR, %s. diff --git a/src/manifest/clog.sidecar b/src/manifest/clog.sidecar index 47a650aec2..9cd78a09bc 100644 --- a/src/manifest/clog.sidecar +++ b/src/manifest/clog.sidecar @@ -5111,6 +5111,62 @@ ], "macroName": "QuicTraceLogVerbose" }, + "FrameLogReliableResetStream": { + "ModuleProperites": {}, + "TraceString": "[%c][%cX][%llu] RELIABLE_RESET_STREAM ID:%llu ErrorCode:0x%llX FinalSize:%llu ReliableSize:%llu", + "UniqueId": "FrameLogReliableResetStream", + "splitArgs": [ + { + "DefinationEncoding": "c", + "MacroVariableName": "arg2" + }, + { + "DefinationEncoding": "c", + "MacroVariableName": "arg3" + }, + { + "DefinationEncoding": "llu", + "MacroVariableName": "arg4" + }, + { + "DefinationEncoding": "llu", + "MacroVariableName": "arg5" + }, + { + "DefinationEncoding": "llX", + "MacroVariableName": "arg6" + }, + { + "DefinationEncoding": "llu", + "MacroVariableName": "arg7" + }, + { + "DefinationEncoding": "llu", + "MacroVariableName": "arg8" + } + ], + "macroName": "QuicTraceLogVerbose" + }, + "FrameLogReliableResetStreamInvalid": { + "ModuleProperites": {}, + "TraceString": "[%c][%cX][%llu] RELIABLE_RESET_STREAM [Invalid]", + "UniqueId": "FrameLogReliableResetStreamInvalid", + "splitArgs": [ + { + "DefinationEncoding": "c", + "MacroVariableName": "arg2" + }, + { + "DefinationEncoding": "c", + "MacroVariableName": "arg3" + }, + { + "DefinationEncoding": "llu", + "MacroVariableName": "arg4" + } + ], + "macroName": "QuicTraceLogVerbose" + }, "FrameLogResetStream": { "ModuleProperites": {}, "TraceString": "[%c][%cX][%llu] RESET_STREAM ID:%llu ErrorCode:0x%llX FinalSize:%llu", @@ -14333,6 +14389,16 @@ "TraceID": "FrameLogPing", "EncodingString": "[%c][%cX][%llu] PING" }, + { + "UniquenessHash": "114e293d-3c55-bda4-2768-2c68d7b2e75e", + "TraceID": "FrameLogReliableResetStream", + "EncodingString": "[%c][%cX][%llu] RELIABLE_RESET_STREAM ID:%llu ErrorCode:0x%llX FinalSize:%llu ReliableSize:%llu" + }, + { + "UniquenessHash": "45b5711e-3b1c-297d-8352-5cc3ceb82dfd", + "TraceID": "FrameLogReliableResetStreamInvalid", + "EncodingString": "[%c][%cX][%llu] RELIABLE_RESET_STREAM [Invalid]" + }, { "UniquenessHash": "47de738b-e1df-210a-5eff-181b82072815", "TraceID": "FrameLogResetStream", From cf2bb520d0de5b1cf732f55bcc228e9c13fd7ec7 Mon Sep 17 00:00:00 2001 From: Jack He Date: Tue, 29 Aug 2023 17:43:34 -0700 Subject: [PATCH 050/123] get rid of 69420 --- src/test/lib/DataTest.cpp | 10 +--------- 1 file changed, 1 insertion(+), 9 deletions(-) diff --git a/src/test/lib/DataTest.cpp b/src/test/lib/DataTest.cpp index b93deb1982..e2725a1b7d 100644 --- a/src/test/lib/DataTest.cpp +++ b/src/test/lib/DataTest.cpp @@ -3188,10 +3188,6 @@ QuicTestStreamReliableReset( CxPlatEvent ClientStreamShutdownComplete; uint64_t ReceivedBufferSize; - uint64_t ReliableOffsetSendSideClient = 69420; - uint64_t ReliableOffsetRecvSideClient = 69420; - uint64_t ReliableOffsetSendSideServer = 69420; - uint64_t ReliableOffsetRecvSideServer = 69420; static QUIC_STATUS ClientStreamCallback(_In_ MsQuicStream*, _In_opt_ void* ClientContext, _Inout_ QUIC_STREAM_EVENT* Event) { auto TestContext = (StreamReliableReset*)ClientContext; @@ -3275,10 +3271,6 @@ QuicTestStreamReliableResetMultipleSends( CxPlatEvent ClientStreamShutdownComplete; uint64_t ReceivedBufferSize; - uint64_t ReliableOffsetSendSideClient = 69420; - uint64_t ReliableOffsetRecvSideClient = 69420; - uint64_t ReliableOffsetSendSideServer = 69420; - uint64_t ReliableOffsetRecvSideServer = 69420; static QUIC_STATUS ClientStreamCallback(_In_ MsQuicStream*, _In_opt_ void* ClientContext, _Inout_ QUIC_STREAM_EVENT* Event) { auto TestContext = (StreamReliableReset*)ClientContext; @@ -3353,4 +3345,4 @@ QuicTestStreamReliableResetMultipleSends( // Should behave similar to QUIC_STREAM_SHUTDOWN_FLAG_GRACEFUL, with some restrictions. TEST_TRUE(Context.ClientStreamShutdownComplete.WaitTimeout(TestWaitTimeout)); TEST_TRUE(Context.ReceivedBufferSize >= RELIABLE_SIZE); -} \ No newline at end of file +} From 8a52a3ba5e000919df897b7c9b7b3f084899fc2c Mon Sep 17 00:00:00 2001 From: Jack He Date: Thu, 31 Aug 2023 14:58:49 -0700 Subject: [PATCH 051/123] add enabling reliablereset to fuzzing --- src/tools/spin/spinquic.cpp | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/tools/spin/spinquic.cpp b/src/tools/spin/spinquic.cpp index cfc426082c..f26e5cc27b 100644 --- a/src/tools/spin/spinquic.cpp +++ b/src/tools/spin/spinquic.cpp @@ -775,7 +775,7 @@ void SpinQuicSetRandomStreamParam(HQUIC Stream, uint16_t ThreadID) { SetParamHelper Helper; - switch (0x08000000 | (GetRandom(5))) { + switch (0x08000000 | (GetRandom(6))) { case QUIC_PARAM_STREAM_ID: // QUIC_UINT62 break; // Get Only case QUIC_PARAM_STREAM_0RTT_LENGTH: // QUIC_ADDR @@ -787,6 +787,8 @@ void SpinQuicSetRandomStreamParam(HQUIC Stream, uint16_t ThreadID) break; case QUIC_PARAM_STREAM_STATISTICS: break; // Get Only + case QUIC_PARAM_STREAM_RELIABLE_OFFSET: + Helper.SetUint64(QUIC_PARAM_STREAM_RELIABLE_OFFSET, (uint64_t)GetRandom(UINT64_MAX)); default: break; } From a059432c94b83fcfc9129da3c5caf4d5f55ca8f7 Mon Sep 17 00:00:00 2001 From: Jack He Date: Fri, 1 Sep 2023 17:07:42 -0700 Subject: [PATCH 052/123] add additional param testing --- src/test/lib/ApiTest.cpp | 71 ++++++++++++++++++++++++++++++--------- src/test/lib/DataTest.cpp | 8 +++++ 2 files changed, 64 insertions(+), 15 deletions(-) diff --git a/src/test/lib/ApiTest.cpp b/src/test/lib/ApiTest.cpp index 5fddd7f06e..f5ec063753 100644 --- a/src/test/lib/ApiTest.cpp +++ b/src/test/lib/ApiTest.cpp @@ -4311,13 +4311,13 @@ void QuicTest_QUIC_PARAM_CONN_ORIG_DEST_CID(MsQuicRegistration& Registration, Ms // uint32_t SizeOfBuffer = 8; uint8_t Buffer[8] = {0}; - uint8_t ZeroBuffer[8] = {0}; + uint8_t ZeroBuffer[8] = {0}; TestScopeLogger LogScope1("GetParam test success case"); TEST_QUIC_STATUS( - QUIC_STATUS_SUCCESS, + QUIC_STATUS_SUCCESS, Connection.GetParam( QUIC_PARAM_CONN_ORIG_DEST_CID, - &SizeOfBuffer, + &SizeOfBuffer, Buffer ) ) @@ -4335,10 +4335,10 @@ void QuicTest_QUIC_PARAM_CONN_ORIG_DEST_CID(MsQuicRegistration& Registration, Ms uint32_t SizeOfBuffer = 8; TestScopeLogger LogScope1("GetParam null buffer check"); TEST_QUIC_STATUS( - QUIC_STATUS_INVALID_PARAMETER, + QUIC_STATUS_INVALID_PARAMETER, Connection.GetParam( QUIC_PARAM_CONN_ORIG_DEST_CID, - &SizeOfBuffer, + &SizeOfBuffer, nullptr ) ) @@ -4356,10 +4356,10 @@ void QuicTest_QUIC_PARAM_CONN_ORIG_DEST_CID(MsQuicRegistration& Registration, Ms TestScopeLogger LogScope1("GetParam buffer too small check"); uint8_t Buffer[1]; TEST_QUIC_STATUS( - QUIC_STATUS_BUFFER_TOO_SMALL, + QUIC_STATUS_BUFFER_TOO_SMALL, Connection.GetParam( QUIC_PARAM_CONN_ORIG_DEST_CID, - &SizeOfBuffer, + &SizeOfBuffer, Buffer ) ) @@ -4375,18 +4375,18 @@ void QuicTest_QUIC_PARAM_CONN_ORIG_DEST_CID(MsQuicRegistration& Registration, Ms 4433)); uint32_t SizeOfBuffer = 100; uint8_t Buffer[100] = {0}; - uint8_t ZeroBuffer[100] = {0}; + uint8_t ZeroBuffer[100] = {0}; TestScopeLogger LogScope1("GetParam size of buffer bigger than needed"); TEST_QUIC_STATUS( - QUIC_STATUS_SUCCESS, + QUIC_STATUS_SUCCESS, Connection.GetParam( QUIC_PARAM_CONN_ORIG_DEST_CID, - &SizeOfBuffer, + &SizeOfBuffer, Buffer ) ) TEST_NOT_EQUAL(memcmp(Buffer, ZeroBuffer, sizeof(Buffer)), 0); - // + // // There is no way the CID written should be 100 bytes according to the RFC. // TEST_TRUE(SizeOfBuffer < 100); @@ -4403,19 +4403,19 @@ void QuicTest_QUIC_PARAM_CONN_ORIG_DEST_CID(MsQuicRegistration& Registration, Ms uint32_t SizeOfBuffer = 0; TestScopeLogger LogScope1("GetParam check OrigDestCID size with nullptr"); TEST_QUIC_STATUS( - QUIC_STATUS_BUFFER_TOO_SMALL, + QUIC_STATUS_BUFFER_TOO_SMALL, Connection.GetParam( QUIC_PARAM_CONN_ORIG_DEST_CID, - &SizeOfBuffer, + &SizeOfBuffer, nullptr ) ) TEST_TRUE(SizeOfBuffer >= 8); TEST_QUIC_STATUS( - QUIC_STATUS_INVALID_PARAMETER, + QUIC_STATUS_INVALID_PARAMETER, Connection.GetParam( QUIC_PARAM_CONN_ORIG_DEST_CID, - &SizeOfBuffer, + &SizeOfBuffer, nullptr ) ) @@ -4971,6 +4971,47 @@ void QuicTestStreamParam() TEST_EQUAL(Length, sizeof(QUIC_STREAM_STATISTICS)); } } + + + // + // QUIC_PARAM_STREAM_RELIABLE_OFFSET + // + { + TestScopeLogger LogScope0("QUIC_PARAM_STREAM_RELIABLE_OFFSET"); + MsQuicStream Stream(Connection, QUIC_STREAM_OPEN_FLAG_NONE); + uint32_t ReliableSize32 = 1; + uint64_t ReliableSize = 1; + + // + // SetParam Test Invalid States. + // + { + TestScopeLogger LogScope1("SetParam is not allowed"); + TEST_QUIC_STATUS( + QUIC_STATUS_INVALID_PARAMETER, + MsQuic->SetParam( + Stream.Handle, + QUIC_PARAM_STREAM_RELIABLE_OFFSET, + sizeof(ReliableSize), + NULL)); + + TEST_QUIC_STATUS( + QUIC_STATUS_INVALID_PARAMETER, + MsQuic->SetParam( + Stream.Handle, + QUIC_PARAM_STREAM_RELIABLE_OFFSET, + sizeof(ReliableSize32), + &ReliableSize32)); + + TEST_QUIC_STATUS( + QUIC_STATUS_INVALID_STATE, + MsQuic->SetParam( + Stream.Handle, + QUIC_PARAM_STREAM_RELIABLE_OFFSET, + sizeof(ReliableSize), + &ReliableSize)); + } + } } void diff --git a/src/test/lib/DataTest.cpp b/src/test/lib/DataTest.cpp index e2725a1b7d..082bf2cf65 100644 --- a/src/test/lib/DataTest.cpp +++ b/src/test/lib/DataTest.cpp @@ -3255,11 +3255,19 @@ QuicTestStreamReliableReset( TEST_QUIC_SUCCEEDED(Stream.GetInitStatus()); TEST_QUIC_SUCCEEDED(Stream.Start()); TEST_QUIC_SUCCEEDED(Stream.Send(&SendBuffer, 1, QUIC_SEND_FLAG_DELAY_SEND, &Context)); + TEST_QUIC_STATUS( + QUIC_STATUS_INVALID_STATE, + Stream.SetReliableOffset(UINT64_MAX)); TEST_QUIC_SUCCEEDED(Stream.SetReliableOffset(RELIABLE_SIZE)); TEST_QUIC_SUCCEEDED(Stream.Shutdown(0)); // Queues up a shutdown operation. // Should behave similar to QUIC_STREAM_SHUTDOWN_FLAG_GRACEFUL, with some restrictions. TEST_TRUE(Context.ClientStreamShutdownComplete.WaitTimeout(TestWaitTimeout)); TEST_TRUE(Context.ReceivedBufferSize >= RELIABLE_SIZE); + + // We shouldn't be able to change ReliableSize now that the stream has already been reset. + TEST_QUIC_STATUS( + QUIC_STATUS_INVALID_STATE, + Stream.SetReliableOffset(1)); } From fb4c56bc407a065a1015c9050e64c3bb96801bfe Mon Sep 17 00:00:00 2001 From: Jack He Date: Fri, 1 Sep 2023 17:08:05 -0700 Subject: [PATCH 053/123] no need to indicate irrelevant event --- src/core/stream_recv.c | 20 ++++---------------- 1 file changed, 4 insertions(+), 16 deletions(-) diff --git a/src/core/stream_recv.c b/src/core/stream_recv.c index c2c9960aa3..ded1266d13 100644 --- a/src/core/stream_recv.c +++ b/src/core/stream_recv.c @@ -208,14 +208,8 @@ QuicStreamProcessReliableResetFrame( QuicTraceLogStreamVerbose( StreamProcessReliableReset, Stream, - "Shutting down stream from Process Reliable Reset Frame. Recv Side."); - QUIC_STREAM_EVENT Event; - Event.Type = QUIC_STREAM_EVENT_PEER_SEND_SHUTDOWN; - QuicTraceLogStreamVerbose( - IndicatePeerSendShutdown, - Stream, - "Indicating QUIC_STREAM_EVENT_PEER_SEND_SHUTDOWN"); - (void)QuicStreamIndicateEvent(Stream, &Event); + "Shutting down stream from Process Reliable Reset Frame. Recv Side. BaseOffset: %llu, RecvMaxLength: %llu", + Stream->RecvBuffer.BaseOffset, Stream->RecvMaxLength); QuicStreamRecvShutdown(Stream, TRUE, QUIC_ERROR_NO_ERROR); } @@ -1171,14 +1165,8 @@ QuicStreamReceiveComplete( QuicTraceLogStreamVerbose( StreamReliableResetReceiveComplete, Stream, - "Shutting down stream from ReceiveComplete Recv Side."); - QUIC_STREAM_EVENT Event; - Event.Type = QUIC_STREAM_EVENT_PEER_SEND_SHUTDOWN; - QuicTraceLogStreamVerbose( - IndicatePeerSendShutdown, - Stream, - "Indicating QUIC_STREAM_EVENT_PEER_SEND_SHUTDOWN"); - (void)QuicStreamIndicateEvent(Stream, &Event); + "Shutting down stream from ReceiveComplete Recv Side. BaseOffset: %llu, RecvMaxLength: %llu", + Stream->RecvBuffer.BaseOffset, Stream->RecvMaxLength); QuicStreamRecvShutdown(Stream, TRUE, QUIC_ERROR_NO_ERROR); } From ec387f9ab83979e8f72f637f6acbb5b205b62032 Mon Sep 17 00:00:00 2001 From: Jack He Date: Fri, 1 Sep 2023 17:13:41 -0700 Subject: [PATCH 054/123] change error code and update flags --- src/core/stream_send.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/core/stream_send.c b/src/core/stream_send.c index ab6085dda1..5e056f7a8f 100644 --- a/src/core/stream_send.c +++ b/src/core/stream_send.c @@ -1536,7 +1536,8 @@ QuicStreamOnAck( Stream, "Shutting down stream [reliable] from OnStreamAck. Send side."); QuicStreamCleanupReliableReset(Stream); - QuicStreamSendShutdown(Stream, FALSE, TRUE, FALSE, QUIC_ERROR_NO_ERROR); + Stream->Flags.LocalCloseReset = TRUE; + QuicStreamSendShutdown(Stream, FALSE, TRUE, FALSE, 0x21); } if (!QuicStreamHasPendingStreamData(Stream)) { @@ -1618,7 +1619,8 @@ QuicStreamOnResetReliableAck( Stream, "Shutting down stream [reliably] from OnResetReliableAck. Send side."); QuicStreamCleanupReliableReset(Stream); - QuicStreamSendShutdown(Stream, FALSE, TRUE, FALSE, QUIC_ERROR_NO_ERROR); + Stream->Flags.LocalCloseReset = TRUE; + QuicStreamSendShutdown(Stream, FALSE, TRUE, FALSE, 0x21); } } From 9dbfc0b101a6df570020d304f1c52fa097901a05 Mon Sep 17 00:00:00 2001 From: Jack He Date: Fri, 1 Sep 2023 18:20:41 -0700 Subject: [PATCH 055/123] update sidecar --- src/core/stream_recv.c | 4 +- src/generated/linux/stream_recv.c.clog.h | 70 +++++++++-------- .../linux/stream_recv.c.clog.h.lttng.h | 76 +++++++++++-------- src/manifest/clog.sidecar | 50 ++++++++++++ 4 files changed, 135 insertions(+), 65 deletions(-) diff --git a/src/core/stream_recv.c b/src/core/stream_recv.c index ded1266d13..7b61fe637e 100644 --- a/src/core/stream_recv.c +++ b/src/core/stream_recv.c @@ -206,7 +206,7 @@ QuicStreamProcessReliableResetFrame( Stream->Flags.LocalCloseAcked = TRUE; Stream->Flags.RemoteCloseAcked = TRUE; QuicTraceLogStreamVerbose( - StreamProcessReliableReset, + ProcessReliableReset, Stream, "Shutting down stream from Process Reliable Reset Frame. Recv Side. BaseOffset: %llu, RecvMaxLength: %llu", Stream->RecvBuffer.BaseOffset, Stream->RecvMaxLength); @@ -1163,7 +1163,7 @@ QuicStreamReceiveComplete( Stream->Flags.LocalCloseAcked = TRUE; Stream->Flags.RemoteCloseAcked = TRUE; QuicTraceLogStreamVerbose( - StreamReliableResetReceiveComplete, + ReliableResetReceiveComplete, Stream, "Shutting down stream from ReceiveComplete Recv Side. BaseOffset: %llu, RecvMaxLength: %llu", Stream->RecvBuffer.BaseOffset, Stream->RecvMaxLength); diff --git a/src/generated/linux/stream_recv.c.clog.h b/src/generated/linux/stream_recv.c.clog.h index 412fc7cd87..38e933254e 100644 --- a/src/generated/linux/stream_recv.c.clog.h +++ b/src/generated/linux/stream_recv.c.clog.h @@ -216,35 +216,20 @@ tracepoint(CLOG_STREAM_RECV_C, QueueRecvFlush , arg1);\ /*---------------------------------------------------------- -// Decoder Ring for StreamProcessReliableReset -// [strm][%p] Shutting down stream from Process Reliable Reset Frame. Recv Side. +// Decoder Ring for ProcessReliableReset +// [strm][%p] Shutting down stream from Process Reliable Reset Frame. Recv Side. BaseOffset: %llu, RecvMaxLength: %llu // QuicTraceLogStreamVerbose( - StreamProcessReliableReset, + ProcessReliableReset, Stream, - "Shutting down stream from Process Reliable Reset Frame. Recv Side."); + "Shutting down stream from Process Reliable Reset Frame. Recv Side. BaseOffset: %llu, RecvMaxLength: %llu", + Stream->RecvBuffer.BaseOffset, Stream->RecvMaxLength); // arg1 = arg1 = Stream = arg1 +// arg3 = arg3 = Stream->RecvBuffer.BaseOffset = arg3 +// arg4 = arg4 = Stream->RecvMaxLength = arg4 ----------------------------------------------------------*/ -#ifndef _clog_3_ARGS_TRACE_StreamProcessReliableReset -#define _clog_3_ARGS_TRACE_StreamProcessReliableReset(uniqueId, arg1, encoded_arg_string)\ -tracepoint(CLOG_STREAM_RECV_C, StreamProcessReliableReset , arg1);\ - -#endif - - - - -/*---------------------------------------------------------- -// Decoder Ring for IndicatePeerSendShutdown -// [strm][%p] Indicating QUIC_STREAM_EVENT_PEER_SEND_SHUTDOWN -// QuicTraceLogStreamVerbose( - IndicatePeerSendShutdown, - Stream, - "Indicating QUIC_STREAM_EVENT_PEER_SEND_SHUTDOWN"); -// arg1 = arg1 = Stream = arg1 -----------------------------------------------------------*/ -#ifndef _clog_3_ARGS_TRACE_IndicatePeerSendShutdown -#define _clog_3_ARGS_TRACE_IndicatePeerSendShutdown(uniqueId, arg1, encoded_arg_string)\ -tracepoint(CLOG_STREAM_RECV_C, IndicatePeerSendShutdown , arg1);\ +#ifndef _clog_5_ARGS_TRACE_ProcessReliableReset +#define _clog_5_ARGS_TRACE_ProcessReliableReset(uniqueId, arg1, encoded_arg_string, arg3, arg4)\ +tracepoint(CLOG_STREAM_RECV_C, ProcessReliableReset , arg1, arg3, arg4);\ #endif @@ -469,6 +454,24 @@ tracepoint(CLOG_STREAM_RECV_C, IgnoreRecvFlush , arg1);\ +/*---------------------------------------------------------- +// Decoder Ring for IndicatePeerSendShutdown +// [strm][%p] Indicating QUIC_STREAM_EVENT_PEER_SEND_SHUTDOWN +// QuicTraceLogStreamVerbose( + IndicatePeerSendShutdown, + Stream, + "Indicating QUIC_STREAM_EVENT_PEER_SEND_SHUTDOWN"); +// arg1 = arg1 = Stream = arg1 +----------------------------------------------------------*/ +#ifndef _clog_3_ARGS_TRACE_IndicatePeerSendShutdown +#define _clog_3_ARGS_TRACE_IndicatePeerSendShutdown(uniqueId, arg1, encoded_arg_string)\ +tracepoint(CLOG_STREAM_RECV_C, IndicatePeerSendShutdown , arg1);\ + +#endif + + + + /*---------------------------------------------------------- // Decoder Ring for StreamReliableResetRecvGraceful // [strm][%p] Shutting down stream [gracefully] Recv Side. @@ -488,17 +491,20 @@ tracepoint(CLOG_STREAM_RECV_C, StreamReliableResetRecvGraceful , arg1);\ /*---------------------------------------------------------- -// Decoder Ring for StreamReliableResetReceiveComplete -// [strm][%p] Shutting down stream from ReceiveComplete Recv Side. +// Decoder Ring for ReliableResetReceiveComplete +// [strm][%p] Shutting down stream from ReceiveComplete Recv Side. BaseOffset: %llu, RecvMaxLength: %llu // QuicTraceLogStreamVerbose( - StreamReliableResetReceiveComplete, + ReliableResetReceiveComplete, Stream, - "Shutting down stream from ReceiveComplete Recv Side."); + "Shutting down stream from ReceiveComplete Recv Side. BaseOffset: %llu, RecvMaxLength: %llu", + Stream->RecvBuffer.BaseOffset, Stream->RecvMaxLength); // arg1 = arg1 = Stream = arg1 +// arg3 = arg3 = Stream->RecvBuffer.BaseOffset = arg3 +// arg4 = arg4 = Stream->RecvMaxLength = arg4 ----------------------------------------------------------*/ -#ifndef _clog_3_ARGS_TRACE_StreamReliableResetReceiveComplete -#define _clog_3_ARGS_TRACE_StreamReliableResetReceiveComplete(uniqueId, arg1, encoded_arg_string)\ -tracepoint(CLOG_STREAM_RECV_C, StreamReliableResetReceiveComplete , arg1);\ +#ifndef _clog_5_ARGS_TRACE_ReliableResetReceiveComplete +#define _clog_5_ARGS_TRACE_ReliableResetReceiveComplete(uniqueId, arg1, encoded_arg_string, arg3, arg4)\ +tracepoint(CLOG_STREAM_RECV_C, ReliableResetReceiveComplete , arg1, arg3, arg4);\ #endif diff --git a/src/generated/linux/stream_recv.c.clog.h.lttng.h b/src/generated/linux/stream_recv.c.clog.h.lttng.h index 7e70bff3dc..f4f81f0953 100644 --- a/src/generated/linux/stream_recv.c.clog.h.lttng.h +++ b/src/generated/linux/stream_recv.c.clog.h.lttng.h @@ -196,38 +196,26 @@ TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, QueueRecvFlush, /*---------------------------------------------------------- -// Decoder Ring for StreamProcessReliableReset -// [strm][%p] Shutting down stream from Process Reliable Reset Frame. Recv Side. +// Decoder Ring for ProcessReliableReset +// [strm][%p] Shutting down stream from Process Reliable Reset Frame. Recv Side. BaseOffset: %llu, RecvMaxLength: %llu // QuicTraceLogStreamVerbose( - StreamProcessReliableReset, + ProcessReliableReset, Stream, - "Shutting down stream from Process Reliable Reset Frame. Recv Side."); + "Shutting down stream from Process Reliable Reset Frame. Recv Side. BaseOffset: %llu, RecvMaxLength: %llu", + Stream->RecvBuffer.BaseOffset, Stream->RecvMaxLength); // arg1 = arg1 = Stream = arg1 +// arg3 = arg3 = Stream->RecvBuffer.BaseOffset = arg3 +// arg4 = arg4 = Stream->RecvMaxLength = arg4 ----------------------------------------------------------*/ -TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, StreamProcessReliableReset, +TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, ProcessReliableReset, TP_ARGS( - const void *, arg1), - TP_FIELDS( - ctf_integer_hex(uint64_t, arg1, arg1) - ) -) - - - -/*---------------------------------------------------------- -// Decoder Ring for IndicatePeerSendShutdown -// [strm][%p] Indicating QUIC_STREAM_EVENT_PEER_SEND_SHUTDOWN -// QuicTraceLogStreamVerbose( - IndicatePeerSendShutdown, - Stream, - "Indicating QUIC_STREAM_EVENT_PEER_SEND_SHUTDOWN"); -// arg1 = arg1 = Stream = arg1 -----------------------------------------------------------*/ -TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, IndicatePeerSendShutdown, - TP_ARGS( - const void *, arg1), + const void *, arg1, + unsigned long long, arg3, + unsigned long long, arg4), TP_FIELDS( ctf_integer_hex(uint64_t, arg1, arg1) + ctf_integer(uint64_t, arg3, arg3) + ctf_integer(uint64_t, arg4, arg4) ) ) @@ -482,6 +470,25 @@ TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, IgnoreRecvFlush, +/*---------------------------------------------------------- +// Decoder Ring for IndicatePeerSendShutdown +// [strm][%p] Indicating QUIC_STREAM_EVENT_PEER_SEND_SHUTDOWN +// QuicTraceLogStreamVerbose( + IndicatePeerSendShutdown, + Stream, + "Indicating QUIC_STREAM_EVENT_PEER_SEND_SHUTDOWN"); +// arg1 = arg1 = Stream = arg1 +----------------------------------------------------------*/ +TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, IndicatePeerSendShutdown, + TP_ARGS( + const void *, arg1), + TP_FIELDS( + ctf_integer_hex(uint64_t, arg1, arg1) + ) +) + + + /*---------------------------------------------------------- // Decoder Ring for StreamReliableResetRecvGraceful // [strm][%p] Shutting down stream [gracefully] Recv Side. @@ -502,19 +509,26 @@ TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, StreamReliableResetRecvGraceful, /*---------------------------------------------------------- -// Decoder Ring for StreamReliableResetReceiveComplete -// [strm][%p] Shutting down stream from ReceiveComplete Recv Side. +// Decoder Ring for ReliableResetReceiveComplete +// [strm][%p] Shutting down stream from ReceiveComplete Recv Side. BaseOffset: %llu, RecvMaxLength: %llu // QuicTraceLogStreamVerbose( - StreamReliableResetReceiveComplete, + ReliableResetReceiveComplete, Stream, - "Shutting down stream from ReceiveComplete Recv Side."); + "Shutting down stream from ReceiveComplete Recv Side. BaseOffset: %llu, RecvMaxLength: %llu", + Stream->RecvBuffer.BaseOffset, Stream->RecvMaxLength); // arg1 = arg1 = Stream = arg1 +// arg3 = arg3 = Stream->RecvBuffer.BaseOffset = arg3 +// arg4 = arg4 = Stream->RecvMaxLength = arg4 ----------------------------------------------------------*/ -TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, StreamReliableResetReceiveComplete, +TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, ReliableResetReceiveComplete, TP_ARGS( - const void *, arg1), + const void *, arg1, + unsigned long long, arg3, + unsigned long long, arg4), TP_FIELDS( ctf_integer_hex(uint64_t, arg1, arg1) + ctf_integer(uint64_t, arg3, arg3) + ctf_integer(uint64_t, arg4, arg4) ) ) diff --git a/src/manifest/clog.sidecar b/src/manifest/clog.sidecar index 9cd78a09bc..67e1a2e9d5 100644 --- a/src/manifest/clog.sidecar +++ b/src/manifest/clog.sidecar @@ -8838,6 +8838,26 @@ ], "macroName": "QuicTraceLogInfo" }, + "ProcessReliableReset": { + "ModuleProperites": {}, + "TraceString": "[strm][%p] Shutting down stream from Process Reliable Reset Frame. Recv Side. BaseOffset: %llu, RecvMaxLength: %llu", + "UniqueId": "ProcessReliableReset", + "splitArgs": [ + { + "DefinationEncoding": "p", + "MacroVariableName": "arg1" + }, + { + "DefinationEncoding": "llu", + "MacroVariableName": "arg3" + }, + { + "DefinationEncoding": "llu", + "MacroVariableName": "arg4" + } + ], + "macroName": "QuicTraceLogStreamVerbose" + }, "QueueDatagrams": { "ModuleProperites": {}, "TraceString": "[conn][%p] Queuing %u UDP datagrams", @@ -9258,6 +9278,26 @@ ], "macroName": "QuicTraceLogStreamVerbose" }, + "ReliableResetReceiveComplete": { + "ModuleProperites": {}, + "TraceString": "[strm][%p] Shutting down stream from ReceiveComplete Recv Side. BaseOffset: %llu, RecvMaxLength: %llu", + "UniqueId": "ReliableResetReceiveComplete", + "splitArgs": [ + { + "DefinationEncoding": "p", + "MacroVariableName": "arg1" + }, + { + "DefinationEncoding": "llu", + "MacroVariableName": "arg3" + }, + { + "DefinationEncoding": "llu", + "MacroVariableName": "arg4" + } + ], + "macroName": "QuicTraceLogStreamVerbose" + }, "ReliableSendOffsetSet": { "ModuleProperites": {}, "TraceString": "[strm][%p] Reliable send offset set to %llu", @@ -15574,6 +15614,11 @@ "TraceID": "ProcessorInfoV2", "EncodingString": "[ dll] Proc[%u] Group[%hu] Index[%u] Active=%hhu" }, + { + "UniquenessHash": "518b5117-c14d-ee4e-47c5-8264735c8638", + "TraceID": "ProcessReliableReset", + "EncodingString": "[strm][%p] Shutting down stream from Process Reliable Reset Frame. Recv Side. BaseOffset: %llu, RecvMaxLength: %llu" + }, { "UniquenessHash": "18ef147d-5376-d7f2-f624-3b27af96dd05", "TraceID": "QueueDatagrams", @@ -15709,6 +15754,11 @@ "TraceID": "ReliableResetOnStreamAck", "EncodingString": "[strm][%p] Shutting down stream [reliable] from OnStreamAck. Send side." }, + { + "UniquenessHash": "6ea13123-905c-3439-77cb-45bbd050b9bc", + "TraceID": "ReliableResetReceiveComplete", + "EncodingString": "[strm][%p] Shutting down stream from ReceiveComplete Recv Side. BaseOffset: %llu, RecvMaxLength: %llu" + }, { "UniquenessHash": "84836f4f-d47f-cc00-7cb2-530ac90c70d3", "TraceID": "ReliableSendOffsetSet", From 5d4e69999bd97fd1df26cec713ba6884df0b1521 Mon Sep 17 00:00:00 2001 From: Jack He Date: Fri, 1 Sep 2023 18:21:38 -0700 Subject: [PATCH 056/123] update datatest --- src/test/lib/DataTest.cpp | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/src/test/lib/DataTest.cpp b/src/test/lib/DataTest.cpp index 082bf2cf65..002ce86b2b 100644 --- a/src/test/lib/DataTest.cpp +++ b/src/test/lib/DataTest.cpp @@ -3184,9 +3184,10 @@ QuicTestStreamReliableReset( #define BUFFER_SIZE 10000 #define RELIABLE_SIZE 5000 - struct StreamReliableReset { + struct StreamReliableReset { CxPlatEvent ClientStreamShutdownComplete; + CxPlatEvent ServerStreamShutdownComplete; uint64_t ReceivedBufferSize; static QUIC_STATUS ClientStreamCallback(_In_ MsQuicStream*, _In_opt_ void* ClientContext, _Inout_ QUIC_STREAM_EVENT* Event) { @@ -3205,6 +3206,9 @@ QuicTestStreamReliableReset( if (Event->Type == QUIC_STREAM_EVENT_PEER_SEND_SHUTDOWN) { Stream->Shutdown(QUIC_STREAM_SHUTDOWN_FLAG_ABORT_SEND); } + if (Event->Type == QUIC_STREAM_EVENT_SHUTDOWN_COMPLETE) { + TestContext->ServerStreamShutdownComplete.Set(); + } return QUIC_STATUS_SUCCESS; } @@ -3262,6 +3266,7 @@ QuicTestStreamReliableReset( TEST_QUIC_SUCCEEDED(Stream.Shutdown(0)); // Queues up a shutdown operation. // Should behave similar to QUIC_STREAM_SHUTDOWN_FLAG_GRACEFUL, with some restrictions. TEST_TRUE(Context.ClientStreamShutdownComplete.WaitTimeout(TestWaitTimeout)); + TEST_TRUE(Context.ServerStreamShutdownComplete.WaitTimeout(TestWaitTimeout)); TEST_TRUE(Context.ReceivedBufferSize >= RELIABLE_SIZE); // We shouldn't be able to change ReliableSize now that the stream has already been reset. @@ -3278,6 +3283,7 @@ QuicTestStreamReliableResetMultipleSends( struct StreamReliableReset { CxPlatEvent ClientStreamShutdownComplete; + CxPlatEvent ServerStreamShutdownComplete; uint64_t ReceivedBufferSize; static QUIC_STATUS ClientStreamCallback(_In_ MsQuicStream*, _In_opt_ void* ClientContext, _Inout_ QUIC_STREAM_EVENT* Event) { @@ -3296,6 +3302,9 @@ QuicTestStreamReliableResetMultipleSends( if (Event->Type == QUIC_STREAM_EVENT_PEER_SEND_SHUTDOWN) { Stream->Shutdown(QUIC_STREAM_SHUTDOWN_FLAG_ABORT_SEND); } + if (Event->Type == QUIC_STREAM_EVENT_SHUTDOWN_COMPLETE) { + TestContext->ServerStreamShutdownComplete.Set(); + } return QUIC_STATUS_SUCCESS; } @@ -3352,5 +3361,6 @@ QuicTestStreamReliableResetMultipleSends( TEST_QUIC_SUCCEEDED(Stream.Shutdown(0)); // Queues up a shutdown operation. // Should behave similar to QUIC_STREAM_SHUTDOWN_FLAG_GRACEFUL, with some restrictions. TEST_TRUE(Context.ClientStreamShutdownComplete.WaitTimeout(TestWaitTimeout)); + TEST_TRUE(Context.ServerStreamShutdownComplete.WaitTimeout(TestWaitTimeout)); TEST_TRUE(Context.ReceivedBufferSize >= RELIABLE_SIZE); } From d1e9df48ecb3160750e577de9041c6ce300fda9f Mon Sep 17 00:00:00 2001 From: Jack He Date: Mon, 4 Sep 2023 18:09:39 -0700 Subject: [PATCH 057/123] use ACK instead of local reset --- src/core/stream.h | 2 +- src/core/stream_recv.c | 12 +- src/core/stream_send.c | 31 ++-- src/core/stream_set.c | 3 - src/generated/linux/stream_recv.c.clog.h | 20 +-- .../linux/stream_recv.c.clog.h.lttng.h | 12 +- src/generated/linux/stream_send.c.clog.h | 75 ++++++--- .../linux/stream_send.c.clog.h.lttng.h | 76 +++++++--- src/manifest/clog.sidecar | 143 ++++++++++++++++++ 9 files changed, 291 insertions(+), 83 deletions(-) diff --git a/src/core/stream.h b/src/core/stream.h index 1454db1d27..3e3f883ecf 100644 --- a/src/core/stream.h +++ b/src/core/stream.h @@ -123,6 +123,7 @@ typedef union QUIC_STREAM_FLAGS { BOOLEAN LocalCloseFin : 1; // Locally closed (graceful). BOOLEAN LocalCloseReset : 1; // Locally closed (locally aborted). BOOLEAN LocalCloseResetReliable : 1; // Indicates that we should shutdown the send path once we sent/ACK'd ReliableOffsetSend bytes. + BOOLEAN LocalCloseResetReliableAcked : 1; // Indicates the peer has acknowledged we will stop sending once we sent/ACK'd ReliableOffsetSend bytes. BOOLEAN RemoteCloseResetReliable : 1; // Indicates that the peer initiaited a reliable reset. Keep Recv path available for RecvMaxLength bytes. BOOLEAN ReceivedStopSending : 1; // Peer sent STOP_SENDING frame. BOOLEAN LocalCloseAcked : 1; // Any close acknowledged. @@ -142,7 +143,6 @@ typedef union QUIC_STREAM_FLAGS { BOOLEAN ReceiveDataPending : 1; // Data (or FIN) is queued and ready for delivery. BOOLEAN ReceiveCallPending : 1; // There is an uncompleted receive to the app. BOOLEAN ReceiveCallActive : 1; // There is an active receive to the app. - BOOLEAN ReceiveClosedReliable : 1; // We closed the stream on the Recv side from a Reliable reset frame. BOOLEAN SendDelayed : 1; // A delayed send is currently queued. BOOLEAN HandleSendShutdown : 1; // Send shutdown complete callback delivered. diff --git a/src/core/stream_recv.c b/src/core/stream_recv.c index 7b61fe637e..78659363c9 100644 --- a/src/core/stream_recv.c +++ b/src/core/stream_recv.c @@ -202,7 +202,6 @@ QuicStreamProcessReliableResetFrame( } if (Stream->RecvBuffer.BaseOffset >= Stream->RecvMaxLength) { - Stream->Flags.ReceiveClosedReliable = TRUE; Stream->Flags.LocalCloseAcked = TRUE; Stream->Flags.RemoteCloseAcked = TRUE; QuicTraceLogStreamVerbose( @@ -210,7 +209,7 @@ QuicStreamProcessReliableResetFrame( Stream, "Shutting down stream from Process Reliable Reset Frame. Recv Side. BaseOffset: %llu, RecvMaxLength: %llu", Stream->RecvBuffer.BaseOffset, Stream->RecvMaxLength); - QuicStreamRecvShutdown(Stream, TRUE, QUIC_ERROR_NO_ERROR); + QuicStreamRecvShutdown(Stream, TRUE, ErrorCode); } if (!Stream->Flags.SentStopSending) { @@ -325,7 +324,7 @@ QuicStreamProcessResetFrame( } QuicTraceLogStreamVerbose( - StreamReliableProcessResetFrame, + ProcessReliableProcessResetFrame, Stream, "Shutting down stream Abortively in ProcessResetFrame. Recv Side."); // @@ -1141,7 +1140,7 @@ QuicStreamReceiveComplete( (void)QuicStreamIndicateEvent(Stream, &Event); QuicTraceLogStreamVerbose( - StreamReliableResetRecvGraceful, + GracefulRecv, Stream, "Shutting down stream [gracefully] Recv Side."); // @@ -1158,8 +1157,7 @@ QuicStreamReceiveComplete( &Stream->Connection->Send, Stream, QUIC_STREAM_SEND_FLAG_MAX_DATA | QUIC_STREAM_SEND_FLAG_RECV_ABORT); - } else if (Stream->Flags.RemoteCloseResetReliable && Stream->RecvBuffer.BaseOffset >= Stream->RecvMaxLength && !Stream->Flags.ReceiveClosedReliable) { - Stream->Flags.ReceiveClosedReliable = TRUE; + } else if (Stream->Flags.RemoteCloseResetReliable && Stream->RecvBuffer.BaseOffset >= Stream->RecvMaxLength) { Stream->Flags.LocalCloseAcked = TRUE; Stream->Flags.RemoteCloseAcked = TRUE; QuicTraceLogStreamVerbose( @@ -1167,7 +1165,7 @@ QuicStreamReceiveComplete( Stream, "Shutting down stream from ReceiveComplete Recv Side. BaseOffset: %llu, RecvMaxLength: %llu", Stream->RecvBuffer.BaseOffset, Stream->RecvMaxLength); - QuicStreamRecvShutdown(Stream, TRUE, QUIC_ERROR_NO_ERROR); + QuicStreamRecvShutdown(Stream, TRUE, 0x21); } return FALSE; diff --git a/src/core/stream_send.c b/src/core/stream_send.c index 5e056f7a8f..8705ba21cb 100644 --- a/src/core/stream_send.c +++ b/src/core/stream_send.c @@ -238,7 +238,7 @@ QuicStreamSendShutdown( QUIC_STREAM_SEND_FLAG_FIN); } } else { - if (Stream->Flags.LocalCloseReset || Stream->Flags.LocalCloseResetReliable) { + if (Stream->Flags.LocalCloseReset) { // // We have already closed the stream (graceful or abortive) so we // can't reliably abort it. @@ -527,11 +527,6 @@ QuicStreamSendFlush( BOOLEAN Start = FALSE; while (ApiSendRequests != NULL) { - - if (Stream->UnAckedOffset >= Stream->ReliableOffsetSend && Stream->Flags.LocalCloseResetReliable) { - break; - } - QUIC_SEND_REQUEST* SendRequest = ApiSendRequests; ApiSendRequests = ApiSendRequests->Next; SendRequest->Next = NULL; @@ -1213,7 +1208,7 @@ QuicStreamOnLoss( return FALSE; } - if (Stream->Flags.LocalCloseResetReliable && Stream->UnAckedOffset >= Stream->ReliableOffsetSend) { + if (Stream->Flags.LocalCloseResetReliableAcked && Stream->UnAckedOffset >= Stream->ReliableOffsetSend) { // // Ignore any STREAM frame packet loss if we aborted reliably and // received acks for enough data. @@ -1480,7 +1475,7 @@ QuicStreamOnAck( Stream, QuicStreamSendGetState(Stream)); QuicTraceLogStreamVerbose( - StreamGracefulShutdown, + GracefulShutdown, Stream, "Shutting down [gracefully] from OnStreamAck. Send Side."); QuicStreamIndicateSendShutdownComplete(Stream, TRUE); @@ -1527,14 +1522,15 @@ QuicStreamOnAck( // // If this stream has been reset reliably, we only close if we have received enough bytes. // - BOOLEAN ReliableResetShutdown = !Stream->Flags.LocalCloseAcked && Stream->Flags.LocalCloseResetReliable && Stream->UnAckedOffset >= Stream->ReliableOffsetSend; + BOOLEAN ReliableResetShutdown = !Stream->Flags.LocalCloseAcked && Stream->Flags.LocalCloseResetReliableAcked && Stream->UnAckedOffset >= Stream->ReliableOffsetSend; if (ReliableResetShutdown) { Stream->Flags.LocalCloseAcked = TRUE; Stream->Flags.RemoteCloseAcked = TRUE; QuicTraceLogStreamVerbose( - ReliableResetOnStreamAck, + OnStreamAckReliableReset, Stream, - "Shutting down stream [reliable] from OnStreamAck. Send side."); + "Shutting down stream [reliable] from OnStreamAck. Send side. UnAckedOffset=%llu, ReliableOffsetSend=%llu", + Stream->UnAckedOffset, Stream->ReliableOffsetSend); QuicStreamCleanupReliableReset(Stream); Stream->Flags.LocalCloseReset = TRUE; QuicStreamSendShutdown(Stream, FALSE, TRUE, FALSE, 0x21); @@ -1598,7 +1594,7 @@ QuicStreamOnResetAck( Stream, QuicStreamSendGetState(Stream)); QuicTraceLogStreamVerbose( - StreamOnResetAck, + OnResetAck, Stream, "Shutting down stream [abortively] from OnResetAck. Send Side."); QuicStreamIndicateSendShutdownComplete(Stream, FALSE); @@ -1611,13 +1607,20 @@ void QuicStreamOnResetReliableAck( _In_ QUIC_STREAM* Stream ) { + Stream->Flags.LocalCloseResetReliableAcked = TRUE; + QuicTraceLogStreamVerbose( + ResetReliableAck, + Stream, + "Reset Reliable ACKed in OnResetReliableAck. Send side. UnAckedOffset=%llu, ReliableOffsetSend=%llu", + Stream->UnAckedOffset, Stream->ReliableOffsetSend); if (Stream->UnAckedOffset >= Stream->ReliableOffsetSend && !Stream->Flags.LocalCloseAcked) { Stream->Flags.LocalCloseAcked = TRUE; Stream->Flags.RemoteCloseAcked = TRUE; QuicTraceLogStreamVerbose( - OnResetReliableAck, + ResetReliableAckShutDown, Stream, - "Shutting down stream [reliably] from OnResetReliableAck. Send side."); + "Shutting down stream [reliably] from OnResetReliableAck. Send side. UnAckedOffset=%llu, ReliableOffsetSend=%llu", + Stream->UnAckedOffset, Stream->ReliableOffsetSend); QuicStreamCleanupReliableReset(Stream); Stream->Flags.LocalCloseReset = TRUE; QuicStreamSendShutdown(Stream, FALSE, TRUE, FALSE, 0x21); diff --git a/src/core/stream_set.c b/src/core/stream_set.c index 7c540ff6ca..5d37a8a15c 100644 --- a/src/core/stream_set.c +++ b/src/core/stream_set.c @@ -160,9 +160,6 @@ QuicStreamSetShutdown( CxPlatHashtableEnumerateBegin(StreamSet->StreamTable, &Enumerator); while ((Entry = CxPlatHashtableEnumerateNext(StreamSet->StreamTable, &Enumerator)) != NULL) { QUIC_STREAM* Stream = CXPLAT_CONTAINING_RECORD(Entry, QUIC_STREAM, TableEntry); - if (Stream->Flags.LocalCloseResetReliable && !Stream->Flags.LocalCloseAcked) { - continue; - } QuicStreamShutdown( Stream, QUIC_STREAM_SHUTDOWN_FLAG_ABORT_SEND | diff --git a/src/generated/linux/stream_recv.c.clog.h b/src/generated/linux/stream_recv.c.clog.h index 38e933254e..aaad01f8ec 100644 --- a/src/generated/linux/stream_recv.c.clog.h +++ b/src/generated/linux/stream_recv.c.clog.h @@ -257,17 +257,17 @@ tracepoint(CLOG_STREAM_RECV_C, IndicatePeerSendAbort , arg1, arg3);\ /*---------------------------------------------------------- -// Decoder Ring for StreamReliableProcessResetFrame +// Decoder Ring for ProcessReliableProcessResetFrame // [strm][%p] Shutting down stream Abortively in ProcessResetFrame. Recv Side. // QuicTraceLogStreamVerbose( - StreamReliableProcessResetFrame, + ProcessReliableProcessResetFrame, Stream, "Shutting down stream Abortively in ProcessResetFrame. Recv Side."); // arg1 = arg1 = Stream = arg1 ----------------------------------------------------------*/ -#ifndef _clog_3_ARGS_TRACE_StreamReliableProcessResetFrame -#define _clog_3_ARGS_TRACE_StreamReliableProcessResetFrame(uniqueId, arg1, encoded_arg_string)\ -tracepoint(CLOG_STREAM_RECV_C, StreamReliableProcessResetFrame , arg1);\ +#ifndef _clog_3_ARGS_TRACE_ProcessReliableProcessResetFrame +#define _clog_3_ARGS_TRACE_ProcessReliableProcessResetFrame(uniqueId, arg1, encoded_arg_string)\ +tracepoint(CLOG_STREAM_RECV_C, ProcessReliableProcessResetFrame , arg1);\ #endif @@ -473,17 +473,17 @@ tracepoint(CLOG_STREAM_RECV_C, IndicatePeerSendShutdown , arg1);\ /*---------------------------------------------------------- -// Decoder Ring for StreamReliableResetRecvGraceful +// Decoder Ring for GracefulRecv // [strm][%p] Shutting down stream [gracefully] Recv Side. // QuicTraceLogStreamVerbose( - StreamReliableResetRecvGraceful, + GracefulRecv, Stream, "Shutting down stream [gracefully] Recv Side."); // arg1 = arg1 = Stream = arg1 ----------------------------------------------------------*/ -#ifndef _clog_3_ARGS_TRACE_StreamReliableResetRecvGraceful -#define _clog_3_ARGS_TRACE_StreamReliableResetRecvGraceful(uniqueId, arg1, encoded_arg_string)\ -tracepoint(CLOG_STREAM_RECV_C, StreamReliableResetRecvGraceful , arg1);\ +#ifndef _clog_3_ARGS_TRACE_GracefulRecv +#define _clog_3_ARGS_TRACE_GracefulRecv(uniqueId, arg1, encoded_arg_string)\ +tracepoint(CLOG_STREAM_RECV_C, GracefulRecv , arg1);\ #endif diff --git a/src/generated/linux/stream_recv.c.clog.h.lttng.h b/src/generated/linux/stream_recv.c.clog.h.lttng.h index f4f81f0953..9c9bb4e76b 100644 --- a/src/generated/linux/stream_recv.c.clog.h.lttng.h +++ b/src/generated/linux/stream_recv.c.clog.h.lttng.h @@ -245,15 +245,15 @@ TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, IndicatePeerSendAbort, /*---------------------------------------------------------- -// Decoder Ring for StreamReliableProcessResetFrame +// Decoder Ring for ProcessReliableProcessResetFrame // [strm][%p] Shutting down stream Abortively in ProcessResetFrame. Recv Side. // QuicTraceLogStreamVerbose( - StreamReliableProcessResetFrame, + ProcessReliableProcessResetFrame, Stream, "Shutting down stream Abortively in ProcessResetFrame. Recv Side."); // arg1 = arg1 = Stream = arg1 ----------------------------------------------------------*/ -TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, StreamReliableProcessResetFrame, +TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, ProcessReliableProcessResetFrame, TP_ARGS( const void *, arg1), TP_FIELDS( @@ -490,15 +490,15 @@ TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, IndicatePeerSendShutdown, /*---------------------------------------------------------- -// Decoder Ring for StreamReliableResetRecvGraceful +// Decoder Ring for GracefulRecv // [strm][%p] Shutting down stream [gracefully] Recv Side. // QuicTraceLogStreamVerbose( - StreamReliableResetRecvGraceful, + GracefulRecv, Stream, "Shutting down stream [gracefully] Recv Side."); // arg1 = arg1 = Stream = arg1 ----------------------------------------------------------*/ -TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, StreamReliableResetRecvGraceful, +TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, GracefulRecv, TP_ARGS( const void *, arg1), TP_FIELDS( diff --git a/src/generated/linux/stream_send.c.clog.h b/src/generated/linux/stream_send.c.clog.h index ce130cb13f..69246ce698 100644 --- a/src/generated/linux/stream_send.c.clog.h +++ b/src/generated/linux/stream_send.c.clog.h @@ -290,17 +290,17 @@ tracepoint(CLOG_STREAM_SEND_C, SendQueueDrained , arg1);\ /*---------------------------------------------------------- -// Decoder Ring for StreamGracefulShutdown +// Decoder Ring for GracefulShutdown // [strm][%p] Shutting down [gracefully] from OnStreamAck. Send Side. // QuicTraceLogStreamVerbose( - StreamGracefulShutdown, + GracefulShutdown, Stream, "Shutting down [gracefully] from OnStreamAck. Send Side."); // arg1 = arg1 = Stream = arg1 ----------------------------------------------------------*/ -#ifndef _clog_3_ARGS_TRACE_StreamGracefulShutdown -#define _clog_3_ARGS_TRACE_StreamGracefulShutdown(uniqueId, arg1, encoded_arg_string)\ -tracepoint(CLOG_STREAM_SEND_C, StreamGracefulShutdown , arg1);\ +#ifndef _clog_3_ARGS_TRACE_GracefulShutdown +#define _clog_3_ARGS_TRACE_GracefulShutdown(uniqueId, arg1, encoded_arg_string)\ +tracepoint(CLOG_STREAM_SEND_C, GracefulShutdown , arg1);\ #endif @@ -308,17 +308,20 @@ tracepoint(CLOG_STREAM_SEND_C, StreamGracefulShutdown , arg1);\ /*---------------------------------------------------------- -// Decoder Ring for ReliableResetOnStreamAck -// [strm][%p] Shutting down stream [reliable] from OnStreamAck. Send side. +// Decoder Ring for OnStreamAckReliableReset +// [strm][%p] Shutting down stream [reliable] from OnStreamAck. Send side. UnAckedOffset=%llu, ReliableOffsetSend=%llu // QuicTraceLogStreamVerbose( - ReliableResetOnStreamAck, + OnStreamAckReliableReset, Stream, - "Shutting down stream [reliable] from OnStreamAck. Send side."); + "Shutting down stream [reliable] from OnStreamAck. Send side. UnAckedOffset=%llu, ReliableOffsetSend=%llu", + Stream->UnAckedOffset, Stream->ReliableOffsetSend); // arg1 = arg1 = Stream = arg1 +// arg3 = arg3 = Stream->UnAckedOffset = arg3 +// arg4 = arg4 = Stream->ReliableOffsetSend = arg4 ----------------------------------------------------------*/ -#ifndef _clog_3_ARGS_TRACE_ReliableResetOnStreamAck -#define _clog_3_ARGS_TRACE_ReliableResetOnStreamAck(uniqueId, arg1, encoded_arg_string)\ -tracepoint(CLOG_STREAM_SEND_C, ReliableResetOnStreamAck , arg1);\ +#ifndef _clog_5_ARGS_TRACE_OnStreamAckReliableReset +#define _clog_5_ARGS_TRACE_OnStreamAckReliableReset(uniqueId, arg1, encoded_arg_string, arg3, arg4)\ +tracepoint(CLOG_STREAM_SEND_C, OnStreamAckReliableReset , arg1, arg3, arg4);\ #endif @@ -326,17 +329,17 @@ tracepoint(CLOG_STREAM_SEND_C, ReliableResetOnStreamAck , arg1);\ /*---------------------------------------------------------- -// Decoder Ring for StreamOnResetAck +// Decoder Ring for OnResetAck // [strm][%p] Shutting down stream [abortively] from OnResetAck. Send Side. // QuicTraceLogStreamVerbose( - StreamOnResetAck, + OnResetAck, Stream, "Shutting down stream [abortively] from OnResetAck. Send Side."); // arg1 = arg1 = Stream = arg1 ----------------------------------------------------------*/ -#ifndef _clog_3_ARGS_TRACE_StreamOnResetAck -#define _clog_3_ARGS_TRACE_StreamOnResetAck(uniqueId, arg1, encoded_arg_string)\ -tracepoint(CLOG_STREAM_SEND_C, StreamOnResetAck , arg1);\ +#ifndef _clog_3_ARGS_TRACE_OnResetAck +#define _clog_3_ARGS_TRACE_OnResetAck(uniqueId, arg1, encoded_arg_string)\ +tracepoint(CLOG_STREAM_SEND_C, OnResetAck , arg1);\ #endif @@ -344,17 +347,41 @@ tracepoint(CLOG_STREAM_SEND_C, StreamOnResetAck , arg1);\ /*---------------------------------------------------------- -// Decoder Ring for OnResetReliableAck -// [strm][%p] Shutting down stream [reliably] from OnResetReliableAck. Send side. +// Decoder Ring for ResetReliableAck +// [strm][%p] Reset Reliable ACKed in OnResetReliableAck. Send side. UnAckedOffset=%llu, ReliableOffsetSend=%llu // QuicTraceLogStreamVerbose( - OnResetReliableAck, + ResetReliableAck, Stream, - "Shutting down stream [reliably] from OnResetReliableAck. Send side."); + "Reset Reliable ACKed in OnResetReliableAck. Send side. UnAckedOffset=%llu, ReliableOffsetSend=%llu", + Stream->UnAckedOffset, Stream->ReliableOffsetSend); // arg1 = arg1 = Stream = arg1 +// arg3 = arg3 = Stream->UnAckedOffset = arg3 +// arg4 = arg4 = Stream->ReliableOffsetSend = arg4 ----------------------------------------------------------*/ -#ifndef _clog_3_ARGS_TRACE_OnResetReliableAck -#define _clog_3_ARGS_TRACE_OnResetReliableAck(uniqueId, arg1, encoded_arg_string)\ -tracepoint(CLOG_STREAM_SEND_C, OnResetReliableAck , arg1);\ +#ifndef _clog_5_ARGS_TRACE_ResetReliableAck +#define _clog_5_ARGS_TRACE_ResetReliableAck(uniqueId, arg1, encoded_arg_string, arg3, arg4)\ +tracepoint(CLOG_STREAM_SEND_C, ResetReliableAck , arg1, arg3, arg4);\ + +#endif + + + + +/*---------------------------------------------------------- +// Decoder Ring for ResetReliableAckShutDown +// [strm][%p] Shutting down stream [reliably] from OnResetReliableAck. Send side. UnAckedOffset=%llu, ReliableOffsetSend=%llu +// QuicTraceLogStreamVerbose( + ResetReliableAckShutDown, + Stream, + "Shutting down stream [reliably] from OnResetReliableAck. Send side. UnAckedOffset=%llu, ReliableOffsetSend=%llu", + Stream->UnAckedOffset, Stream->ReliableOffsetSend); +// arg1 = arg1 = Stream = arg1 +// arg3 = arg3 = Stream->UnAckedOffset = arg3 +// arg4 = arg4 = Stream->ReliableOffsetSend = arg4 +----------------------------------------------------------*/ +#ifndef _clog_5_ARGS_TRACE_ResetReliableAckShutDown +#define _clog_5_ARGS_TRACE_ResetReliableAckShutDown(uniqueId, arg1, encoded_arg_string, arg3, arg4)\ +tracepoint(CLOG_STREAM_SEND_C, ResetReliableAckShutDown , arg1, arg3, arg4);\ #endif diff --git a/src/generated/linux/stream_send.c.clog.h.lttng.h b/src/generated/linux/stream_send.c.clog.h.lttng.h index 724caf8404..170efbe2b5 100644 --- a/src/generated/linux/stream_send.c.clog.h.lttng.h +++ b/src/generated/linux/stream_send.c.clog.h.lttng.h @@ -309,15 +309,15 @@ TRACEPOINT_EVENT(CLOG_STREAM_SEND_C, SendQueueDrained, /*---------------------------------------------------------- -// Decoder Ring for StreamGracefulShutdown +// Decoder Ring for GracefulShutdown // [strm][%p] Shutting down [gracefully] from OnStreamAck. Send Side. // QuicTraceLogStreamVerbose( - StreamGracefulShutdown, + GracefulShutdown, Stream, "Shutting down [gracefully] from OnStreamAck. Send Side."); // arg1 = arg1 = Stream = arg1 ----------------------------------------------------------*/ -TRACEPOINT_EVENT(CLOG_STREAM_SEND_C, StreamGracefulShutdown, +TRACEPOINT_EVENT(CLOG_STREAM_SEND_C, GracefulShutdown, TP_ARGS( const void *, arg1), TP_FIELDS( @@ -328,34 +328,41 @@ TRACEPOINT_EVENT(CLOG_STREAM_SEND_C, StreamGracefulShutdown, /*---------------------------------------------------------- -// Decoder Ring for ReliableResetOnStreamAck -// [strm][%p] Shutting down stream [reliable] from OnStreamAck. Send side. +// Decoder Ring for OnStreamAckReliableReset +// [strm][%p] Shutting down stream [reliable] from OnStreamAck. Send side. UnAckedOffset=%llu, ReliableOffsetSend=%llu // QuicTraceLogStreamVerbose( - ReliableResetOnStreamAck, + OnStreamAckReliableReset, Stream, - "Shutting down stream [reliable] from OnStreamAck. Send side."); + "Shutting down stream [reliable] from OnStreamAck. Send side. UnAckedOffset=%llu, ReliableOffsetSend=%llu", + Stream->UnAckedOffset, Stream->ReliableOffsetSend); // arg1 = arg1 = Stream = arg1 +// arg3 = arg3 = Stream->UnAckedOffset = arg3 +// arg4 = arg4 = Stream->ReliableOffsetSend = arg4 ----------------------------------------------------------*/ -TRACEPOINT_EVENT(CLOG_STREAM_SEND_C, ReliableResetOnStreamAck, +TRACEPOINT_EVENT(CLOG_STREAM_SEND_C, OnStreamAckReliableReset, TP_ARGS( - const void *, arg1), + const void *, arg1, + unsigned long long, arg3, + unsigned long long, arg4), TP_FIELDS( ctf_integer_hex(uint64_t, arg1, arg1) + ctf_integer(uint64_t, arg3, arg3) + ctf_integer(uint64_t, arg4, arg4) ) ) /*---------------------------------------------------------- -// Decoder Ring for StreamOnResetAck +// Decoder Ring for OnResetAck // [strm][%p] Shutting down stream [abortively] from OnResetAck. Send Side. // QuicTraceLogStreamVerbose( - StreamOnResetAck, + OnResetAck, Stream, "Shutting down stream [abortively] from OnResetAck. Send Side."); // arg1 = arg1 = Stream = arg1 ----------------------------------------------------------*/ -TRACEPOINT_EVENT(CLOG_STREAM_SEND_C, StreamOnResetAck, +TRACEPOINT_EVENT(CLOG_STREAM_SEND_C, OnResetAck, TP_ARGS( const void *, arg1), TP_FIELDS( @@ -366,19 +373,52 @@ TRACEPOINT_EVENT(CLOG_STREAM_SEND_C, StreamOnResetAck, /*---------------------------------------------------------- -// Decoder Ring for OnResetReliableAck -// [strm][%p] Shutting down stream [reliably] from OnResetReliableAck. Send side. +// Decoder Ring for ResetReliableAck +// [strm][%p] Reset Reliable ACKed in OnResetReliableAck. Send side. UnAckedOffset=%llu, ReliableOffsetSend=%llu // QuicTraceLogStreamVerbose( - OnResetReliableAck, + ResetReliableAck, Stream, - "Shutting down stream [reliably] from OnResetReliableAck. Send side."); + "Reset Reliable ACKed in OnResetReliableAck. Send side. UnAckedOffset=%llu, ReliableOffsetSend=%llu", + Stream->UnAckedOffset, Stream->ReliableOffsetSend); // arg1 = arg1 = Stream = arg1 +// arg3 = arg3 = Stream->UnAckedOffset = arg3 +// arg4 = arg4 = Stream->ReliableOffsetSend = arg4 ----------------------------------------------------------*/ -TRACEPOINT_EVENT(CLOG_STREAM_SEND_C, OnResetReliableAck, +TRACEPOINT_EVENT(CLOG_STREAM_SEND_C, ResetReliableAck, TP_ARGS( - const void *, arg1), + const void *, arg1, + unsigned long long, arg3, + unsigned long long, arg4), + TP_FIELDS( + ctf_integer_hex(uint64_t, arg1, arg1) + ctf_integer(uint64_t, arg3, arg3) + ctf_integer(uint64_t, arg4, arg4) + ) +) + + + +/*---------------------------------------------------------- +// Decoder Ring for ResetReliableAckShutDown +// [strm][%p] Shutting down stream [reliably] from OnResetReliableAck. Send side. UnAckedOffset=%llu, ReliableOffsetSend=%llu +// QuicTraceLogStreamVerbose( + ResetReliableAckShutDown, + Stream, + "Shutting down stream [reliably] from OnResetReliableAck. Send side. UnAckedOffset=%llu, ReliableOffsetSend=%llu", + Stream->UnAckedOffset, Stream->ReliableOffsetSend); +// arg1 = arg1 = Stream = arg1 +// arg3 = arg3 = Stream->UnAckedOffset = arg3 +// arg4 = arg4 = Stream->ReliableOffsetSend = arg4 +----------------------------------------------------------*/ +TRACEPOINT_EVENT(CLOG_STREAM_SEND_C, ResetReliableAckShutDown, + TP_ARGS( + const void *, arg1, + unsigned long long, arg3, + unsigned long long, arg4), TP_FIELDS( ctf_integer_hex(uint64_t, arg1, arg1) + ctf_integer(uint64_t, arg3, arg3) + ctf_integer(uint64_t, arg4, arg4) ) ) diff --git a/src/manifest/clog.sidecar b/src/manifest/clog.sidecar index 67e1a2e9d5..60257cce39 100644 --- a/src/manifest/clog.sidecar +++ b/src/manifest/clog.sidecar @@ -5531,6 +5531,30 @@ ], "macroName": "QuicTraceLogConnWarning" }, + "GracefulRecv": { + "ModuleProperites": {}, + "TraceString": "[strm][%p] Shutting down stream [gracefully] Recv Side.", + "UniqueId": "GracefulRecv", + "splitArgs": [ + { + "DefinationEncoding": "p", + "MacroVariableName": "arg1" + } + ], + "macroName": "QuicTraceLogStreamVerbose" + }, + "GracefulShutdown": { + "ModuleProperites": {}, + "TraceString": "[strm][%p] Shutting down [gracefully] from OnStreamAck. Send Side.", + "UniqueId": "GracefulShutdown", + "splitArgs": [ + { + "DefinationEncoding": "p", + "MacroVariableName": "arg1" + } + ], + "macroName": "QuicTraceLogStreamVerbose" + }, "HandshakeConfirmedAck": { "ModuleProperites": {}, "TraceString": "[conn][%p] Handshake confirmed (ack)", @@ -7336,6 +7360,18 @@ ], "macroName": "QuicTraceLogConnInfo" }, + "OnResetAck": { + "ModuleProperites": {}, + "TraceString": "[strm][%p] Shutting down stream [abortively] from OnResetAck. Send Side.", + "UniqueId": "OnResetAck", + "splitArgs": [ + { + "DefinationEncoding": "p", + "MacroVariableName": "arg1" + } + ], + "macroName": "QuicTraceLogStreamVerbose" + }, "OnResetReliableAck": { "ModuleProperites": {}, "TraceString": "[strm][%p] Shutting down stream [reliably] from OnResetReliableAck. Send side.", @@ -7348,6 +7384,26 @@ ], "macroName": "QuicTraceLogStreamVerbose" }, + "OnStreamAckReliableReset": { + "ModuleProperites": {}, + "TraceString": "[strm][%p] Shutting down stream [reliable] from OnStreamAck. Send side. UnAckedOffset=%llu, ReliableOffsetSend=%llu", + "UniqueId": "OnStreamAckReliableReset", + "splitArgs": [ + { + "DefinationEncoding": "p", + "MacroVariableName": "arg1" + }, + { + "DefinationEncoding": "llu", + "MacroVariableName": "arg3" + }, + { + "DefinationEncoding": "llu", + "MacroVariableName": "arg4" + } + ], + "macroName": "QuicTraceLogStreamVerbose" + }, "OpenSsl1RttDataStart": { "ModuleProperites": {}, "TraceString": "[conn][%p] Writing 1-RTT data starts at %u", @@ -8838,6 +8894,18 @@ ], "macroName": "QuicTraceLogInfo" }, + "ProcessReliableProcessResetFrame": { + "ModuleProperites": {}, + "TraceString": "[strm][%p] Shutting down stream Abortively in ProcessResetFrame. Recv Side.", + "UniqueId": "ProcessReliableProcessResetFrame", + "splitArgs": [ + { + "DefinationEncoding": "p", + "MacroVariableName": "arg1" + } + ], + "macroName": "QuicTraceLogStreamVerbose" + }, "ProcessReliableReset": { "ModuleProperites": {}, "TraceString": "[strm][%p] Shutting down stream from Process Reliable Reset Frame. Recv Side. BaseOffset: %llu, RecvMaxLength: %llu", @@ -9370,6 +9438,46 @@ ], "macroName": "QuicTraceLogStreamWarning" }, + "ResetReliableAck": { + "ModuleProperites": {}, + "TraceString": "[strm][%p] Reset Reliable ACKed in OnResetReliableAck. Send side. UnAckedOffset=%llu, ReliableOffsetSend=%llu", + "UniqueId": "ResetReliableAck", + "splitArgs": [ + { + "DefinationEncoding": "p", + "MacroVariableName": "arg1" + }, + { + "DefinationEncoding": "llu", + "MacroVariableName": "arg3" + }, + { + "DefinationEncoding": "llu", + "MacroVariableName": "arg4" + } + ], + "macroName": "QuicTraceLogStreamVerbose" + }, + "ResetReliableAckShutDown": { + "ModuleProperites": {}, + "TraceString": "[strm][%p] Shutting down stream [reliably] from OnResetReliableAck. Send side. UnAckedOffset=%llu, ReliableOffsetSend=%llu", + "UniqueId": "ResetReliableAckShutDown", + "splitArgs": [ + { + "DefinationEncoding": "p", + "MacroVariableName": "arg1" + }, + { + "DefinationEncoding": "llu", + "MacroVariableName": "arg3" + }, + { + "DefinationEncoding": "llu", + "MacroVariableName": "arg4" + } + ], + "macroName": "QuicTraceLogStreamVerbose" + }, "ResetTooBig": { "ModuleProperites": {}, "TraceString": "[strm][%p] Tried to reset with too big final size!", @@ -14514,6 +14622,16 @@ "TraceID": "GetPacketTypeFailure", "EncodingString": "[conn][%p] Failed to get packet type for control frames, 0x%x" }, + { + "UniquenessHash": "1ec6223a-a19f-a735-9a21-ed1d8d73b5d3", + "TraceID": "GracefulRecv", + "EncodingString": "[strm][%p] Shutting down stream [gracefully] Recv Side." + }, + { + "UniquenessHash": "5f7f4d4e-dafa-668f-9f15-913a5bee40ab", + "TraceID": "GracefulShutdown", + "EncodingString": "[strm][%p] Shutting down [gracefully] from OnStreamAck. Send Side." + }, { "UniquenessHash": "eeb31991-927b-2f3c-bfb7-12b7dea50ead", "TraceID": "HandshakeConfirmedAck", @@ -15099,11 +15217,21 @@ "TraceID": "OfflodingStop", "EncodingString": "[conn][%p] Path[%hhu] %s stop encryption offloading" }, + { + "UniquenessHash": "5dd5642c-a450-86ac-bd61-deaac4c3e22b", + "TraceID": "OnResetAck", + "EncodingString": "[strm][%p] Shutting down stream [abortively] from OnResetAck. Send Side." + }, { "UniquenessHash": "2cc58e3e-a2c8-f337-a085-325bf53da75c", "TraceID": "OnResetReliableAck", "EncodingString": "[strm][%p] Shutting down stream [reliably] from OnResetReliableAck. Send side." }, + { + "UniquenessHash": "6f67e832-eb3d-e51d-c58e-12962752358b", + "TraceID": "OnStreamAckReliableReset", + "EncodingString": "[strm][%p] Shutting down stream [reliable] from OnStreamAck. Send side. UnAckedOffset=%llu, ReliableOffsetSend=%llu" + }, { "UniquenessHash": "eaede67a-124b-3b3f-95ba-363d08546d2a", "TraceID": "OpenSsl1RttDataStart", @@ -15614,6 +15742,11 @@ "TraceID": "ProcessorInfoV2", "EncodingString": "[ dll] Proc[%u] Group[%hu] Index[%u] Active=%hhu" }, + { + "UniquenessHash": "d3961059-2b9a-e20d-88c5-d1fc421bbf13", + "TraceID": "ProcessReliableProcessResetFrame", + "EncodingString": "[strm][%p] Shutting down stream Abortively in ProcessResetFrame. Recv Side." + }, { "UniquenessHash": "518b5117-c14d-ee4e-47c5-8264735c8638", "TraceID": "ProcessReliableReset", @@ -15784,6 +15917,16 @@ "TraceID": "ResetEarly", "EncodingString": "[strm][%p] Tried to reset at earlier final size!" }, + { + "UniquenessHash": "50002ed8-e6a9-b9ca-037a-59003c9e1f5f", + "TraceID": "ResetReliableAck", + "EncodingString": "[strm][%p] Reset Reliable ACKed in OnResetReliableAck. Send side. UnAckedOffset=%llu, ReliableOffsetSend=%llu" + }, + { + "UniquenessHash": "46d87c29-7237-3ef0-b107-77b5f4db762f", + "TraceID": "ResetReliableAckShutDown", + "EncodingString": "[strm][%p] Shutting down stream [reliably] from OnResetReliableAck. Send side. UnAckedOffset=%llu, ReliableOffsetSend=%llu" + }, { "UniquenessHash": "a3253f53-3e9c-4e45-d114-c4e99cd3cdc6", "TraceID": "ResetTooBig", From 28c338d25cd9c5b06a423824b8f30bd4d46bca1e Mon Sep 17 00:00:00 2001 From: Jack He Date: Mon, 4 Sep 2023 18:18:09 -0700 Subject: [PATCH 058/123] Add packet loss to test --- src/test/lib/DataTest.cpp | 41 ++++++++++++++++++++++----------------- 1 file changed, 23 insertions(+), 18 deletions(-) diff --git a/src/test/lib/DataTest.cpp b/src/test/lib/DataTest.cpp index 002ce86b2b..e04498e71e 100644 --- a/src/test/lib/DataTest.cpp +++ b/src/test/lib/DataTest.cpp @@ -3255,24 +3255,29 @@ QuicTestStreamReliableReset( TEST_TRUE(Listener.LastConnection->HandshakeComplete); CxPlatSleep(50); // Wait for things to idle out - MsQuicStream Stream(Connection, QUIC_STREAM_OPEN_FLAG_NONE, CleanUpManual, StreamReliableReset::ClientStreamCallback, &Context); - TEST_QUIC_SUCCEEDED(Stream.GetInitStatus()); - TEST_QUIC_SUCCEEDED(Stream.Start()); - TEST_QUIC_SUCCEEDED(Stream.Send(&SendBuffer, 1, QUIC_SEND_FLAG_DELAY_SEND, &Context)); - TEST_QUIC_STATUS( - QUIC_STATUS_INVALID_STATE, - Stream.SetReliableOffset(UINT64_MAX)); - TEST_QUIC_SUCCEEDED(Stream.SetReliableOffset(RELIABLE_SIZE)); - TEST_QUIC_SUCCEEDED(Stream.Shutdown(0)); // Queues up a shutdown operation. - // Should behave similar to QUIC_STREAM_SHUTDOWN_FLAG_GRACEFUL, with some restrictions. - TEST_TRUE(Context.ClientStreamShutdownComplete.WaitTimeout(TestWaitTimeout)); - TEST_TRUE(Context.ServerStreamShutdownComplete.WaitTimeout(TestWaitTimeout)); - TEST_TRUE(Context.ReceivedBufferSize >= RELIABLE_SIZE); - - // We shouldn't be able to change ReliableSize now that the stream has already been reset. - TEST_QUIC_STATUS( - QUIC_STATUS_INVALID_STATE, - Stream.SetReliableOffset(1)); + for (uint64_t Bitmap = 0; Bitmap < 8; ++Bitmap) { // Try dropping the first 3 packets + char Name[64]; sprintf_s(Name, sizeof(Name), "Try Reliably Shutting Down Stream %llu", (unsigned long long)Bitmap); + TestScopeLogger logScope(Name); + BitmapLossHelper LossHelper(Bitmap); + MsQuicStream Stream(Connection, QUIC_STREAM_OPEN_FLAG_NONE, CleanUpManual, StreamReliableReset::ClientStreamCallback, &Context); + TEST_QUIC_SUCCEEDED(Stream.GetInitStatus()); + TEST_QUIC_SUCCEEDED(Stream.Start()); + TEST_QUIC_SUCCEEDED(Stream.Send(&SendBuffer, 1, QUIC_SEND_FLAG_DELAY_SEND, &Context)); + TEST_QUIC_STATUS( + QUIC_STATUS_INVALID_STATE, + Stream.SetReliableOffset(UINT64_MAX)); + TEST_QUIC_SUCCEEDED(Stream.SetReliableOffset(RELIABLE_SIZE)); + TEST_QUIC_SUCCEEDED(Stream.Shutdown(0)); // Queues up a shutdown operation. + // Should behave similar to QUIC_STREAM_SHUTDOWN_FLAG_GRACEFUL, with some restrictions. + TEST_TRUE(Context.ClientStreamShutdownComplete.WaitTimeout(TestWaitTimeout)); + TEST_TRUE(Context.ServerStreamShutdownComplete.WaitTimeout(TestWaitTimeout)); + TEST_TRUE(Context.ReceivedBufferSize >= RELIABLE_SIZE); + + // We shouldn't be able to change ReliableSize now that the stream has already been reset. + TEST_QUIC_STATUS( + QUIC_STATUS_INVALID_STATE, + Stream.SetReliableOffset(1)); + } } From 331e71c2c3dbff49cd887f4e66a87cb90719148b Mon Sep 17 00:00:00 2001 From: Jack He Date: Tue, 5 Sep 2023 11:44:31 -0700 Subject: [PATCH 059/123] error out instead of ignoring --- src/core/stream.c | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/src/core/stream.c b/src/core/stream.c index eaab564080..49e2af8133 100644 --- a/src/core/stream.c +++ b/src/core/stream.c @@ -567,13 +567,21 @@ QuicStreamShutdown( } if (!!(Flags & QUIC_STREAM_SHUTDOWN_FLAG_IMMEDIATE) && - !Stream->Flags.ShutdownComplete && !Stream->Flags.RemoteCloseResetReliable) { + !Stream->Flags.ShutdownComplete) { // // The app has requested that we immediately give them completion // events so they don't have to wait. Deliver the send shutdown complete // and shutdown complete events now, if they haven't already been // delivered. // + if (Stream->Flags.RemoteCloseResetReliable || Stream->Flags.LocalCloseResetReliable) { + QuicTraceLogStreamWarning( + BadShutdownImmediate, + Stream, + "App tried ditching this stream but it still has stuff to do."); + QuicConnTransportError(Stream->Connection, QUIC_ERROR_STREAM_STATE_ERROR); + return; + } QuicStreamIndicateSendShutdownComplete(Stream, FALSE); QuicStreamIndicateShutdownComplete(Stream); } From 45a7d9bf7448087b378674b1ba49b7d851c6a669 Mon Sep 17 00:00:00 2001 From: Jack He Date: Tue, 5 Sep 2023 11:52:48 -0700 Subject: [PATCH 060/123] update clog --- src/generated/linux/stream.c.clog.h | 18 ++++++++++++++++++ src/generated/linux/stream.c.clog.h.lttng.h | 19 +++++++++++++++++++ src/manifest/clog.sidecar | 17 +++++++++++++++++ 3 files changed, 54 insertions(+) diff --git a/src/generated/linux/stream.c.clog.h b/src/generated/linux/stream.c.clog.h index ac7c040951..cdb2cdecf5 100644 --- a/src/generated/linux/stream.c.clog.h +++ b/src/generated/linux/stream.c.clog.h @@ -69,6 +69,24 @@ tracepoint(CLOG_STREAM_C, EventSilentDiscard , arg1);\ +/*---------------------------------------------------------- +// Decoder Ring for BadShutdownImmediate +// [strm][%p] App tried ditching this stream but it still has stuff to do. +// QuicTraceLogStreamWarning( + BadShutdownImmediate, + Stream, + "App tried ditching this stream but it still has stuff to do."); +// arg1 = arg1 = Stream = arg1 +----------------------------------------------------------*/ +#ifndef _clog_3_ARGS_TRACE_BadShutdownImmediate +#define _clog_3_ARGS_TRACE_BadShutdownImmediate(uniqueId, arg1, encoded_arg_string)\ +tracepoint(CLOG_STREAM_C, BadShutdownImmediate , arg1);\ + +#endif + + + + /*---------------------------------------------------------- // Decoder Ring for UpdatePriority // [strm][%p] New send priority = %hu diff --git a/src/generated/linux/stream.c.clog.h.lttng.h b/src/generated/linux/stream.c.clog.h.lttng.h index 15ec36db60..c4efa6e0b4 100644 --- a/src/generated/linux/stream.c.clog.h.lttng.h +++ b/src/generated/linux/stream.c.clog.h.lttng.h @@ -39,6 +39,25 @@ TRACEPOINT_EVENT(CLOG_STREAM_C, EventSilentDiscard, +/*---------------------------------------------------------- +// Decoder Ring for BadShutdownImmediate +// [strm][%p] App tried ditching this stream but it still has stuff to do. +// QuicTraceLogStreamWarning( + BadShutdownImmediate, + Stream, + "App tried ditching this stream but it still has stuff to do."); +// arg1 = arg1 = Stream = arg1 +----------------------------------------------------------*/ +TRACEPOINT_EVENT(CLOG_STREAM_C, BadShutdownImmediate, + TP_ARGS( + const void *, arg1), + TP_FIELDS( + ctf_integer_hex(uint64_t, arg1, arg1) + ) +) + + + /*---------------------------------------------------------- // Decoder Ring for UpdatePriority // [strm][%p] New send priority = %hu diff --git a/src/manifest/clog.sidecar b/src/manifest/clog.sidecar index 60257cce39..acfea6ed48 100644 --- a/src/manifest/clog.sidecar +++ b/src/manifest/clog.sidecar @@ -219,6 +219,18 @@ ], "macroName": "QuicTraceLogConnInfo" }, + "BadShutdownImmediate": { + "ModuleProperites": {}, + "TraceString": "[strm][%p] App tried ditching this stream but it still has stuff to do.", + "UniqueId": "BadShutdownImmediate", + "splitArgs": [ + { + "DefinationEncoding": "p", + "MacroVariableName": "arg1" + } + ], + "macroName": "QuicTraceLogStreamWarning" + }, "BindingCleanup": { "ModuleProperites": {}, "TraceString": "[bind][%p] Cleaning up", @@ -13127,6 +13139,11 @@ "TraceID": "ApplySettings", "EncodingString": "[conn][%p] Applying new settings" }, + { + "UniquenessHash": "abf37194-1390-d9bc-6ee7-88c908a22b58", + "TraceID": "BadShutdownImmediate", + "EncodingString": "[strm][%p] App tried ditching this stream but it still has stuff to do." + }, { "UniquenessHash": "5d83e63e-7ce5-0102-8dd2-cbcf5946da2e", "TraceID": "BindingCleanup", From c3ebef982417e0aad5d5beeab5ee1c8bacf4c017 Mon Sep 17 00:00:00 2001 From: Jack He Date: Tue, 5 Sep 2023 12:08:28 -0700 Subject: [PATCH 061/123] integrate numiterations to test.ps1 script --- scripts/iter_command.ps1 | 34 ---------------------------------- scripts/test.ps1 | 32 ++++++++++++++++++++++++++------ 2 files changed, 26 insertions(+), 40 deletions(-) delete mode 100644 scripts/iter_command.ps1 diff --git a/scripts/iter_command.ps1 b/scripts/iter_command.ps1 deleted file mode 100644 index 51bbf3fb55..0000000000 --- a/scripts/iter_command.ps1 +++ /dev/null @@ -1,34 +0,0 @@ - -# For local unit testing, often certain bugs only appear due to a specific ordering of events in the network. -# To catch those edge cases, lots of iterations are required. Manually doing them is tiresome. -# This script automates the process of finding those bugs. -# Additionally, running this script with large NumIterations gives confidence. - -# Example Usage: -# .\scripts\iter_command.ps1 -commandToRun "./scripts/test.ps1 -Filter *StreamReliable* -LogProfile Full.Light" -numIterations 100 - - -param ( - [string]$commandToRun, - [int]$numIterations -) - -if ($commandToRun -eq $null) { - Write-Host "Error: 'commandToRun' parameter cannot be null." - exit -} - -if ($numIterations -eq $null) { - Write-Host "Error: 'commandToRun' parameter cannot be null." - exit -} - -if ($numIterations -le 0) { - Write-Host "Error: 'numIterations' parameter must be greater than 0." - exit -} - -for ($i = 1; $i -le $numIterations; $i++) { - Invoke-Expression $commandToRun - Write-Host "-------------------------------------------" -} diff --git a/scripts/test.ps1 b/scripts/test.ps1 index c0d23f56f7..9a2f278ea8 100644 --- a/scripts/test.ps1 +++ b/scripts/test.ps1 @@ -67,6 +67,9 @@ This script runs the MsQuic tests. .Parameter DuoNic Uses DuoNic instead of loopback (DuoNic must already be installed via 'prepare-machine.ps1 -InstallDuoNic'). +.Parameter NumIterations + Number of times to run this particular command. Catches tricky edge cases due to random nature of networks. + .EXAMPLE test.ps1 @@ -85,6 +88,8 @@ This script runs the MsQuic tests. .EXAMPLE test.ps1 -LogProfile Full.Verbose -Compress +.EXAMPLE + test.ps1 -Filter ParameterValidation* -NumIterations 10 #> param ( @@ -172,7 +177,10 @@ param ( [switch]$UseQtip = $false, [Parameter(Mandatory = $false)] - [string]$OsRunner = "" + [string]$OsRunner = "", + + [Parameter(Mandatory = $false)] + [int]$NumIterations = 0 ) Set-StrictMode -Version 'Latest' @@ -344,12 +352,24 @@ if (![string]::IsNullOrWhiteSpace($ExtraArtifactDir)) { $TestArguments += " -ExtraArtifactDir $ExtraArtifactDir" } -# Run the script. -if (!$Kernel -and !$SkipUnitTests) { - Invoke-Expression ($RunTest + " -Path $MsQuicPlatTest " + $TestArguments) - Invoke-Expression ($RunTest + " -Path $MsQuicCoreTest " + $TestArguments) +if ($NumIterations -gt 1) { + for ($iteration = 1; $iteration -le $NumIterations; $iteration++) { + Write-Host "------- Iteration $iteration -------" + + if (!$Kernel -and !$SkipUnitTests) { + Invoke-Expression ($RunTest + " -Path $MsQuicPlatTest " + $TestArguments) + Invoke-Expression ($RunTest + " -Path $MsQuicCoreTest " + $TestArguments) + } + Invoke-Expression ($RunTest + " -Path $MsQuicTest " + $TestArguments) + } +} else { + # Run the script. + if (!$Kernel -and !$SkipUnitTests) { + Invoke-Expression ($RunTest + " -Path $MsQuicPlatTest " + $TestArguments) + Invoke-Expression ($RunTest + " -Path $MsQuicCoreTest " + $TestArguments) + } + Invoke-Expression ($RunTest + " -Path $MsQuicTest " + $TestArguments) } -Invoke-Expression ($RunTest + " -Path $MsQuicTest " + $TestArguments) if ($CodeCoverage) { # Merge code coverage results From 9abc6cdff5ce89b549f62a01a892073cf3960c38 Mon Sep 17 00:00:00 2001 From: "Jack He (Github)" Date: Fri, 8 Sep 2023 11:08:23 -0700 Subject: [PATCH 062/123] Update src/test/lib/DataTest.cpp Co-authored-by: Nick Banks --- src/test/lib/DataTest.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/test/lib/DataTest.cpp b/src/test/lib/DataTest.cpp index e04498e71e..f9e146c1ee 100644 --- a/src/test/lib/DataTest.cpp +++ b/src/test/lib/DataTest.cpp @@ -3319,7 +3319,7 @@ QuicTestStreamReliableResetMultipleSends( } return QUIC_STATUS_SUCCESS; } -}; + }; MsQuicRegistration Registration(true); TEST_TRUE(Registration.IsValid()); From b76e7825efd409df417f7a1e00d83cc8848ef24b Mon Sep 17 00:00:00 2001 From: "Jack He (Github)" Date: Fri, 8 Sep 2023 11:08:33 -0700 Subject: [PATCH 063/123] Update src/test/lib/DataTest.cpp Co-authored-by: Nick Banks --- src/test/lib/DataTest.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/test/lib/DataTest.cpp b/src/test/lib/DataTest.cpp index f9e146c1ee..98a9c2a05c 100644 --- a/src/test/lib/DataTest.cpp +++ b/src/test/lib/DataTest.cpp @@ -3284,7 +3284,8 @@ QuicTestStreamReliableReset( void QuicTestStreamReliableResetMultipleSends( -) { + ) +{ struct StreamReliableReset { CxPlatEvent ClientStreamShutdownComplete; From 08ea49ed947010390b5815e30f00f0316bf534d1 Mon Sep 17 00:00:00 2001 From: "Jack He (Github)" Date: Fri, 8 Sep 2023 11:08:39 -0700 Subject: [PATCH 064/123] Update src/test/lib/DataTest.cpp Co-authored-by: Nick Banks --- src/test/lib/DataTest.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/test/lib/DataTest.cpp b/src/test/lib/DataTest.cpp index 98a9c2a05c..84a5660a3c 100644 --- a/src/test/lib/DataTest.cpp +++ b/src/test/lib/DataTest.cpp @@ -3218,7 +3218,7 @@ QuicTestStreamReliableReset( } return QUIC_STATUS_SUCCESS; } -}; + }; MsQuicRegistration Registration(true); TEST_TRUE(Registration.IsValid()); From fc58da6bc4f4b2641d2a30c4209abd5257c4b937 Mon Sep 17 00:00:00 2001 From: "Jack He (Github)" Date: Fri, 8 Sep 2023 11:08:49 -0700 Subject: [PATCH 065/123] Update src/test/lib/DataTest.cpp Co-authored-by: Nick Banks --- src/test/lib/DataTest.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/test/lib/DataTest.cpp b/src/test/lib/DataTest.cpp index 84a5660a3c..c5a2c2c52a 100644 --- a/src/test/lib/DataTest.cpp +++ b/src/test/lib/DataTest.cpp @@ -3184,7 +3184,7 @@ QuicTestStreamReliableReset( #define BUFFER_SIZE 10000 #define RELIABLE_SIZE 5000 - struct StreamReliableReset { + struct StreamReliableReset { CxPlatEvent ClientStreamShutdownComplete; CxPlatEvent ServerStreamShutdownComplete; From 229c83518507c0e8d65acabb1e7fa89b929d5b2d Mon Sep 17 00:00:00 2001 From: "Jack He (Github)" Date: Fri, 8 Sep 2023 11:09:02 -0700 Subject: [PATCH 066/123] Update src/test/lib/DataTest.cpp Co-authored-by: Nick Banks --- src/test/lib/DataTest.cpp | 3 --- 1 file changed, 3 deletions(-) diff --git a/src/test/lib/DataTest.cpp b/src/test/lib/DataTest.cpp index c5a2c2c52a..827aef088b 100644 --- a/src/test/lib/DataTest.cpp +++ b/src/test/lib/DataTest.cpp @@ -3279,9 +3279,6 @@ QuicTestStreamReliableReset( Stream.SetReliableOffset(1)); } } - - - void QuicTestStreamReliableResetMultipleSends( ) From f59d2134d0704ecd4c0a788aa01a5e00d7e6b8c7 Mon Sep 17 00:00:00 2001 From: Jack He Date: Fri, 8 Sep 2023 11:13:01 -0700 Subject: [PATCH 067/123] simiplify logic in test.ps1 script --- scripts/test.ps1 | 13 +++---------- 1 file changed, 3 insertions(+), 10 deletions(-) diff --git a/scripts/test.ps1 b/scripts/test.ps1 index 9a2f278ea8..46c0a4e13d 100644 --- a/scripts/test.ps1 +++ b/scripts/test.ps1 @@ -180,7 +180,7 @@ param ( [string]$OsRunner = "", [Parameter(Mandatory = $false)] - [int]$NumIterations = 0 + [int]$NumIterations = 1 ) Set-StrictMode -Version 'Latest' @@ -352,17 +352,10 @@ if (![string]::IsNullOrWhiteSpace($ExtraArtifactDir)) { $TestArguments += " -ExtraArtifactDir $ExtraArtifactDir" } -if ($NumIterations -gt 1) { - for ($iteration = 1; $iteration -le $NumIterations; $iteration++) { +for ($iteration = 1; $iteration -le $NumIterations; $iteration++) { + if ($NumIterations -gt 1) { Write-Host "------- Iteration $iteration -------" - - if (!$Kernel -and !$SkipUnitTests) { - Invoke-Expression ($RunTest + " -Path $MsQuicPlatTest " + $TestArguments) - Invoke-Expression ($RunTest + " -Path $MsQuicCoreTest " + $TestArguments) - } - Invoke-Expression ($RunTest + " -Path $MsQuicTest " + $TestArguments) } -} else { # Run the script. if (!$Kernel -and !$SkipUnitTests) { Invoke-Expression ($RunTest + " -Path $MsQuicPlatTest " + $TestArguments) From da4df370c6a9b276b6809837f3b1f06af948eae1 Mon Sep 17 00:00:00 2001 From: Jack He Date: Fri, 8 Sep 2023 13:40:12 -0700 Subject: [PATCH 068/123] add stub for support for multiple reliable sends --- src/core/stream.c | 25 ++++++++++++++++++++++++- 1 file changed, 24 insertions(+), 1 deletion(-) diff --git a/src/core/stream.c b/src/core/stream.c index 49e2af8133..43fcb31964 100644 --- a/src/core/stream.c +++ b/src/core/stream.c @@ -685,7 +685,30 @@ QuicStreamParamSet( break; } - Stream->ReliableOffsetSend = *(uint64_t*)Buffer; + if (!Stream->Flags.LocalCloseResetReliable) { + // + // We haven't called shutdown reliable yet. App can set ReliableOffsetSend to be whatever. + // + Stream->ReliableOffsetSend = *(uint64_t*)Buffer; + } else if (*(uint64_t*)Buffer < Stream->ReliableOffsetSend) { + // + // TODO - Determine if we need to support this feature in future iterations. + // + // We have previously called shutdown reliable. + // Now we are loosening the conditions of the ReliableReset, + // but we have already sent the peer a stale frame, we must retransmit + // this new frame, and update the metadata. + // + QuicTraceLogStreamInfo( + MultipleReliableResetSendNotSupported, + Stream, + "Multiple RELIABLE_RESET frames sending not supported."); + Status = QUIC_STATUS_INVALID_STATE; + break; + } else { + Status = QUIC_STATUS_INVALID_STATE; + break; + } QuicTraceLogStreamInfo( ReliableSendOffsetSet, From 6bbebbfa7a69314950fc8d091b5d9f5c8051fb30 Mon Sep 17 00:00:00 2001 From: "Jack He (Github)" Date: Fri, 8 Sep 2023 13:46:31 -0700 Subject: [PATCH 069/123] Update src/core/stream_send.c Co-authored-by: Nick Banks --- src/core/stream_send.c | 1 + 1 file changed, 1 insertion(+) diff --git a/src/core/stream_send.c b/src/core/stream_send.c index 8705ba21cb..dec6b386ac 100644 --- a/src/core/stream_send.c +++ b/src/core/stream_send.c @@ -1212,6 +1212,7 @@ QuicStreamOnLoss( // // Ignore any STREAM frame packet loss if we aborted reliably and // received acks for enough data. + // return FALSE; } From c0e93b9b0b04f63a435f545b3043786889b6d7b6 Mon Sep 17 00:00:00 2001 From: "Jack He (Github)" Date: Fri, 8 Sep 2023 13:46:53 -0700 Subject: [PATCH 070/123] Update src/core/stream_send.c Co-authored-by: Nick Banks --- src/core/stream_send.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/core/stream_send.c b/src/core/stream_send.c index dec6b386ac..c820a67d2e 100644 --- a/src/core/stream_send.c +++ b/src/core/stream_send.c @@ -1559,7 +1559,8 @@ _IRQL_requires_max_(PASSIVE_LEVEL) void QuicStreamCleanupReliableReset( _In_ QUIC_STREAM* Stream -) { + ) +{ // // Cleanup. Cancels all send requests with offsets after ReliableOffsetSend. // Assume this function gets called only when we're about to close the SEND From 802f170c965c133d44aed60a3f34db22da8b7dac Mon Sep 17 00:00:00 2001 From: "Jack He (Github)" Date: Fri, 8 Sep 2023 13:49:19 -0700 Subject: [PATCH 071/123] Update src/core/stream_send.c Co-authored-by: Nick Banks --- src/core/stream_send.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/core/stream_send.c b/src/core/stream_send.c index c820a67d2e..d9b83ec484 100644 --- a/src/core/stream_send.c +++ b/src/core/stream_send.c @@ -1608,7 +1608,8 @@ _IRQL_requires_max_(PASSIVE_LEVEL) void QuicStreamOnResetReliableAck( _In_ QUIC_STREAM* Stream -) { + ) +{ Stream->Flags.LocalCloseResetReliableAcked = TRUE; QuicTraceLogStreamVerbose( ResetReliableAck, From 641a22a2b1f52f7be7c2b8f26d5bee527b11011a Mon Sep 17 00:00:00 2001 From: Jack He Date: Fri, 8 Sep 2023 13:57:15 -0700 Subject: [PATCH 072/123] update logging to include trace events --- src/core/stream_recv.c | 10 ++++++++++ src/core/stream_send.c | 10 ++++++++++ src/generated/linux/stream.c.clog.h | 18 ++++++++++++++++++ src/generated/linux/stream.c.clog.h.lttng.h | 19 +++++++++++++++++++ src/manifest/clog.sidecar | 17 +++++++++++++++++ 5 files changed, 74 insertions(+) diff --git a/src/core/stream_recv.c b/src/core/stream_recv.c index 78659363c9..14aa78dee0 100644 --- a/src/core/stream_recv.c +++ b/src/core/stream_recv.c @@ -204,6 +204,11 @@ QuicStreamProcessReliableResetFrame( if (Stream->RecvBuffer.BaseOffset >= Stream->RecvMaxLength) { Stream->Flags.LocalCloseAcked = TRUE; Stream->Flags.RemoteCloseAcked = TRUE; + QuicTraceEvent( + StreamRecvState, + "[strm][%p] Recv State: %hhu", + Stream, + QuicStreamRecvGetState(Stream)); QuicTraceLogStreamVerbose( ProcessReliableReset, Stream, @@ -1160,6 +1165,11 @@ QuicStreamReceiveComplete( } else if (Stream->Flags.RemoteCloseResetReliable && Stream->RecvBuffer.BaseOffset >= Stream->RecvMaxLength) { Stream->Flags.LocalCloseAcked = TRUE; Stream->Flags.RemoteCloseAcked = TRUE; + QuicTraceEvent( + StreamRecvState, + "[strm][%p] Recv State: %hhu", + Stream, + QuicStreamRecvGetState(Stream)); QuicTraceLogStreamVerbose( ReliableResetReceiveComplete, Stream, diff --git a/src/core/stream_send.c b/src/core/stream_send.c index d9b83ec484..82f1ef8e66 100644 --- a/src/core/stream_send.c +++ b/src/core/stream_send.c @@ -1527,6 +1527,11 @@ QuicStreamOnAck( if (ReliableResetShutdown) { Stream->Flags.LocalCloseAcked = TRUE; Stream->Flags.RemoteCloseAcked = TRUE; + QuicTraceEvent( + StreamSendState, + "[strm][%p] Send State: %hhu", + Stream, + QuicStreamSendGetState(Stream)); QuicTraceLogStreamVerbose( OnStreamAckReliableReset, Stream, @@ -1619,6 +1624,11 @@ QuicStreamOnResetReliableAck( if (Stream->UnAckedOffset >= Stream->ReliableOffsetSend && !Stream->Flags.LocalCloseAcked) { Stream->Flags.LocalCloseAcked = TRUE; Stream->Flags.RemoteCloseAcked = TRUE; + QuicTraceEvent( + StreamSendState, + "[strm][%p] Send State: %hhu", + Stream, + QuicStreamSendGetState(Stream)); QuicTraceLogStreamVerbose( ResetReliableAckShutDown, Stream, diff --git a/src/generated/linux/stream.c.clog.h b/src/generated/linux/stream.c.clog.h index cdb2cdecf5..0cad30d0c6 100644 --- a/src/generated/linux/stream.c.clog.h +++ b/src/generated/linux/stream.c.clog.h @@ -107,6 +107,24 @@ tracepoint(CLOG_STREAM_C, UpdatePriority , arg1, arg3);\ +/*---------------------------------------------------------- +// Decoder Ring for MultipleReliableResetSendNotSupported +// [strm][%p] Multiple RELIABLE_RESET frames sending not supported. +// QuicTraceLogStreamInfo( + MultipleReliableResetSendNotSupported, + Stream, + "Multiple RELIABLE_RESET frames sending not supported."); +// arg1 = arg1 = Stream = arg1 +----------------------------------------------------------*/ +#ifndef _clog_3_ARGS_TRACE_MultipleReliableResetSendNotSupported +#define _clog_3_ARGS_TRACE_MultipleReliableResetSendNotSupported(uniqueId, arg1, encoded_arg_string)\ +tracepoint(CLOG_STREAM_C, MultipleReliableResetSendNotSupported , arg1);\ + +#endif + + + + /*---------------------------------------------------------- // Decoder Ring for ReliableSendOffsetSet // [strm][%p] Reliable send offset set to %llu diff --git a/src/generated/linux/stream.c.clog.h.lttng.h b/src/generated/linux/stream.c.clog.h.lttng.h index c4efa6e0b4..0434e52fa0 100644 --- a/src/generated/linux/stream.c.clog.h.lttng.h +++ b/src/generated/linux/stream.c.clog.h.lttng.h @@ -81,6 +81,25 @@ TRACEPOINT_EVENT(CLOG_STREAM_C, UpdatePriority, +/*---------------------------------------------------------- +// Decoder Ring for MultipleReliableResetSendNotSupported +// [strm][%p] Multiple RELIABLE_RESET frames sending not supported. +// QuicTraceLogStreamInfo( + MultipleReliableResetSendNotSupported, + Stream, + "Multiple RELIABLE_RESET frames sending not supported."); +// arg1 = arg1 = Stream = arg1 +----------------------------------------------------------*/ +TRACEPOINT_EVENT(CLOG_STREAM_C, MultipleReliableResetSendNotSupported, + TP_ARGS( + const void *, arg1), + TP_FIELDS( + ctf_integer_hex(uint64_t, arg1, arg1) + ) +) + + + /*---------------------------------------------------------- // Decoder Ring for ReliableSendOffsetSet // [strm][%p] Reliable send offset set to %llu diff --git a/src/manifest/clog.sidecar b/src/manifest/clog.sidecar index acfea6ed48..64cb1f112a 100644 --- a/src/manifest/clog.sidecar +++ b/src/manifest/clog.sidecar @@ -7212,6 +7212,18 @@ ], "macroName": "QuicTraceLogConnInfo" }, + "MultipleReliableResetSendNotSupported": { + "ModuleProperites": {}, + "TraceString": "[strm][%p] Multiple RELIABLE_RESET frames sending not supported.", + "UniqueId": "MultipleReliableResetSendNotSupported", + "splitArgs": [ + { + "DefinationEncoding": "p", + "MacroVariableName": "arg1" + } + ], + "macroName": "QuicTraceLogStreamInfo" + }, "NegotiatedDisable1RttEncryption": { "ModuleProperites": {}, "TraceString": "[conn][%p] Negotiated Disable 1-RTT Encryption", @@ -15174,6 +15186,11 @@ "TraceID": "MtuSearching", "EncodingString": "[conn][%p] Path[%hhu] Mtu Discovery Search Packet Sending with MTU %hu" }, + { + "UniquenessHash": "7c8ed181-6e73-0552-43f1-7e00ce4948af", + "TraceID": "MultipleReliableResetSendNotSupported", + "EncodingString": "[strm][%p] Multiple RELIABLE_RESET frames sending not supported." + }, { "UniquenessHash": "270621d6-25e4-9741-4f15-ed4a5b3d4f33", "TraceID": "NegotiatedDisable1RttEncryption", From 275799bf2fa9b598e2bdd8edf60aa87e3cc4d659 Mon Sep 17 00:00:00 2001 From: Jack He Date: Fri, 8 Sep 2023 15:17:36 -0700 Subject: [PATCH 073/123] clean up useless code --- src/core/stream_send.c | 6 ------ 1 file changed, 6 deletions(-) diff --git a/src/core/stream_send.c b/src/core/stream_send.c index 82f1ef8e66..87aab834dd 100644 --- a/src/core/stream_send.c +++ b/src/core/stream_send.c @@ -1573,12 +1573,6 @@ QuicStreamCleanupReliableReset( // while (Stream->SendRequests) { QUIC_SEND_REQUEST* Req = Stream->SendRequests; - // - // Ignore send requests that should have been ACK'd, i.e., < ReliableOffsetSend - // - if (Req->StreamOffset + Req->TotalLength < Stream->ReliableOffsetSend) { - continue; - } Stream->SendRequests = Req->Next; if (Stream->SendRequests == NULL) { Stream->SendRequestsTail = &Stream->SendRequests; From b859f1584615a013eebc02b07233c2de24f726a3 Mon Sep 17 00:00:00 2001 From: Jack He Date: Sat, 9 Sep 2023 16:54:11 -0700 Subject: [PATCH 074/123] update test suite to improve code coverage --- src/test/lib/ApiTest.cpp | 58 +++++++++++++++++++++++++++++---------- src/test/lib/DataTest.cpp | 1 + 2 files changed, 44 insertions(+), 15 deletions(-) diff --git a/src/test/lib/ApiTest.cpp b/src/test/lib/ApiTest.cpp index f5ec063753..43afa43e02 100644 --- a/src/test/lib/ApiTest.cpp +++ b/src/test/lib/ApiTest.cpp @@ -4975,41 +4975,69 @@ void QuicTestStreamParam() // // QUIC_PARAM_STREAM_RELIABLE_OFFSET + // QUIC_PARAM_STREAM_RELIABLE_OFFSET_RECV // { TestScopeLogger LogScope0("QUIC_PARAM_STREAM_RELIABLE_OFFSET"); MsQuicStream Stream(Connection, QUIC_STREAM_OPEN_FLAG_NONE); - uint32_t ReliableSize32 = 1; - uint64_t ReliableSize = 1; + uint32_t BufferSize = 1; // - // SetParam Test Invalid States. + // GetParam Test Invalid States. // { - TestScopeLogger LogScope1("SetParam is not allowed"); + TestScopeLogger LogScope1("GetParam for invalid states"); TEST_QUIC_STATUS( - QUIC_STATUS_INVALID_PARAMETER, - MsQuic->SetParam( + QUIC_STATUS_BUFFER_TOO_SMALL, + MsQuic->GetParam( Stream.Handle, QUIC_PARAM_STREAM_RELIABLE_OFFSET, - sizeof(ReliableSize), + &BufferSize, + NULL)); + BufferSize = 1; + TEST_QUIC_STATUS( + QUIC_STATUS_BUFFER_TOO_SMALL, + MsQuic->GetParam( + Stream.Handle, + QUIC_PARAM_STREAM_RELIABLE_OFFSET_RECV, + &BufferSize, NULL)); + BufferSize = 64; + TEST_QUIC_STATUS( QUIC_STATUS_INVALID_PARAMETER, - MsQuic->SetParam( + MsQuic->GetParam( Stream.Handle, - QUIC_PARAM_STREAM_RELIABLE_OFFSET, - sizeof(ReliableSize32), - &ReliableSize32)); + QUIC_PARAM_STREAM_RELIABLE_OFFSET_RECV, + &BufferSize, + NULL)); + TEST_QUIC_STATUS( + QUIC_STATUS_INVALID_PARAMETER, + MsQuic->GetParam( + Stream.Handle, + QUIC_PARAM_STREAM_RELIABLE_OFFSET_RECV, + &BufferSize, + NULL)); + uint64_t Buffer = 10000; TEST_QUIC_STATUS( - QUIC_STATUS_INVALID_STATE, - MsQuic->SetParam( + QUIC_STATUS_SUCCESS, + MsQuic->GetParam( Stream.Handle, QUIC_PARAM_STREAM_RELIABLE_OFFSET, - sizeof(ReliableSize), - &ReliableSize)); + &BufferSize, + &Buffer)); + TEST_TRUE(Buffer == 0); + Buffer = 10000; + TEST_QUIC_STATUS( + QUIC_STATUS_SUCCESS, + MsQuic->GetParam( + Stream.Handle, + QUIC_PARAM_STREAM_RELIABLE_OFFSET_RECV, + &BufferSize, + &Buffer)); + TEST_TRUE(Buffer == 0); } } } diff --git a/src/test/lib/DataTest.cpp b/src/test/lib/DataTest.cpp index 827aef088b..52d1ed69e2 100644 --- a/src/test/lib/DataTest.cpp +++ b/src/test/lib/DataTest.cpp @@ -3268,6 +3268,7 @@ QuicTestStreamReliableReset( Stream.SetReliableOffset(UINT64_MAX)); TEST_QUIC_SUCCEEDED(Stream.SetReliableOffset(RELIABLE_SIZE)); TEST_QUIC_SUCCEEDED(Stream.Shutdown(0)); // Queues up a shutdown operation. + TEST_QUIC_STATUS(QUIC_STATUS_INVALID_STATE, Stream.SetReliableOffset(RELIABLE_SIZE)); // Should behave similar to QUIC_STREAM_SHUTDOWN_FLAG_GRACEFUL, with some restrictions. TEST_TRUE(Context.ClientStreamShutdownComplete.WaitTimeout(TestWaitTimeout)); TEST_TRUE(Context.ServerStreamShutdownComplete.WaitTimeout(TestWaitTimeout)); From 82825c5c887e9043ca7a10e84fa5f33bf0fc4107 Mon Sep 17 00:00:00 2001 From: Jack He Date: Mon, 11 Sep 2023 13:43:43 -0700 Subject: [PATCH 075/123] add new flag instead of multi-plexing --- src/core/loss_detection.c | 2 +- src/core/send.c | 1 + src/core/send.h | 15 ++++++++------- src/core/stream_send.c | 39 +++++++++++++++++++++++---------------- 4 files changed, 33 insertions(+), 24 deletions(-) diff --git a/src/core/loss_detection.c b/src/core/loss_detection.c index 545a59c0be..204eebd36a 100644 --- a/src/core/loss_detection.c +++ b/src/core/loss_detection.c @@ -716,7 +716,7 @@ QuicLossDetectionRetransmitFrames( QuicSendSetStreamSendFlag( &Connection->Send, Packet->Frames[i].RELIABLE_RESET_STREAM.Stream, - QUIC_STREAM_SEND_FLAG_SEND_ABORT, + QUIC_STREAM_SEND_FLAG_RELIABLE_ABORT, FALSE); break; diff --git a/src/core/send.c b/src/core/send.c index 59c583e225..6f7b42675a 100644 --- a/src/core/send.c +++ b/src/core/send.c @@ -387,6 +387,7 @@ QuicSendSetStreamSendFlag( if (Stream->Flags.LocalCloseAcked) { SendFlags &= ~(QUIC_STREAM_SEND_FLAG_SEND_ABORT | + QUIC_STREAM_SEND_FLAG_RELIABLE_ABORT | QUIC_STREAM_SEND_FLAG_DATA_BLOCKED | QUIC_STREAM_SEND_FLAG_DATA | QUIC_STREAM_SEND_FLAG_OPEN | diff --git a/src/core/send.h b/src/core/send.h index 24ea97761a..1568fee19a 100644 --- a/src/core/send.h +++ b/src/core/send.h @@ -195,13 +195,14 @@ QuicPacketTypeToEncryptLevelV2( // stream. The order reflects the order the data is framed into a packet. // -#define QUIC_STREAM_SEND_FLAG_DATA_BLOCKED 0x0001U -#define QUIC_STREAM_SEND_FLAG_MAX_DATA 0x0002U -#define QUIC_STREAM_SEND_FLAG_SEND_ABORT 0x0004U -#define QUIC_STREAM_SEND_FLAG_RECV_ABORT 0x0008U -#define QUIC_STREAM_SEND_FLAG_DATA 0x0010U -#define QUIC_STREAM_SEND_FLAG_OPEN 0x0020U -#define QUIC_STREAM_SEND_FLAG_FIN 0x0040U +#define QUIC_STREAM_SEND_FLAG_DATA_BLOCKED 0x0001U +#define QUIC_STREAM_SEND_FLAG_MAX_DATA 0x0002U +#define QUIC_STREAM_SEND_FLAG_SEND_ABORT 0x0004U +#define QUIC_STREAM_SEND_FLAG_RECV_ABORT 0x0008U +#define QUIC_STREAM_SEND_FLAG_DATA 0x0010U +#define QUIC_STREAM_SEND_FLAG_OPEN 0x0020U +#define QUIC_STREAM_SEND_FLAG_FIN 0x0040U +#define QUIC_STREAM_SEND_FLAG_RELIABLE_ABORT 0x0080U #define QUIC_STREAM_SEND_FLAGS_ALL 0xFFFFU diff --git a/src/core/stream_send.c b/src/core/stream_send.c index 87aab834dd..165bca3a2d 100644 --- a/src/core/stream_send.c +++ b/src/core/stream_send.c @@ -233,6 +233,7 @@ QuicStreamSendShutdown( &Stream->Connection->Send, Stream, QUIC_STREAM_SEND_FLAG_DATA_BLOCKED | + QUIC_STREAM_SEND_FLAG_RELIABLE_ABORT | QUIC_STREAM_SEND_FLAG_DATA | QUIC_STREAM_SEND_FLAG_OPEN | QUIC_STREAM_SEND_FLAG_FIN); @@ -253,7 +254,7 @@ QuicStreamSendShutdown( QuicSendSetStreamSendFlag( &Stream->Connection->Send, Stream, - QUIC_STREAM_SEND_FLAG_SEND_ABORT, + QUIC_STREAM_SEND_FLAG_RELIABLE_ABORT, FALSE); } @@ -1089,28 +1090,34 @@ QuicStreamSendWrite( } if (Stream->SendFlags & QUIC_STREAM_SEND_FLAG_SEND_ABORT) { - QUIC_FRAME_TYPE FrameType; - BOOLEAN CanEncodeFrame; - if (Stream->ReliableOffsetSend > 0) { - QUIC_RELIABLE_RESET_STREAM_EX Frame = { Stream->ID, Stream->SendShutdownErrorCode, Stream->MaxSentLength, Stream->ReliableOffsetSend }; - CanEncodeFrame = QuicReliableResetFrameEncode( + QUIC_RESET_STREAM_EX Frame = { Stream->ID, Stream->SendShutdownErrorCode, Stream->MaxSentLength }; + + if (QuicResetStreamFrameEncode( &Frame, &Builder->DatagramLength, AvailableBufferLength, - Builder->Datagram->Buffer); - FrameType = QUIC_FRAME_RELIABLE_RESET_STREAM; + Builder->Datagram->Buffer)) { + + Stream->SendFlags &= ~QUIC_STREAM_SEND_FLAG_SEND_ABORT; + if (QuicPacketBuilderAddStreamFrame(Builder, Stream, QUIC_FRAME_RESET_STREAM)) { + return TRUE; + } } else { - QUIC_RESET_STREAM_EX Frame = { Stream->ID, Stream->SendShutdownErrorCode, Stream->MaxSentLength }; - CanEncodeFrame = QuicResetStreamFrameEncode( + RanOutOfRoom = TRUE; + } + } + + if (Stream->SendFlags & QUIC_STREAM_SEND_FLAG_RELIABLE_ABORT) { + QUIC_RELIABLE_RESET_STREAM_EX Frame = { Stream->ID, Stream->SendShutdownErrorCode, Stream->MaxSentLength, Stream->ReliableOffsetSend }; + + if (QuicReliableResetFrameEncode( &Frame, &Builder->DatagramLength, AvailableBufferLength, - Builder->Datagram->Buffer); - FrameType = QUIC_FRAME_RESET_STREAM; - } - if (CanEncodeFrame) { - Stream->SendFlags &= ~QUIC_STREAM_SEND_FLAG_SEND_ABORT; - if (QuicPacketBuilderAddStreamFrame(Builder, Stream, FrameType)) { + Builder->Datagram->Buffer)) { + + Stream->SendFlags &= ~QUIC_STREAM_SEND_FLAG_RELIABLE_ABORT; + if (QuicPacketBuilderAddStreamFrame(Builder, Stream, QUIC_FRAME_RELIABLE_RESET_STREAM)) { return TRUE; } } else { From c56ef1347df7bf5e21c6ebb48ec325527a70d55c Mon Sep 17 00:00:00 2001 From: Jack He Date: Thu, 14 Sep 2023 18:39:44 -0700 Subject: [PATCH 076/123] send order and number of events completed matches up --- src/test/lib/DataTest.cpp | 86 ++++++++++++++++++--------------------- 1 file changed, 39 insertions(+), 47 deletions(-) diff --git a/src/test/lib/DataTest.cpp b/src/test/lib/DataTest.cpp index 52d1ed69e2..234ffd50f6 100644 --- a/src/test/lib/DataTest.cpp +++ b/src/test/lib/DataTest.cpp @@ -3177,18 +3177,24 @@ QuicTestConnectAndIdleForDestCidChange( } } -void -QuicTestStreamReliableReset( - ) -{ - #define BUFFER_SIZE 10000 - #define RELIABLE_SIZE 5000 +#define BUFFER_SIZE 10000 +#define RELIABLE_SIZE 5000 +#define BUFFER_SIZE_MULTI_SENDS 10000 +#define RELIABLE_SIZE_MULTI_SENDS 20000 - struct StreamReliableReset { + +// +// This Context Struct is a useful helper for the StreamReliableReset test suite. +// It keeps track of the order of absolute offsets of all the send requests received, and the total number of bytes received. +// If everything works, SendCompleteOrder MUST be monotonically increasing. +// +struct StreamReliableReset { CxPlatEvent ClientStreamShutdownComplete; CxPlatEvent ServerStreamShutdownComplete; uint64_t ReceivedBufferSize; + std::vector SendCompleteOrder; + static QUIC_STATUS ClientStreamCallback(_In_ MsQuicStream*, _In_opt_ void* ClientContext, _Inout_ QUIC_STREAM_EVENT* Event) { auto TestContext = (StreamReliableReset*)ClientContext; @@ -3202,6 +3208,7 @@ QuicTestStreamReliableReset( auto TestContext = (StreamReliableReset*)ServerContext; if (Event->Type == QUIC_STREAM_EVENT_RECEIVE) { TestContext->ReceivedBufferSize += Event->RECEIVE.TotalBufferLength; + TestContext->SendCompleteOrder.push_back(Event->RECEIVE.AbsoluteOffset); } if (Event->Type == QUIC_STREAM_EVENT_PEER_SEND_SHUTDOWN) { Stream->Shutdown(QUIC_STREAM_SHUTDOWN_FLAG_ABORT_SEND); @@ -3218,7 +3225,13 @@ QuicTestStreamReliableReset( } return QUIC_STATUS_SUCCESS; } - }; +}; + + +void +QuicTestStreamReliableReset( + ) +{ MsQuicRegistration Registration(true); TEST_TRUE(Registration.IsValid()); @@ -3238,6 +3251,7 @@ QuicTestStreamReliableReset( QUIC_BUFFER SendBuffer { sizeof(SendDataBuffer), SendDataBuffer }; Context.ReceivedBufferSize = 0; + Context.SendCompleteOrder = {}; MsQuicAutoAcceptListener Listener(Registration, ServerConfiguration, StreamReliableReset::ConnCallback, &Context); TEST_QUIC_SUCCEEDED(Listener.GetInitStatus()); @@ -3284,42 +3298,6 @@ void QuicTestStreamReliableResetMultipleSends( ) { - struct StreamReliableReset { - - CxPlatEvent ClientStreamShutdownComplete; - CxPlatEvent ServerStreamShutdownComplete; - uint64_t ReceivedBufferSize; - - static QUIC_STATUS ClientStreamCallback(_In_ MsQuicStream*, _In_opt_ void* ClientContext, _Inout_ QUIC_STREAM_EVENT* Event) { - auto TestContext = (StreamReliableReset*)ClientContext; - if (Event->Type == QUIC_STREAM_EVENT_SHUTDOWN_COMPLETE) { - TestContext->ClientStreamShutdownComplete.Set(); - } - return QUIC_STATUS_SUCCESS; - } - - static QUIC_STATUS ServerStreamCallback(_In_ MsQuicStream* Stream, _In_opt_ void* ServerContext, _Inout_ QUIC_STREAM_EVENT* Event) { - auto TestContext = (StreamReliableReset*)ServerContext; - if (Event->Type == QUIC_STREAM_EVENT_RECEIVE) { - TestContext->ReceivedBufferSize += Event->RECEIVE.TotalBufferLength; - } - if (Event->Type == QUIC_STREAM_EVENT_PEER_SEND_SHUTDOWN) { - Stream->Shutdown(QUIC_STREAM_SHUTDOWN_FLAG_ABORT_SEND); - } - if (Event->Type == QUIC_STREAM_EVENT_SHUTDOWN_COMPLETE) { - TestContext->ServerStreamShutdownComplete.Set(); - } - return QUIC_STATUS_SUCCESS; - } - - static QUIC_STATUS ConnCallback(_In_ MsQuicConnection*, _In_opt_ void* Context, _Inout_ QUIC_CONNECTION_EVENT* Event) { - if (Event->Type == QUIC_CONNECTION_EVENT_PEER_STREAM_STARTED) { - new(std::nothrow) MsQuicStream(Event->PEER_STREAM_STARTED.Stream, CleanUpAutoDelete, ServerStreamCallback, Context); - } - return QUIC_STATUS_SUCCESS; - } - }; - MsQuicRegistration Registration(true); TEST_TRUE(Registration.IsValid()); @@ -3334,10 +3312,11 @@ QuicTestStreamReliableResetMultipleSends( TEST_QUIC_SUCCEEDED(ClientConfiguration.GetInitStatus()); StreamReliableReset Context; - uint8_t SendDataBuffer[BUFFER_SIZE]; + uint8_t SendDataBuffer[BUFFER_SIZE_MULTI_SENDS]; QUIC_BUFFER SendBuffer { sizeof(SendDataBuffer), SendDataBuffer }; Context.ReceivedBufferSize = 0; + Context.SendCompleteOrder = {}; MsQuicAutoAcceptListener Listener(Registration, ServerConfiguration, StreamReliableReset::ConnCallback, &Context); TEST_QUIC_SUCCEEDED(Listener.GetInitStatus()); @@ -3361,10 +3340,23 @@ QuicTestStreamReliableResetMultipleSends( TEST_QUIC_SUCCEEDED(Stream.Send(&SendBuffer, 1, QUIC_SEND_FLAG_DELAY_SEND, &Context)); TEST_QUIC_SUCCEEDED(Stream.Send(&SendBuffer, 1, QUIC_SEND_FLAG_DELAY_SEND, &Context)); TEST_QUIC_SUCCEEDED(Stream.Send(&SendBuffer, 1, QUIC_SEND_FLAG_DELAY_SEND, &Context)); - TEST_QUIC_SUCCEEDED(Stream.SetReliableOffset(RELIABLE_SIZE)); + TEST_QUIC_SUCCEEDED(Stream.Send(&SendBuffer, 1, QUIC_SEND_FLAG_DELAY_SEND, &Context)); + TEST_QUIC_SUCCEEDED(Stream.Send(&SendBuffer, 1, QUIC_SEND_FLAG_DELAY_SEND, &Context)); + TEST_QUIC_SUCCEEDED(Stream.SetReliableOffset(RELIABLE_SIZE_MULTI_SENDS)); TEST_QUIC_SUCCEEDED(Stream.Shutdown(0)); // Queues up a shutdown operation. // Should behave similar to QUIC_STREAM_SHUTDOWN_FLAG_GRACEFUL, with some restrictions. TEST_TRUE(Context.ClientStreamShutdownComplete.WaitTimeout(TestWaitTimeout)); TEST_TRUE(Context.ServerStreamShutdownComplete.WaitTimeout(TestWaitTimeout)); - TEST_TRUE(Context.ReceivedBufferSize >= RELIABLE_SIZE); + TEST_TRUE(Context.ReceivedBufferSize >= RELIABLE_SIZE_MULTI_SENDS); + + if (Context.SendCompleteOrder.size() < 2) { + TEST_FAILURE("We expected at least 2 successful sends, got %llu", (unsigned long long)Context.SendCompleteOrder.size()); + } + + for (int i = 1; i < Context.SendCompleteOrder.size(); ++i) { + if (Context.SendCompleteOrder[i - 1] > Context.SendCompleteOrder[i]) { + TEST_FAILURE("We expected send requests to be completed in order. Got an absolute offset of %llu after %llu", + (unsigned long long)Context.SendCompleteOrder[i], (unsigned long long)Context.SendCompleteOrder[i - 1]); + } + } } From ee56e9a767c596a3c9a3e8d40c450d64f46fe50e Mon Sep 17 00:00:00 2001 From: "Jack He (Github)" Date: Thu, 14 Sep 2023 18:48:51 -0700 Subject: [PATCH 077/123] Update src/test/lib/DataTest.cpp Co-authored-by: Nick Banks --- src/test/lib/DataTest.cpp | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/src/test/lib/DataTest.cpp b/src/test/lib/DataTest.cpp index 234ffd50f6..6473257e59 100644 --- a/src/test/lib/DataTest.cpp +++ b/src/test/lib/DataTest.cpp @@ -3289,9 +3289,7 @@ QuicTestStreamReliableReset( TEST_TRUE(Context.ReceivedBufferSize >= RELIABLE_SIZE); // We shouldn't be able to change ReliableSize now that the stream has already been reset. - TEST_QUIC_STATUS( - QUIC_STATUS_INVALID_STATE, - Stream.SetReliableOffset(1)); + TEST_QUIC_STATUS(QUIC_STATUS_INVALID_STATE, Stream.SetReliableOffset(1)); } } void From ff54e2ed4c922e0c84a6b34803ea6cc27c485208 Mon Sep 17 00:00:00 2001 From: "Jack He (Github)" Date: Thu, 14 Sep 2023 18:49:18 -0700 Subject: [PATCH 078/123] Update src/core/stream_recv.c Co-authored-by: Nick Banks --- src/core/stream_recv.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/core/stream_recv.c b/src/core/stream_recv.c index 14aa78dee0..21572f32ed 100644 --- a/src/core/stream_recv.c +++ b/src/core/stream_recv.c @@ -458,8 +458,8 @@ QuicStreamProcessStreamFrame( if (Stream->Flags.RemoteCloseResetReliable) { if (Stream->RecvBuffer.BaseOffset >= Stream->RecvMaxLength) { // - // We've aborted reliably, and... - // Frame goes past reliable offset, we can just discard to save space and compute. + // We've aborted reliably, but the stream goes past reliable offset, we can just + // ignore it. // Status = QUIC_STATUS_SUCCESS; goto Error; From 181d2101b59466cf98f21c9badafde59cffc1446 Mon Sep 17 00:00:00 2001 From: "Jack He (Github)" Date: Thu, 14 Sep 2023 18:49:51 -0700 Subject: [PATCH 079/123] Update src/core/stream_recv.c Co-authored-by: Nick Banks --- src/core/stream_recv.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/core/stream_recv.c b/src/core/stream_recv.c index 21572f32ed..f1bdda9a2f 100644 --- a/src/core/stream_recv.c +++ b/src/core/stream_recv.c @@ -181,7 +181,7 @@ QuicStreamProcessReliableResetFrame( QuicTraceLogStreamWarning( ReliableResetNotNegotiated, Stream, - "Tried to use ReliableReset without negotiation."); + "Received ReliableReset without negotiation."); QuicConnTransportError(Stream->Connection, QUIC_ERROR_STREAM_STATE_ERROR); return; } From d438e08de50eb66674d362db94e400b580a440b2 Mon Sep 17 00:00:00 2001 From: "Jack He (Github)" Date: Thu, 14 Sep 2023 18:50:12 -0700 Subject: [PATCH 080/123] Update src/core/stream.c Co-authored-by: Nick Banks --- src/core/stream.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/core/stream.c b/src/core/stream.c index 43fcb31964..b016ff7ce8 100644 --- a/src/core/stream.c +++ b/src/core/stream.c @@ -578,7 +578,7 @@ QuicStreamShutdown( QuicTraceLogStreamWarning( BadShutdownImmediate, Stream, - "App tried ditching this stream but it still has stuff to do."); + "Invalid immediate shutdown request (pending reliable reset)."); QuicConnTransportError(Stream->Connection, QUIC_ERROR_STREAM_STATE_ERROR); return; } From f62d8cb052e340894579a79e5cb2d4bc78f640da Mon Sep 17 00:00:00 2001 From: Jack He Date: Fri, 15 Sep 2023 01:43:30 -0700 Subject: [PATCH 081/123] more tests lol --- src/test/lib/DataTest.cpp | 39 ++++++++++++++++++++++++++++++++------- 1 file changed, 32 insertions(+), 7 deletions(-) diff --git a/src/test/lib/DataTest.cpp b/src/test/lib/DataTest.cpp index 6473257e59..d361d945de 100644 --- a/src/test/lib/DataTest.cpp +++ b/src/test/lib/DataTest.cpp @@ -3184,22 +3184,33 @@ QuicTestConnectAndIdleForDestCidChange( // -// This Context Struct is a useful helper for the StreamReliableReset test suite. +// These Context Structs are useful helpers for the StreamReliableReset test suite. // It keeps track of the order of absolute offsets of all the send requests received, and the total number of bytes received. // If everything works, SendCompleteOrder MUST be monotonically increasing. // +struct SendContext { + BOOLEAN Successful; + uint64_t SeqNum; +}; struct StreamReliableReset { CxPlatEvent ClientStreamShutdownComplete; CxPlatEvent ServerStreamShutdownComplete; uint64_t ReceivedBufferSize; std::vector SendCompleteOrder; + uint64_t SequenceNum; static QUIC_STATUS ClientStreamCallback(_In_ MsQuicStream*, _In_opt_ void* ClientContext, _Inout_ QUIC_STREAM_EVENT* Event) { auto TestContext = (StreamReliableReset*)ClientContext; if (Event->Type == QUIC_STREAM_EVENT_SHUTDOWN_COMPLETE) { TestContext->ClientStreamShutdownComplete.Set(); + } + // Get the send context of the Event + if (Event->Type == QUIC_STREAM_EVENT_SEND_COMPLETE) { + auto Context = (SendContext*)Event->SEND_COMPLETE.ClientContext; + Context->Successful = Event->SEND_COMPLETE.Canceled == FALSE; + Context->SeqNum = TestContext->SequenceNum++; } return QUIC_STATUS_SUCCESS; } @@ -3276,7 +3287,8 @@ QuicTestStreamReliableReset( MsQuicStream Stream(Connection, QUIC_STREAM_OPEN_FLAG_NONE, CleanUpManual, StreamReliableReset::ClientStreamCallback, &Context); TEST_QUIC_SUCCEEDED(Stream.GetInitStatus()); TEST_QUIC_SUCCEEDED(Stream.Start()); - TEST_QUIC_SUCCEEDED(Stream.Send(&SendBuffer, 1, QUIC_SEND_FLAG_DELAY_SEND, &Context)); + SendContext send1 = {FALSE, 0}; + TEST_QUIC_SUCCEEDED(Stream.Send(&SendBuffer, 1, QUIC_SEND_FLAG_DELAY_SEND, &send1)); TEST_QUIC_STATUS( QUIC_STATUS_INVALID_STATE, Stream.SetReliableOffset(UINT64_MAX)); @@ -3314,6 +3326,7 @@ QuicTestStreamReliableResetMultipleSends( QUIC_BUFFER SendBuffer { sizeof(SendDataBuffer), SendDataBuffer }; Context.ReceivedBufferSize = 0; + Context.SequenceNum = 0; Context.SendCompleteOrder = {}; MsQuicAutoAcceptListener Listener(Registration, ServerConfiguration, StreamReliableReset::ConnCallback, &Context); @@ -3335,11 +3348,16 @@ QuicTestStreamReliableResetMultipleSends( MsQuicStream Stream(Connection, QUIC_STREAM_OPEN_FLAG_NONE, CleanUpManual, StreamReliableReset::ClientStreamCallback, &Context); TEST_QUIC_SUCCEEDED(Stream.GetInitStatus()); TEST_QUIC_SUCCEEDED(Stream.Start()); - TEST_QUIC_SUCCEEDED(Stream.Send(&SendBuffer, 1, QUIC_SEND_FLAG_DELAY_SEND, &Context)); - TEST_QUIC_SUCCEEDED(Stream.Send(&SendBuffer, 1, QUIC_SEND_FLAG_DELAY_SEND, &Context)); - TEST_QUIC_SUCCEEDED(Stream.Send(&SendBuffer, 1, QUIC_SEND_FLAG_DELAY_SEND, &Context)); - TEST_QUIC_SUCCEEDED(Stream.Send(&SendBuffer, 1, QUIC_SEND_FLAG_DELAY_SEND, &Context)); - TEST_QUIC_SUCCEEDED(Stream.Send(&SendBuffer, 1, QUIC_SEND_FLAG_DELAY_SEND, &Context)); + SendContext send1 = {FALSE, 0}; + SendContext send2 = {FALSE, 0}; + SendContext send3 = {FALSE, 0}; + SendContext send4 = {FALSE, 0}; + SendContext send5 = {FALSE, 0}; + TEST_QUIC_SUCCEEDED(Stream.Send(&SendBuffer, 1, QUIC_SEND_FLAG_DELAY_SEND, &send1)); + TEST_QUIC_SUCCEEDED(Stream.Send(&SendBuffer, 1, QUIC_SEND_FLAG_DELAY_SEND, &send2)); + TEST_QUIC_SUCCEEDED(Stream.Send(&SendBuffer, 1, QUIC_SEND_FLAG_DELAY_SEND, &send3)); + TEST_QUIC_SUCCEEDED(Stream.Send(&SendBuffer, 1, QUIC_SEND_FLAG_DELAY_SEND, &send4)); + TEST_QUIC_SUCCEEDED(Stream.Send(&SendBuffer, 1, QUIC_SEND_FLAG_DELAY_SEND, &send5)); TEST_QUIC_SUCCEEDED(Stream.SetReliableOffset(RELIABLE_SIZE_MULTI_SENDS)); TEST_QUIC_SUCCEEDED(Stream.Shutdown(0)); // Queues up a shutdown operation. // Should behave similar to QUIC_STREAM_SHUTDOWN_FLAG_GRACEFUL, with some restrictions. @@ -3347,6 +3365,13 @@ QuicTestStreamReliableResetMultipleSends( TEST_TRUE(Context.ServerStreamShutdownComplete.WaitTimeout(TestWaitTimeout)); TEST_TRUE(Context.ReceivedBufferSize >= RELIABLE_SIZE_MULTI_SENDS); + TEST_TRUE(send1.Successful); + TEST_TRUE(send2.Successful); + TEST_TRUE(send1.SeqNum < send2.SeqNum); + TEST_TRUE(send2.SeqNum < send3.SeqNum); + TEST_TRUE(send3.SeqNum < send4.SeqNum); + TEST_TRUE(send4.SeqNum < send5.SeqNum); + if (Context.SendCompleteOrder.size() < 2) { TEST_FAILURE("We expected at least 2 successful sends, got %llu", (unsigned long long)Context.SendCompleteOrder.size()); } From 0dbddc9be780b9cc4c730a65bce9f40165aab639 Mon Sep 17 00:00:00 2001 From: Jack He Date: Mon, 18 Sep 2023 11:47:55 -0700 Subject: [PATCH 082/123] do not fail connection if shutdown immediate --- src/core/stream.c | 3 +- src/core/stream_recv.c | 2 +- src/generated/linux/frame.c.clog.h | 76 ++++++++++-------- src/generated/linux/frame.c.clog.h.lttng.h | 77 ++++++++++++------- src/generated/linux/stream.c.clog.h | 14 ++-- src/generated/linux/stream.c.clog.h.lttng.h | 10 +-- src/generated/linux/stream_recv.c.clog.h | 14 ++-- .../linux/stream_recv.c.clog.h.lttng.h | 10 +-- src/manifest/clog.sidecar | 34 ++++++++ 9 files changed, 153 insertions(+), 87 deletions(-) diff --git a/src/core/stream.c b/src/core/stream.c index 28899c5c3d..f86e21b5c9 100644 --- a/src/core/stream.c +++ b/src/core/stream.c @@ -576,10 +576,9 @@ QuicStreamShutdown( // if (Stream->Flags.RemoteCloseResetReliable || Stream->Flags.LocalCloseResetReliable) { QuicTraceLogStreamWarning( - BadShutdownImmediate, + ShutdownImmediatePendingReliableReset, Stream, "Invalid immediate shutdown request (pending reliable reset)."); - QuicConnTransportError(Stream->Connection, QUIC_ERROR_STREAM_STATE_ERROR); return; } QuicStreamIndicateSendShutdownComplete(Stream, FALSE); diff --git a/src/core/stream_recv.c b/src/core/stream_recv.c index cbdb031115..f37b431686 100644 --- a/src/core/stream_recv.c +++ b/src/core/stream_recv.c @@ -179,7 +179,7 @@ QuicStreamProcessReliableResetFrame( // negotiating first. Kill the connection. // QuicTraceLogStreamWarning( - ReliableResetNotNegotiated, + ReliableResetNotNegotiatedError, Stream, "Received ReliableReset without negotiation."); QuicConnTransportError(Stream->Connection, QUIC_ERROR_STREAM_STATE_ERROR); diff --git a/src/generated/linux/frame.c.clog.h b/src/generated/linux/frame.c.clog.h index 648577c21b..99477a4200 100644 --- a/src/generated/linux/frame.c.clog.h +++ b/src/generated/linux/frame.c.clog.h @@ -1226,18 +1226,11 @@ tracepoint(CLOG_FRAME_C, FrameLogImmediateAck , arg2, arg3, arg4);\ /*---------------------------------------------------------- -// Decoder Ring for FrameLogReliableResetStreamInvalid -// [%c][%cX][%llu] RELIABLE_RESET_STREAM [Invalid] -// QuicTraceLogVerbose( - FrameLogReliableResetStreamInvalid, - "[%c][%cX][%llu] RELIABLE_RESET_STREAM [Invalid]", - // Decoder Ring for FrameLogTimestampInvalid // [%c][%cX][%llu] TIMESTAMP [Invalid] // QuicTraceLogVerbose( FrameLogTimestampInvalid, "[%c][%cX][%llu] TIMESTAMP [Invalid]", - PtkConnPre(Connection), PktRxPre(Rx), PacketNumber); @@ -1245,15 +1238,55 @@ tracepoint(CLOG_FRAME_C, FrameLogImmediateAck , arg2, arg3, arg4);\ // arg3 = arg3 = PktRxPre(Rx) = arg3 // arg4 = arg4 = PacketNumber = arg4 ----------------------------------------------------------*/ - -#ifndef _clog_5_ARGS_TRACE_FrameLogReliableResetStreamInvalid -#define _clog_5_ARGS_TRACE_FrameLogReliableResetStreamInvalid(uniqueId, encoded_arg_string, arg2, arg3, arg4)\ -tracepoint(CLOG_FRAME_C, FrameLogReliableResetStreamInvalid , arg2, arg3, arg4);\ - #ifndef _clog_5_ARGS_TRACE_FrameLogTimestampInvalid #define _clog_5_ARGS_TRACE_FrameLogTimestampInvalid(uniqueId, encoded_arg_string, arg2, arg3, arg4)\ tracepoint(CLOG_FRAME_C, FrameLogTimestampInvalid , arg2, arg3, arg4);\ +#endif + + + + +/*---------------------------------------------------------- +// Decoder Ring for FrameLogTimestamp +// [%c][%cX][%llu] TIMESTAMP %llu +// QuicTraceLogVerbose( + FrameLogTimestamp, + "[%c][%cX][%llu] TIMESTAMP %llu", + PtkConnPre(Connection), + PktRxPre(Rx), + PacketNumber, + Frame.Timestamp); +// arg2 = arg2 = PtkConnPre(Connection) = arg2 +// arg3 = arg3 = PktRxPre(Rx) = arg3 +// arg4 = arg4 = PacketNumber = arg4 +// arg5 = arg5 = Frame.Timestamp = arg5 +----------------------------------------------------------*/ +#ifndef _clog_6_ARGS_TRACE_FrameLogTimestamp +#define _clog_6_ARGS_TRACE_FrameLogTimestamp(uniqueId, encoded_arg_string, arg2, arg3, arg4, arg5)\ +tracepoint(CLOG_FRAME_C, FrameLogTimestamp , arg2, arg3, arg4, arg5);\ + +#endif + + + + +/*---------------------------------------------------------- +// Decoder Ring for FrameLogReliableResetStreamInvalid +// [%c][%cX][%llu] RELIABLE_RESET_STREAM [Invalid] +// QuicTraceLogVerbose( + FrameLogReliableResetStreamInvalid, + "[%c][%cX][%llu] RELIABLE_RESET_STREAM [Invalid]", + PtkConnPre(Connection), + PktRxPre(Rx), + PacketNumber); +// arg2 = arg2 = PtkConnPre(Connection) = arg2 +// arg3 = arg3 = PktRxPre(Rx) = arg3 +// arg4 = arg4 = PacketNumber = arg4 +----------------------------------------------------------*/ +#ifndef _clog_5_ARGS_TRACE_FrameLogReliableResetStreamInvalid +#define _clog_5_ARGS_TRACE_FrameLogReliableResetStreamInvalid(uniqueId, encoded_arg_string, arg2, arg3, arg4)\ +tracepoint(CLOG_FRAME_C, FrameLogReliableResetStreamInvalid , arg2, arg3, arg4);\ #endif @@ -1280,30 +1313,11 @@ tracepoint(CLOG_FRAME_C, FrameLogTimestampInvalid , arg2, arg3, arg4);\ // arg6 = arg6 = Frame.ErrorCode = arg6 // arg7 = arg7 = Frame.FinalSize = arg7 // arg8 = arg8 = Frame.ReliableSize = arg8 - -// Decoder Ring for FrameLogTimestamp -// [%c][%cX][%llu] TIMESTAMP %llu -// QuicTraceLogVerbose( - FrameLogTimestamp, - "[%c][%cX][%llu] TIMESTAMP %llu", - PtkConnPre(Connection), - PktRxPre(Rx), - PacketNumber, - Frame.Timestamp); -// arg2 = arg2 = PtkConnPre(Connection) = arg2 -// arg3 = arg3 = PktRxPre(Rx) = arg3 -// arg4 = arg4 = PacketNumber = arg4 -// arg5 = arg5 = Frame.Timestamp = arg5 ----------------------------------------------------------*/ #ifndef _clog_9_ARGS_TRACE_FrameLogReliableResetStream #define _clog_9_ARGS_TRACE_FrameLogReliableResetStream(uniqueId, encoded_arg_string, arg2, arg3, arg4, arg5, arg6, arg7, arg8)\ tracepoint(CLOG_FRAME_C, FrameLogReliableResetStream , arg2, arg3, arg4, arg5, arg6, arg7, arg8);\ -#ifndef _clog_6_ARGS_TRACE_FrameLogTimestamp -#define _clog_6_ARGS_TRACE_FrameLogTimestamp(uniqueId, encoded_arg_string, arg2, arg3, arg4, arg5)\ -tracepoint(CLOG_FRAME_C, FrameLogTimestamp , arg2, arg3, arg4, arg5);\ - - #endif diff --git a/src/generated/linux/frame.c.clog.h.lttng.h b/src/generated/linux/frame.c.clog.h.lttng.h index 315497684c..bbb7dc77f1 100644 --- a/src/generated/linux/frame.c.clog.h.lttng.h +++ b/src/generated/linux/frame.c.clog.h.lttng.h @@ -1552,19 +1552,11 @@ TRACEPOINT_EVENT(CLOG_FRAME_C, FrameLogImmediateAck, /*---------------------------------------------------------- - -// Decoder Ring for FrameLogReliableResetStreamInvalid -// [%c][%cX][%llu] RELIABLE_RESET_STREAM [Invalid] -// QuicTraceLogVerbose( - FrameLogReliableResetStreamInvalid, - "[%c][%cX][%llu] RELIABLE_RESET_STREAM [Invalid]", - // Decoder Ring for FrameLogTimestampInvalid // [%c][%cX][%llu] TIMESTAMP [Invalid] // QuicTraceLogVerbose( FrameLogTimestampInvalid, "[%c][%cX][%llu] TIMESTAMP [Invalid]", - PtkConnPre(Connection), PktRxPre(Rx), PacketNumber); @@ -1572,8 +1564,7 @@ TRACEPOINT_EVENT(CLOG_FRAME_C, FrameLogImmediateAck, // arg3 = arg3 = PktRxPre(Rx) = arg3 // arg4 = arg4 = PacketNumber = arg4 ----------------------------------------------------------*/ - -TRACEPOINT_EVENT(CLOG_FRAME_C, FrameLogReliableResetStreamInvalid, +TRACEPOINT_EVENT(CLOG_FRAME_C, FrameLogTimestampInvalid, TP_ARGS( unsigned char, arg2, unsigned char, arg3, @@ -1585,7 +1576,53 @@ TRACEPOINT_EVENT(CLOG_FRAME_C, FrameLogReliableResetStreamInvalid, ) ) -TRACEPOINT_EVENT(CLOG_FRAME_C, FrameLogTimestampInvalid, + + +/*---------------------------------------------------------- +// Decoder Ring for FrameLogTimestamp +// [%c][%cX][%llu] TIMESTAMP %llu +// QuicTraceLogVerbose( + FrameLogTimestamp, + "[%c][%cX][%llu] TIMESTAMP %llu", + PtkConnPre(Connection), + PktRxPre(Rx), + PacketNumber, + Frame.Timestamp); +// arg2 = arg2 = PtkConnPre(Connection) = arg2 +// arg3 = arg3 = PktRxPre(Rx) = arg3 +// arg4 = arg4 = PacketNumber = arg4 +// arg5 = arg5 = Frame.Timestamp = arg5 +----------------------------------------------------------*/ +TRACEPOINT_EVENT(CLOG_FRAME_C, FrameLogTimestamp, + TP_ARGS( + unsigned char, arg2, + unsigned char, arg3, + unsigned long long, arg4, + unsigned long long, arg5), + TP_FIELDS( + ctf_integer(unsigned char, arg2, arg2) + ctf_integer(unsigned char, arg3, arg3) + ctf_integer(uint64_t, arg4, arg4) + ctf_integer(uint64_t, arg5, arg5) + ) +) + + + +/*---------------------------------------------------------- +// Decoder Ring for FrameLogReliableResetStreamInvalid +// [%c][%cX][%llu] RELIABLE_RESET_STREAM [Invalid] +// QuicTraceLogVerbose( + FrameLogReliableResetStreamInvalid, + "[%c][%cX][%llu] RELIABLE_RESET_STREAM [Invalid]", + PtkConnPre(Connection), + PktRxPre(Rx), + PacketNumber); +// arg2 = arg2 = PtkConnPre(Connection) = arg2 +// arg3 = arg3 = PktRxPre(Rx) = arg3 +// arg4 = arg4 = PacketNumber = arg4 +----------------------------------------------------------*/ +TRACEPOINT_EVENT(CLOG_FRAME_C, FrameLogReliableResetStreamInvalid, TP_ARGS( unsigned char, arg2, unsigned char, arg3, @@ -1621,21 +1658,6 @@ TRACEPOINT_EVENT(CLOG_FRAME_C, FrameLogTimestampInvalid, // arg8 = arg8 = Frame.ReliableSize = arg8 ----------------------------------------------------------*/ TRACEPOINT_EVENT(CLOG_FRAME_C, FrameLogReliableResetStream, -// Decoder Ring for FrameLogTimestamp -// [%c][%cX][%llu] TIMESTAMP %llu -// QuicTraceLogVerbose( - FrameLogTimestamp, - "[%c][%cX][%llu] TIMESTAMP %llu", - PtkConnPre(Connection), - PktRxPre(Rx), - PacketNumber, - Frame.Timestamp); -// arg2 = arg2 = PtkConnPre(Connection) = arg2 -// arg3 = arg3 = PktRxPre(Rx) = arg3 -// arg4 = arg4 = PacketNumber = arg4 -// arg5 = arg5 = Frame.Timestamp = arg5 -----------------------------------------------------------*/ -TRACEPOINT_EVENT(CLOG_FRAME_C, FrameLogTimestamp, TP_ARGS( unsigned char, arg2, unsigned char, arg3, @@ -1644,9 +1666,6 @@ TRACEPOINT_EVENT(CLOG_FRAME_C, FrameLogTimestamp, unsigned long long, arg6, unsigned long long, arg7, unsigned long long, arg8), - - unsigned long long, arg5), - TP_FIELDS( ctf_integer(unsigned char, arg2, arg2) ctf_integer(unsigned char, arg3, arg3) diff --git a/src/generated/linux/stream.c.clog.h b/src/generated/linux/stream.c.clog.h index 0cad30d0c6..c201623442 100644 --- a/src/generated/linux/stream.c.clog.h +++ b/src/generated/linux/stream.c.clog.h @@ -70,17 +70,17 @@ tracepoint(CLOG_STREAM_C, EventSilentDiscard , arg1);\ /*---------------------------------------------------------- -// Decoder Ring for BadShutdownImmediate -// [strm][%p] App tried ditching this stream but it still has stuff to do. +// Decoder Ring for ShutdownImmediatePendingReliableReset +// [strm][%p] Invalid immediate shutdown request (pending reliable reset). // QuicTraceLogStreamWarning( - BadShutdownImmediate, + ShutdownImmediatePendingReliableReset, Stream, - "App tried ditching this stream but it still has stuff to do."); + "Invalid immediate shutdown request (pending reliable reset)."); // arg1 = arg1 = Stream = arg1 ----------------------------------------------------------*/ -#ifndef _clog_3_ARGS_TRACE_BadShutdownImmediate -#define _clog_3_ARGS_TRACE_BadShutdownImmediate(uniqueId, arg1, encoded_arg_string)\ -tracepoint(CLOG_STREAM_C, BadShutdownImmediate , arg1);\ +#ifndef _clog_3_ARGS_TRACE_ShutdownImmediatePendingReliableReset +#define _clog_3_ARGS_TRACE_ShutdownImmediatePendingReliableReset(uniqueId, arg1, encoded_arg_string)\ +tracepoint(CLOG_STREAM_C, ShutdownImmediatePendingReliableReset , arg1);\ #endif diff --git a/src/generated/linux/stream.c.clog.h.lttng.h b/src/generated/linux/stream.c.clog.h.lttng.h index 0434e52fa0..b7796f6d6d 100644 --- a/src/generated/linux/stream.c.clog.h.lttng.h +++ b/src/generated/linux/stream.c.clog.h.lttng.h @@ -40,15 +40,15 @@ TRACEPOINT_EVENT(CLOG_STREAM_C, EventSilentDiscard, /*---------------------------------------------------------- -// Decoder Ring for BadShutdownImmediate -// [strm][%p] App tried ditching this stream but it still has stuff to do. +// Decoder Ring for ShutdownImmediatePendingReliableReset +// [strm][%p] Invalid immediate shutdown request (pending reliable reset). // QuicTraceLogStreamWarning( - BadShutdownImmediate, + ShutdownImmediatePendingReliableReset, Stream, - "App tried ditching this stream but it still has stuff to do."); + "Invalid immediate shutdown request (pending reliable reset)."); // arg1 = arg1 = Stream = arg1 ----------------------------------------------------------*/ -TRACEPOINT_EVENT(CLOG_STREAM_C, BadShutdownImmediate, +TRACEPOINT_EVENT(CLOG_STREAM_C, ShutdownImmediatePendingReliableReset, TP_ARGS( const void *, arg1), TP_FIELDS( diff --git a/src/generated/linux/stream_recv.c.clog.h b/src/generated/linux/stream_recv.c.clog.h index d2278292f9..88fca6b1a4 100644 --- a/src/generated/linux/stream_recv.c.clog.h +++ b/src/generated/linux/stream_recv.c.clog.h @@ -34,17 +34,17 @@ extern "C" { #endif /*---------------------------------------------------------- -// Decoder Ring for ReliableResetNotNegotiated -// [strm][%p] Tried to use ReliableReset without negotiation. +// Decoder Ring for ReliableResetNotNegotiatedError +// [strm][%p] Received ReliableReset without negotiation. // QuicTraceLogStreamWarning( - ReliableResetNotNegotiated, + ReliableResetNotNegotiatedError, Stream, - "Tried to use ReliableReset without negotiation."); + "Received ReliableReset without negotiation."); // arg1 = arg1 = Stream = arg1 ----------------------------------------------------------*/ -#ifndef _clog_3_ARGS_TRACE_ReliableResetNotNegotiated -#define _clog_3_ARGS_TRACE_ReliableResetNotNegotiated(uniqueId, arg1, encoded_arg_string)\ -tracepoint(CLOG_STREAM_RECV_C, ReliableResetNotNegotiated , arg1);\ +#ifndef _clog_3_ARGS_TRACE_ReliableResetNotNegotiatedError +#define _clog_3_ARGS_TRACE_ReliableResetNotNegotiatedError(uniqueId, arg1, encoded_arg_string)\ +tracepoint(CLOG_STREAM_RECV_C, ReliableResetNotNegotiatedError , arg1);\ #endif diff --git a/src/generated/linux/stream_recv.c.clog.h.lttng.h b/src/generated/linux/stream_recv.c.clog.h.lttng.h index b1e30159d7..a09cd08a43 100644 --- a/src/generated/linux/stream_recv.c.clog.h.lttng.h +++ b/src/generated/linux/stream_recv.c.clog.h.lttng.h @@ -2,15 +2,15 @@ /*---------------------------------------------------------- -// Decoder Ring for ReliableResetNotNegotiated -// [strm][%p] Tried to use ReliableReset without negotiation. +// Decoder Ring for ReliableResetNotNegotiatedError +// [strm][%p] Received ReliableReset without negotiation. // QuicTraceLogStreamWarning( - ReliableResetNotNegotiated, + ReliableResetNotNegotiatedError, Stream, - "Tried to use ReliableReset without negotiation."); + "Received ReliableReset without negotiation."); // arg1 = arg1 = Stream = arg1 ----------------------------------------------------------*/ -TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, ReliableResetNotNegotiated, +TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, ReliableResetNotNegotiatedError, TP_ARGS( const void *, arg1), TP_FIELDS( diff --git a/src/manifest/clog.sidecar b/src/manifest/clog.sidecar index bdad347628..7a1c950792 100644 --- a/src/manifest/clog.sidecar +++ b/src/manifest/clog.sidecar @@ -9569,6 +9569,18 @@ ], "macroName": "QuicTraceLogStreamWarning" }, + "ReliableResetNotNegotiatedError": { + "ModuleProperites": {}, + "TraceString": "[strm][%p] Received ReliableReset without negotiation.", + "UniqueId": "ReliableResetNotNegotiatedError", + "splitArgs": [ + { + "DefinationEncoding": "p", + "MacroVariableName": "arg1" + } + ], + "macroName": "QuicTraceLogStreamWarning" + }, "ReliableResetOnStreamAck": { "ModuleProperites": {}, "TraceString": "[strm][%p] Shutting down stream [reliable] from OnStreamAck. Send side.", @@ -11238,6 +11250,18 @@ ], "macroName": "QuicTraceLogError" }, + "ShutdownImmediatePendingReliableReset": { + "ModuleProperites": {}, + "TraceString": "[strm][%p] Invalid immediate shutdown request (pending reliable reset).", + "UniqueId": "ShutdownImmediatePendingReliableReset", + "splitArgs": [ + { + "DefinationEncoding": "p", + "MacroVariableName": "arg1" + } + ], + "macroName": "QuicTraceLogStreamWarning" + }, "StartAckDelayTimer": { "ModuleProperites": {}, "TraceString": "[conn][%p] Starting ACK_DELAY timer for %u ms", @@ -16244,6 +16268,11 @@ "TraceID": "ReliableResetNotNegotiated", "EncodingString": "[strm][%p] Tried to use ReliableReset without negotiation." }, + { + "UniquenessHash": "9c46c2ef-6922-0df3-433c-711969bca059", + "TraceID": "ReliableResetNotNegotiatedError", + "EncodingString": "[strm][%p] Received ReliableReset without negotiation." + }, { "UniquenessHash": "8e06ef5e-6665-a253-c96c-596a2565274d", "TraceID": "ReliableResetOnStreamAck", @@ -16794,6 +16823,11 @@ "TraceID": "SettingsLoadInvalidOfferedVersion", "EncodingString": "Invalid OfferedVersion loaded from storage! 0x%x at position %d" }, + { + "UniquenessHash": "f34a9d8e-7798-1d30-2104-37dac8a3c0e0", + "TraceID": "ShutdownImmediatePendingReliableReset", + "EncodingString": "[strm][%p] Invalid immediate shutdown request (pending reliable reset)." + }, { "UniquenessHash": "3811b30b-84d6-43cc-8312-918d88c99d3e", "TraceID": "StartAckDelayTimer", From 514b0f582f1577a00843e84fc83865eba33c13c1 Mon Sep 17 00:00:00 2001 From: Jack He Date: Mon, 18 Sep 2023 12:07:47 -0700 Subject: [PATCH 083/123] int and unsigned int comparison fix --- src/test/lib/DataTest.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/test/lib/DataTest.cpp b/src/test/lib/DataTest.cpp index d361d945de..cc83e7b724 100644 --- a/src/test/lib/DataTest.cpp +++ b/src/test/lib/DataTest.cpp @@ -3368,7 +3368,7 @@ QuicTestStreamReliableResetMultipleSends( TEST_TRUE(send1.Successful); TEST_TRUE(send2.Successful); TEST_TRUE(send1.SeqNum < send2.SeqNum); - TEST_TRUE(send2.SeqNum < send3.SeqNum); + TEST_TRUE(send2.SeqNum < send3.SeqNum); TEST_TRUE(send3.SeqNum < send4.SeqNum); TEST_TRUE(send4.SeqNum < send5.SeqNum); @@ -3376,7 +3376,7 @@ QuicTestStreamReliableResetMultipleSends( TEST_FAILURE("We expected at least 2 successful sends, got %llu", (unsigned long long)Context.SendCompleteOrder.size()); } - for (int i = 1; i < Context.SendCompleteOrder.size(); ++i) { + for (long unsigned int i = 1; i < Context.SendCompleteOrder.size(); ++i) { if (Context.SendCompleteOrder[i - 1] > Context.SendCompleteOrder[i]) { TEST_FAILURE("We expected send requests to be completed in order. Got an absolute offset of %llu after %llu", (unsigned long long)Context.SendCompleteOrder[i], (unsigned long long)Context.SendCompleteOrder[i - 1]); From 2d1f43c0c22ea836c389840f15836fb6e6db4748 Mon Sep 17 00:00:00 2001 From: Jack He Date: Mon, 18 Sep 2023 12:38:45 -0700 Subject: [PATCH 084/123] got rid of reliance on std:vector --- src/test/lib/DataTest.cpp | 16 +--------------- 1 file changed, 1 insertion(+), 15 deletions(-) diff --git a/src/test/lib/DataTest.cpp b/src/test/lib/DataTest.cpp index cc83e7b724..e5e2a76eb1 100644 --- a/src/test/lib/DataTest.cpp +++ b/src/test/lib/DataTest.cpp @@ -3197,7 +3197,6 @@ struct StreamReliableReset { CxPlatEvent ClientStreamShutdownComplete; CxPlatEvent ServerStreamShutdownComplete; uint64_t ReceivedBufferSize; - std::vector SendCompleteOrder; uint64_t SequenceNum; @@ -3219,7 +3218,6 @@ struct StreamReliableReset { auto TestContext = (StreamReliableReset*)ServerContext; if (Event->Type == QUIC_STREAM_EVENT_RECEIVE) { TestContext->ReceivedBufferSize += Event->RECEIVE.TotalBufferLength; - TestContext->SendCompleteOrder.push_back(Event->RECEIVE.AbsoluteOffset); } if (Event->Type == QUIC_STREAM_EVENT_PEER_SEND_SHUTDOWN) { Stream->Shutdown(QUIC_STREAM_SHUTDOWN_FLAG_ABORT_SEND); @@ -3262,7 +3260,6 @@ QuicTestStreamReliableReset( QUIC_BUFFER SendBuffer { sizeof(SendDataBuffer), SendDataBuffer }; Context.ReceivedBufferSize = 0; - Context.SendCompleteOrder = {}; MsQuicAutoAcceptListener Listener(Registration, ServerConfiguration, StreamReliableReset::ConnCallback, &Context); TEST_QUIC_SUCCEEDED(Listener.GetInitStatus()); @@ -3327,7 +3324,6 @@ QuicTestStreamReliableResetMultipleSends( QUIC_BUFFER SendBuffer { sizeof(SendDataBuffer), SendDataBuffer }; Context.ReceivedBufferSize = 0; Context.SequenceNum = 0; - Context.SendCompleteOrder = {}; MsQuicAutoAcceptListener Listener(Registration, ServerConfiguration, StreamReliableReset::ConnCallback, &Context); TEST_QUIC_SUCCEEDED(Listener.GetInitStatus()); @@ -3365,21 +3361,11 @@ QuicTestStreamReliableResetMultipleSends( TEST_TRUE(Context.ServerStreamShutdownComplete.WaitTimeout(TestWaitTimeout)); TEST_TRUE(Context.ReceivedBufferSize >= RELIABLE_SIZE_MULTI_SENDS); + // Test order of completion, and that our first 2 sends MUST be successful. TEST_TRUE(send1.Successful); TEST_TRUE(send2.Successful); TEST_TRUE(send1.SeqNum < send2.SeqNum); TEST_TRUE(send2.SeqNum < send3.SeqNum); TEST_TRUE(send3.SeqNum < send4.SeqNum); TEST_TRUE(send4.SeqNum < send5.SeqNum); - - if (Context.SendCompleteOrder.size() < 2) { - TEST_FAILURE("We expected at least 2 successful sends, got %llu", (unsigned long long)Context.SendCompleteOrder.size()); - } - - for (long unsigned int i = 1; i < Context.SendCompleteOrder.size(); ++i) { - if (Context.SendCompleteOrder[i - 1] > Context.SendCompleteOrder[i]) { - TEST_FAILURE("We expected send requests to be completed in order. Got an absolute offset of %llu after %llu", - (unsigned long long)Context.SendCompleteOrder[i], (unsigned long long)Context.SendCompleteOrder[i - 1]); - } - } } From 7c02e49394390d2c0635d21a0bff79f4af042d4d Mon Sep 17 00:00:00 2001 From: Jack He Date: Mon, 18 Sep 2023 14:57:05 -0700 Subject: [PATCH 085/123] remote clashing ioctl --- src/test/MsQuicTests.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/test/MsQuicTests.h b/src/test/MsQuicTests.h index 4140a73055..1674d6e457 100644 --- a/src/test/MsQuicTests.h +++ b/src/test/MsQuicTests.h @@ -1219,9 +1219,9 @@ typedef struct { // QUIC_RUN_FEATURE_NEGOTIATION #define IOCTL_QUIC_RUN_STREAM_RELIABLE_RESET \ - QUIC_CTL_CODE(112, METHOD_BUFFERED, FILE_WRITE_DATA) + QUIC_CTL_CODE(113, METHOD_BUFFERED, FILE_WRITE_DATA) #define IOCTL_QUIC_RUN_STREAM_RELIABLE_RESET_MULTIPLE_SENDS \ - QUIC_CTL_CODE(113, METHOD_BUFFERED, FILE_WRITE_DATA) + QUIC_CTL_CODE(114, METHOD_BUFFERED, FILE_WRITE_DATA) -#define QUIC_MAX_IOCTL_FUNC_CODE 113 +#define QUIC_MAX_IOCTL_FUNC_CODE 114 From 4078f192412b222ef7f477f28b020944240aa384 Mon Sep 17 00:00:00 2001 From: Jack He Date: Tue, 19 Sep 2023 15:48:34 -0700 Subject: [PATCH 086/123] remove debug logging --- src/core/stream_recv.c | 18 ---- src/core/stream_send.c | 18 ---- src/generated/linux/stream_recv.c.clog.h | 78 ---------------- .../linux/stream_recv.c.clog.h.lttng.h | 90 ------------------- src/generated/linux/stream_send.c.clog.h | 78 ---------------- .../linux/stream_send.c.clog.h.lttng.h | 90 ------------------- 6 files changed, 372 deletions(-) diff --git a/src/core/stream_recv.c b/src/core/stream_recv.c index f37b431686..4445aa6d41 100644 --- a/src/core/stream_recv.c +++ b/src/core/stream_recv.c @@ -209,11 +209,6 @@ QuicStreamProcessReliableResetFrame( "[strm][%p] Recv State: %hhu", Stream, QuicStreamRecvGetState(Stream)); - QuicTraceLogStreamVerbose( - ProcessReliableReset, - Stream, - "Shutting down stream from Process Reliable Reset Frame. Recv Side. BaseOffset: %llu, RecvMaxLength: %llu", - Stream->RecvBuffer.BaseOffset, Stream->RecvMaxLength); QuicStreamRecvShutdown(Stream, TRUE, ErrorCode); } @@ -328,10 +323,6 @@ QuicStreamProcessResetFrame( (void)QuicStreamIndicateEvent(Stream, &Event); } - QuicTraceLogStreamVerbose( - ProcessReliableProcessResetFrame, - Stream, - "Shutting down stream Abortively in ProcessResetFrame. Recv Side."); // // Remove any flags we shouldn't be sending now that the receive // direction is closed. @@ -1144,10 +1135,6 @@ QuicStreamReceiveComplete( "Indicating QUIC_STREAM_EVENT_PEER_SEND_SHUTDOWN"); (void)QuicStreamIndicateEvent(Stream, &Event); - QuicTraceLogStreamVerbose( - GracefulRecv, - Stream, - "Shutting down stream [gracefully] Recv Side."); // // Now that the close event has been delivered to the app, we can shut // down the stream. @@ -1170,11 +1157,6 @@ QuicStreamReceiveComplete( "[strm][%p] Recv State: %hhu", Stream, QuicStreamRecvGetState(Stream)); - QuicTraceLogStreamVerbose( - ReliableResetReceiveComplete, - Stream, - "Shutting down stream from ReceiveComplete Recv Side. BaseOffset: %llu, RecvMaxLength: %llu", - Stream->RecvBuffer.BaseOffset, Stream->RecvMaxLength); QuicStreamRecvShutdown(Stream, TRUE, 0x21); } diff --git a/src/core/stream_send.c b/src/core/stream_send.c index 165bca3a2d..603e243b9f 100644 --- a/src/core/stream_send.c +++ b/src/core/stream_send.c @@ -1482,10 +1482,6 @@ QuicStreamOnAck( "[strm][%p] Send State: %hhu", Stream, QuicStreamSendGetState(Stream)); - QuicTraceLogStreamVerbose( - GracefulShutdown, - Stream, - "Shutting down [gracefully] from OnStreamAck. Send Side."); QuicStreamIndicateSendShutdownComplete(Stream, TRUE); QuicStreamTryCompleteShutdown(Stream); } @@ -1539,11 +1535,6 @@ QuicStreamOnAck( "[strm][%p] Send State: %hhu", Stream, QuicStreamSendGetState(Stream)); - QuicTraceLogStreamVerbose( - OnStreamAckReliableReset, - Stream, - "Shutting down stream [reliable] from OnStreamAck. Send side. UnAckedOffset=%llu, ReliableOffsetSend=%llu", - Stream->UnAckedOffset, Stream->ReliableOffsetSend); QuicStreamCleanupReliableReset(Stream); Stream->Flags.LocalCloseReset = TRUE; QuicStreamSendShutdown(Stream, FALSE, TRUE, FALSE, 0x21); @@ -1601,10 +1592,6 @@ QuicStreamOnResetAck( "[strm][%p] Send State: %hhu", Stream, QuicStreamSendGetState(Stream)); - QuicTraceLogStreamVerbose( - OnResetAck, - Stream, - "Shutting down stream [abortively] from OnResetAck. Send Side."); QuicStreamIndicateSendShutdownComplete(Stream, FALSE); QuicStreamTryCompleteShutdown(Stream); } @@ -1630,11 +1617,6 @@ QuicStreamOnResetReliableAck( "[strm][%p] Send State: %hhu", Stream, QuicStreamSendGetState(Stream)); - QuicTraceLogStreamVerbose( - ResetReliableAckShutDown, - Stream, - "Shutting down stream [reliably] from OnResetReliableAck. Send side. UnAckedOffset=%llu, ReliableOffsetSend=%llu", - Stream->UnAckedOffset, Stream->ReliableOffsetSend); QuicStreamCleanupReliableReset(Stream); Stream->Flags.LocalCloseReset = TRUE; QuicStreamSendShutdown(Stream, FALSE, TRUE, FALSE, 0x21); diff --git a/src/generated/linux/stream_recv.c.clog.h b/src/generated/linux/stream_recv.c.clog.h index 88fca6b1a4..fb7e9f40db 100644 --- a/src/generated/linux/stream_recv.c.clog.h +++ b/src/generated/linux/stream_recv.c.clog.h @@ -215,27 +215,6 @@ tracepoint(CLOG_STREAM_RECV_C, QueueRecvFlush , arg1);\ -/*---------------------------------------------------------- -// Decoder Ring for ProcessReliableReset -// [strm][%p] Shutting down stream from Process Reliable Reset Frame. Recv Side. BaseOffset: %llu, RecvMaxLength: %llu -// QuicTraceLogStreamVerbose( - ProcessReliableReset, - Stream, - "Shutting down stream from Process Reliable Reset Frame. Recv Side. BaseOffset: %llu, RecvMaxLength: %llu", - Stream->RecvBuffer.BaseOffset, Stream->RecvMaxLength); -// arg1 = arg1 = Stream = arg1 -// arg3 = arg3 = Stream->RecvBuffer.BaseOffset = arg3 -// arg4 = arg4 = Stream->RecvMaxLength = arg4 -----------------------------------------------------------*/ -#ifndef _clog_5_ARGS_TRACE_ProcessReliableReset -#define _clog_5_ARGS_TRACE_ProcessReliableReset(uniqueId, arg1, encoded_arg_string, arg3, arg4)\ -tracepoint(CLOG_STREAM_RECV_C, ProcessReliableReset , arg1, arg3, arg4);\ - -#endif - - - - /*---------------------------------------------------------- // Decoder Ring for IndicatePeerSendAbort // [strm][%p] Indicating QUIC_STREAM_EVENT_PEER_SEND_ABORTED (0x%llX) @@ -256,24 +235,6 @@ tracepoint(CLOG_STREAM_RECV_C, IndicatePeerSendAbort , arg1, arg3);\ -/*---------------------------------------------------------- -// Decoder Ring for ProcessReliableProcessResetFrame -// [strm][%p] Shutting down stream Abortively in ProcessResetFrame. Recv Side. -// QuicTraceLogStreamVerbose( - ProcessReliableProcessResetFrame, - Stream, - "Shutting down stream Abortively in ProcessResetFrame. Recv Side."); -// arg1 = arg1 = Stream = arg1 -----------------------------------------------------------*/ -#ifndef _clog_3_ARGS_TRACE_ProcessReliableProcessResetFrame -#define _clog_3_ARGS_TRACE_ProcessReliableProcessResetFrame(uniqueId, arg1, encoded_arg_string)\ -tracepoint(CLOG_STREAM_RECV_C, ProcessReliableProcessResetFrame , arg1);\ - -#endif - - - - /*---------------------------------------------------------- // Decoder Ring for IndicatePeerReceiveAborted // [strm][%p] Indicating QUIC_STREAM_EVENT_PEER_RECEIVE_ABORTED (0x%llX) @@ -472,45 +433,6 @@ tracepoint(CLOG_STREAM_RECV_C, IndicatePeerSendShutdown , arg1);\ -/*---------------------------------------------------------- -// Decoder Ring for GracefulRecv -// [strm][%p] Shutting down stream [gracefully] Recv Side. -// QuicTraceLogStreamVerbose( - GracefulRecv, - Stream, - "Shutting down stream [gracefully] Recv Side."); -// arg1 = arg1 = Stream = arg1 -----------------------------------------------------------*/ -#ifndef _clog_3_ARGS_TRACE_GracefulRecv -#define _clog_3_ARGS_TRACE_GracefulRecv(uniqueId, arg1, encoded_arg_string)\ -tracepoint(CLOG_STREAM_RECV_C, GracefulRecv , arg1);\ - -#endif - - - - -/*---------------------------------------------------------- -// Decoder Ring for ReliableResetReceiveComplete -// [strm][%p] Shutting down stream from ReceiveComplete Recv Side. BaseOffset: %llu, RecvMaxLength: %llu -// QuicTraceLogStreamVerbose( - ReliableResetReceiveComplete, - Stream, - "Shutting down stream from ReceiveComplete Recv Side. BaseOffset: %llu, RecvMaxLength: %llu", - Stream->RecvBuffer.BaseOffset, Stream->RecvMaxLength); -// arg1 = arg1 = Stream = arg1 -// arg3 = arg3 = Stream->RecvBuffer.BaseOffset = arg3 -// arg4 = arg4 = Stream->RecvMaxLength = arg4 -----------------------------------------------------------*/ -#ifndef _clog_5_ARGS_TRACE_ReliableResetReceiveComplete -#define _clog_5_ARGS_TRACE_ReliableResetReceiveComplete(uniqueId, arg1, encoded_arg_string, arg3, arg4)\ -tracepoint(CLOG_STREAM_RECV_C, ReliableResetReceiveComplete , arg1, arg3, arg4);\ - -#endif - - - - /*---------------------------------------------------------- // Decoder Ring for StreamRecvState // [strm][%p] Recv State: %hhu diff --git a/src/generated/linux/stream_recv.c.clog.h.lttng.h b/src/generated/linux/stream_recv.c.clog.h.lttng.h index a09cd08a43..61bfd6a234 100644 --- a/src/generated/linux/stream_recv.c.clog.h.lttng.h +++ b/src/generated/linux/stream_recv.c.clog.h.lttng.h @@ -195,32 +195,6 @@ TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, QueueRecvFlush, -/*---------------------------------------------------------- -// Decoder Ring for ProcessReliableReset -// [strm][%p] Shutting down stream from Process Reliable Reset Frame. Recv Side. BaseOffset: %llu, RecvMaxLength: %llu -// QuicTraceLogStreamVerbose( - ProcessReliableReset, - Stream, - "Shutting down stream from Process Reliable Reset Frame. Recv Side. BaseOffset: %llu, RecvMaxLength: %llu", - Stream->RecvBuffer.BaseOffset, Stream->RecvMaxLength); -// arg1 = arg1 = Stream = arg1 -// arg3 = arg3 = Stream->RecvBuffer.BaseOffset = arg3 -// arg4 = arg4 = Stream->RecvMaxLength = arg4 -----------------------------------------------------------*/ -TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, ProcessReliableReset, - TP_ARGS( - const void *, arg1, - unsigned long long, arg3, - unsigned long long, arg4), - TP_FIELDS( - ctf_integer_hex(uint64_t, arg1, arg1) - ctf_integer(uint64_t, arg3, arg3) - ctf_integer(uint64_t, arg4, arg4) - ) -) - - - /*---------------------------------------------------------- // Decoder Ring for IndicatePeerSendAbort // [strm][%p] Indicating QUIC_STREAM_EVENT_PEER_SEND_ABORTED (0x%llX) @@ -244,25 +218,6 @@ TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, IndicatePeerSendAbort, -/*---------------------------------------------------------- -// Decoder Ring for ProcessReliableProcessResetFrame -// [strm][%p] Shutting down stream Abortively in ProcessResetFrame. Recv Side. -// QuicTraceLogStreamVerbose( - ProcessReliableProcessResetFrame, - Stream, - "Shutting down stream Abortively in ProcessResetFrame. Recv Side."); -// arg1 = arg1 = Stream = arg1 -----------------------------------------------------------*/ -TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, ProcessReliableProcessResetFrame, - TP_ARGS( - const void *, arg1), - TP_FIELDS( - ctf_integer_hex(uint64_t, arg1, arg1) - ) -) - - - /*---------------------------------------------------------- // Decoder Ring for IndicatePeerReceiveAborted // [strm][%p] Indicating QUIC_STREAM_EVENT_PEER_RECEIVE_ABORTED (0x%llX) @@ -489,51 +444,6 @@ TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, IndicatePeerSendShutdown, -/*---------------------------------------------------------- -// Decoder Ring for GracefulRecv -// [strm][%p] Shutting down stream [gracefully] Recv Side. -// QuicTraceLogStreamVerbose( - GracefulRecv, - Stream, - "Shutting down stream [gracefully] Recv Side."); -// arg1 = arg1 = Stream = arg1 -----------------------------------------------------------*/ -TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, GracefulRecv, - TP_ARGS( - const void *, arg1), - TP_FIELDS( - ctf_integer_hex(uint64_t, arg1, arg1) - ) -) - - - -/*---------------------------------------------------------- -// Decoder Ring for ReliableResetReceiveComplete -// [strm][%p] Shutting down stream from ReceiveComplete Recv Side. BaseOffset: %llu, RecvMaxLength: %llu -// QuicTraceLogStreamVerbose( - ReliableResetReceiveComplete, - Stream, - "Shutting down stream from ReceiveComplete Recv Side. BaseOffset: %llu, RecvMaxLength: %llu", - Stream->RecvBuffer.BaseOffset, Stream->RecvMaxLength); -// arg1 = arg1 = Stream = arg1 -// arg3 = arg3 = Stream->RecvBuffer.BaseOffset = arg3 -// arg4 = arg4 = Stream->RecvMaxLength = arg4 -----------------------------------------------------------*/ -TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, ReliableResetReceiveComplete, - TP_ARGS( - const void *, arg1, - unsigned long long, arg3, - unsigned long long, arg4), - TP_FIELDS( - ctf_integer_hex(uint64_t, arg1, arg1) - ctf_integer(uint64_t, arg3, arg3) - ctf_integer(uint64_t, arg4, arg4) - ) -) - - - /*---------------------------------------------------------- // Decoder Ring for StreamRecvState // [strm][%p] Recv State: %hhu diff --git a/src/generated/linux/stream_send.c.clog.h b/src/generated/linux/stream_send.c.clog.h index 69246ce698..1ff0ee7dd6 100644 --- a/src/generated/linux/stream_send.c.clog.h +++ b/src/generated/linux/stream_send.c.clog.h @@ -289,63 +289,6 @@ tracepoint(CLOG_STREAM_SEND_C, SendQueueDrained , arg1);\ -/*---------------------------------------------------------- -// Decoder Ring for GracefulShutdown -// [strm][%p] Shutting down [gracefully] from OnStreamAck. Send Side. -// QuicTraceLogStreamVerbose( - GracefulShutdown, - Stream, - "Shutting down [gracefully] from OnStreamAck. Send Side."); -// arg1 = arg1 = Stream = arg1 -----------------------------------------------------------*/ -#ifndef _clog_3_ARGS_TRACE_GracefulShutdown -#define _clog_3_ARGS_TRACE_GracefulShutdown(uniqueId, arg1, encoded_arg_string)\ -tracepoint(CLOG_STREAM_SEND_C, GracefulShutdown , arg1);\ - -#endif - - - - -/*---------------------------------------------------------- -// Decoder Ring for OnStreamAckReliableReset -// [strm][%p] Shutting down stream [reliable] from OnStreamAck. Send side. UnAckedOffset=%llu, ReliableOffsetSend=%llu -// QuicTraceLogStreamVerbose( - OnStreamAckReliableReset, - Stream, - "Shutting down stream [reliable] from OnStreamAck. Send side. UnAckedOffset=%llu, ReliableOffsetSend=%llu", - Stream->UnAckedOffset, Stream->ReliableOffsetSend); -// arg1 = arg1 = Stream = arg1 -// arg3 = arg3 = Stream->UnAckedOffset = arg3 -// arg4 = arg4 = Stream->ReliableOffsetSend = arg4 -----------------------------------------------------------*/ -#ifndef _clog_5_ARGS_TRACE_OnStreamAckReliableReset -#define _clog_5_ARGS_TRACE_OnStreamAckReliableReset(uniqueId, arg1, encoded_arg_string, arg3, arg4)\ -tracepoint(CLOG_STREAM_SEND_C, OnStreamAckReliableReset , arg1, arg3, arg4);\ - -#endif - - - - -/*---------------------------------------------------------- -// Decoder Ring for OnResetAck -// [strm][%p] Shutting down stream [abortively] from OnResetAck. Send Side. -// QuicTraceLogStreamVerbose( - OnResetAck, - Stream, - "Shutting down stream [abortively] from OnResetAck. Send Side."); -// arg1 = arg1 = Stream = arg1 -----------------------------------------------------------*/ -#ifndef _clog_3_ARGS_TRACE_OnResetAck -#define _clog_3_ARGS_TRACE_OnResetAck(uniqueId, arg1, encoded_arg_string)\ -tracepoint(CLOG_STREAM_SEND_C, OnResetAck , arg1);\ - -#endif - - - - /*---------------------------------------------------------- // Decoder Ring for ResetReliableAck // [strm][%p] Reset Reliable ACKed in OnResetReliableAck. Send side. UnAckedOffset=%llu, ReliableOffsetSend=%llu @@ -367,27 +310,6 @@ tracepoint(CLOG_STREAM_SEND_C, ResetReliableAck , arg1, arg3, arg4);\ -/*---------------------------------------------------------- -// Decoder Ring for ResetReliableAckShutDown -// [strm][%p] Shutting down stream [reliably] from OnResetReliableAck. Send side. UnAckedOffset=%llu, ReliableOffsetSend=%llu -// QuicTraceLogStreamVerbose( - ResetReliableAckShutDown, - Stream, - "Shutting down stream [reliably] from OnResetReliableAck. Send side. UnAckedOffset=%llu, ReliableOffsetSend=%llu", - Stream->UnAckedOffset, Stream->ReliableOffsetSend); -// arg1 = arg1 = Stream = arg1 -// arg3 = arg3 = Stream->UnAckedOffset = arg3 -// arg4 = arg4 = Stream->ReliableOffsetSend = arg4 -----------------------------------------------------------*/ -#ifndef _clog_5_ARGS_TRACE_ResetReliableAckShutDown -#define _clog_5_ARGS_TRACE_ResetReliableAckShutDown(uniqueId, arg1, encoded_arg_string, arg3, arg4)\ -tracepoint(CLOG_STREAM_SEND_C, ResetReliableAckShutDown , arg1, arg3, arg4);\ - -#endif - - - - /*---------------------------------------------------------- // Decoder Ring for SendDump // [strm][%p] SF:%hX FC:%llu QS:%llu MAX:%llu UNA:%llu NXT:%llu RECOV:%llu-%llu diff --git a/src/generated/linux/stream_send.c.clog.h.lttng.h b/src/generated/linux/stream_send.c.clog.h.lttng.h index 170efbe2b5..3914a3f9bf 100644 --- a/src/generated/linux/stream_send.c.clog.h.lttng.h +++ b/src/generated/linux/stream_send.c.clog.h.lttng.h @@ -308,70 +308,6 @@ TRACEPOINT_EVENT(CLOG_STREAM_SEND_C, SendQueueDrained, -/*---------------------------------------------------------- -// Decoder Ring for GracefulShutdown -// [strm][%p] Shutting down [gracefully] from OnStreamAck. Send Side. -// QuicTraceLogStreamVerbose( - GracefulShutdown, - Stream, - "Shutting down [gracefully] from OnStreamAck. Send Side."); -// arg1 = arg1 = Stream = arg1 -----------------------------------------------------------*/ -TRACEPOINT_EVENT(CLOG_STREAM_SEND_C, GracefulShutdown, - TP_ARGS( - const void *, arg1), - TP_FIELDS( - ctf_integer_hex(uint64_t, arg1, arg1) - ) -) - - - -/*---------------------------------------------------------- -// Decoder Ring for OnStreamAckReliableReset -// [strm][%p] Shutting down stream [reliable] from OnStreamAck. Send side. UnAckedOffset=%llu, ReliableOffsetSend=%llu -// QuicTraceLogStreamVerbose( - OnStreamAckReliableReset, - Stream, - "Shutting down stream [reliable] from OnStreamAck. Send side. UnAckedOffset=%llu, ReliableOffsetSend=%llu", - Stream->UnAckedOffset, Stream->ReliableOffsetSend); -// arg1 = arg1 = Stream = arg1 -// arg3 = arg3 = Stream->UnAckedOffset = arg3 -// arg4 = arg4 = Stream->ReliableOffsetSend = arg4 -----------------------------------------------------------*/ -TRACEPOINT_EVENT(CLOG_STREAM_SEND_C, OnStreamAckReliableReset, - TP_ARGS( - const void *, arg1, - unsigned long long, arg3, - unsigned long long, arg4), - TP_FIELDS( - ctf_integer_hex(uint64_t, arg1, arg1) - ctf_integer(uint64_t, arg3, arg3) - ctf_integer(uint64_t, arg4, arg4) - ) -) - - - -/*---------------------------------------------------------- -// Decoder Ring for OnResetAck -// [strm][%p] Shutting down stream [abortively] from OnResetAck. Send Side. -// QuicTraceLogStreamVerbose( - OnResetAck, - Stream, - "Shutting down stream [abortively] from OnResetAck. Send Side."); -// arg1 = arg1 = Stream = arg1 -----------------------------------------------------------*/ -TRACEPOINT_EVENT(CLOG_STREAM_SEND_C, OnResetAck, - TP_ARGS( - const void *, arg1), - TP_FIELDS( - ctf_integer_hex(uint64_t, arg1, arg1) - ) -) - - - /*---------------------------------------------------------- // Decoder Ring for ResetReliableAck // [strm][%p] Reset Reliable ACKed in OnResetReliableAck. Send side. UnAckedOffset=%llu, ReliableOffsetSend=%llu @@ -398,32 +334,6 @@ TRACEPOINT_EVENT(CLOG_STREAM_SEND_C, ResetReliableAck, -/*---------------------------------------------------------- -// Decoder Ring for ResetReliableAckShutDown -// [strm][%p] Shutting down stream [reliably] from OnResetReliableAck. Send side. UnAckedOffset=%llu, ReliableOffsetSend=%llu -// QuicTraceLogStreamVerbose( - ResetReliableAckShutDown, - Stream, - "Shutting down stream [reliably] from OnResetReliableAck. Send side. UnAckedOffset=%llu, ReliableOffsetSend=%llu", - Stream->UnAckedOffset, Stream->ReliableOffsetSend); -// arg1 = arg1 = Stream = arg1 -// arg3 = arg3 = Stream->UnAckedOffset = arg3 -// arg4 = arg4 = Stream->ReliableOffsetSend = arg4 -----------------------------------------------------------*/ -TRACEPOINT_EVENT(CLOG_STREAM_SEND_C, ResetReliableAckShutDown, - TP_ARGS( - const void *, arg1, - unsigned long long, arg3, - unsigned long long, arg4), - TP_FIELDS( - ctf_integer_hex(uint64_t, arg1, arg1) - ctf_integer(uint64_t, arg3, arg3) - ctf_integer(uint64_t, arg4, arg4) - ) -) - - - /*---------------------------------------------------------- // Decoder Ring for SendDump // [strm][%p] SF:%hX FC:%llu QS:%llu MAX:%llu UNA:%llu NXT:%llu RECOV:%llu-%llu From c8243352c98d5c2ef20a46a7eb923b54313cfa3e Mon Sep 17 00:00:00 2001 From: Jack He Date: Wed, 20 Sep 2023 16:21:40 -0700 Subject: [PATCH 087/123] update error code, and add new send / recv events --- src/core/stream.h | 15 +++++++++++++-- src/core/stream_recv.c | 2 +- 2 files changed, 14 insertions(+), 3 deletions(-) diff --git a/src/core/stream.h b/src/core/stream.h index d88920b8f8..310fa31264 100644 --- a/src/core/stream.h +++ b/src/core/stream.h @@ -168,7 +168,9 @@ typedef enum QUIC_STREAM_SEND_STATE { QUIC_STREAM_SEND_RESET, QUIC_STREAM_SEND_RESET_ACKED, QUIC_STREAM_SEND_FIN, - QUIC_STREAM_SEND_FIN_ACKED + QUIC_STREAM_SEND_FIN_ACKED, + QUIC_STREAM_SEND_RELIABLE_RESET, + QUIC_STREAM_SEND_RELIABLE_RESET_ACKED } QUIC_STREAM_SEND_STATE; typedef enum QUIC_STREAM_RECV_STATE { @@ -177,7 +179,8 @@ typedef enum QUIC_STREAM_RECV_STATE { QUIC_STREAM_RECV_PAUSED, QUIC_STREAM_RECV_STOPPED, QUIC_STREAM_RECV_RESET, - QUIC_STREAM_RECV_FIN + QUIC_STREAM_RECV_FIN, + QUIC_STREAM_RECV_RELIABLE_RESET } QUIC_STREAM_RECV_STATE; // @@ -457,6 +460,12 @@ QuicStreamSendGetState( { if (Stream->Flags.LocalNotAllowed) { return QUIC_STREAM_SEND_DISABLED; + } else if (Stream->Flags.LocalCloseResetReliable) { + if (Stream->Flags.LocalCloseResetReliableAcked) { + return QUIC_STREAM_SEND_RELIABLE_RESET_ACKED; + } else { + return QUIC_STREAM_SEND_RELIABLE_RESET; + } } else if (Stream->Flags.LocalCloseAcked) { if (Stream->Flags.FinAcked) { return QUIC_STREAM_SEND_FIN_ACKED; @@ -480,6 +489,8 @@ QuicStreamRecvGetState( { if (Stream->Flags.RemoteNotAllowed) { return QUIC_STREAM_RECV_DISABLED; + } else if (Stream->Flags.RemoteCloseResetReliable) { + return QUIC_STREAM_RECV_RELIABLE_RESET; } else if (Stream->Flags.RemoteCloseReset) { return QUIC_STREAM_RECV_RESET; } else if (Stream->Flags.RemoteCloseFin) { diff --git a/src/core/stream_recv.c b/src/core/stream_recv.c index 4445aa6d41..24ffef119c 100644 --- a/src/core/stream_recv.c +++ b/src/core/stream_recv.c @@ -182,7 +182,7 @@ QuicStreamProcessReliableResetFrame( ReliableResetNotNegotiatedError, Stream, "Received ReliableReset without negotiation."); - QuicConnTransportError(Stream->Connection, QUIC_ERROR_STREAM_STATE_ERROR); + QuicConnTransportError(Stream->Connection, QUIC_ERROR_TRANSPORT_PARAMETER_ERROR); return; } From 977d36503b1ab3cb04b3beb11cd7c60ef258b01a Mon Sep 17 00:00:00 2001 From: "Jack He (Github)" Date: Thu, 21 Sep 2023 10:02:05 -0700 Subject: [PATCH 088/123] Update src/core/stream_send.c Co-authored-by: Nick Banks --- src/core/stream_send.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/core/stream_send.c b/src/core/stream_send.c index 603e243b9f..cad80709bc 100644 --- a/src/core/stream_send.c +++ b/src/core/stream_send.c @@ -1531,10 +1531,10 @@ QuicStreamOnAck( Stream->Flags.LocalCloseAcked = TRUE; Stream->Flags.RemoteCloseAcked = TRUE; QuicTraceEvent( - StreamSendState, - "[strm][%p] Send State: %hhu", - Stream, - QuicStreamSendGetState(Stream)); + StreamSendState, + "[strm][%p] Send State: %hhu", + Stream, + QuicStreamSendGetState(Stream)); QuicStreamCleanupReliableReset(Stream); Stream->Flags.LocalCloseReset = TRUE; QuicStreamSendShutdown(Stream, FALSE, TRUE, FALSE, 0x21); From e75d5244eb5d5463aabeb4b1bbaf4c12415847ee Mon Sep 17 00:00:00 2001 From: "Jack He (Github)" Date: Thu, 21 Sep 2023 10:02:40 -0700 Subject: [PATCH 089/123] Update src/core/stream_send.c Co-authored-by: Nick Banks --- src/core/stream_send.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/core/stream_send.c b/src/core/stream_send.c index cad80709bc..40064acd9a 100644 --- a/src/core/stream_send.c +++ b/src/core/stream_send.c @@ -1526,7 +1526,10 @@ QuicStreamOnAck( // // If this stream has been reset reliably, we only close if we have received enough bytes. // - BOOLEAN ReliableResetShutdown = !Stream->Flags.LocalCloseAcked && Stream->Flags.LocalCloseResetReliableAcked && Stream->UnAckedOffset >= Stream->ReliableOffsetSend; + const BOOLEAN ReliableResetShutdown = + !Stream->Flags.LocalCloseAcked && + Stream->Flags.LocalCloseResetReliableAcked && + Stream->UnAckedOffset >= Stream->ReliableOffsetSend; if (ReliableResetShutdown) { Stream->Flags.LocalCloseAcked = TRUE; Stream->Flags.RemoteCloseAcked = TRUE; From a32e6d139d361df24a8951fa9eeac7d8f7f2420b Mon Sep 17 00:00:00 2001 From: "Jack He (Github)" Date: Thu, 21 Sep 2023 10:02:58 -0700 Subject: [PATCH 090/123] Update src/core/stream_send.c Co-authored-by: Nick Banks --- src/core/stream_send.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/core/stream_send.c b/src/core/stream_send.c index 40064acd9a..22889e6a76 100644 --- a/src/core/stream_send.c +++ b/src/core/stream_send.c @@ -1608,10 +1608,10 @@ QuicStreamOnResetReliableAck( { Stream->Flags.LocalCloseResetReliableAcked = TRUE; QuicTraceLogStreamVerbose( - ResetReliableAck, - Stream, - "Reset Reliable ACKed in OnResetReliableAck. Send side. UnAckedOffset=%llu, ReliableOffsetSend=%llu", - Stream->UnAckedOffset, Stream->ReliableOffsetSend); + ResetReliableAck, + Stream, + "Reset Reliable ACKed in OnResetReliableAck. Send side. UnAckedOffset=%llu, ReliableOffsetSend=%llu", + Stream->UnAckedOffset, Stream->ReliableOffsetSend); if (Stream->UnAckedOffset >= Stream->ReliableOffsetSend && !Stream->Flags.LocalCloseAcked) { Stream->Flags.LocalCloseAcked = TRUE; Stream->Flags.RemoteCloseAcked = TRUE; From 4ae103c3320e8a19ab3fff15575bb865c45f2b87 Mon Sep 17 00:00:00 2001 From: "Jack He (Github)" Date: Thu, 21 Sep 2023 10:03:09 -0700 Subject: [PATCH 091/123] Update src/core/stream_send.c Co-authored-by: Nick Banks --- src/core/stream_send.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/core/stream_send.c b/src/core/stream_send.c index 22889e6a76..fb1375f664 100644 --- a/src/core/stream_send.c +++ b/src/core/stream_send.c @@ -1616,10 +1616,10 @@ QuicStreamOnResetReliableAck( Stream->Flags.LocalCloseAcked = TRUE; Stream->Flags.RemoteCloseAcked = TRUE; QuicTraceEvent( - StreamSendState, - "[strm][%p] Send State: %hhu", - Stream, - QuicStreamSendGetState(Stream)); + StreamSendState, + "[strm][%p] Send State: %hhu", + Stream, + QuicStreamSendGetState(Stream)); QuicStreamCleanupReliableReset(Stream); Stream->Flags.LocalCloseReset = TRUE; QuicStreamSendShutdown(Stream, FALSE, TRUE, FALSE, 0x21); From d245f6df95de7306d995275b7efd58b4729ca488 Mon Sep 17 00:00:00 2001 From: Jack He Date: Thu, 21 Sep 2023 12:00:44 -0700 Subject: [PATCH 092/123] resolve design decisions --- src/core/stream.c | 7 ++++++- src/core/stream.h | 4 ++-- src/test/lib/DataTest.cpp | 1 + 3 files changed, 9 insertions(+), 3 deletions(-) diff --git a/src/core/stream.c b/src/core/stream.c index f86e21b5c9..eaf677335d 100644 --- a/src/core/stream.c +++ b/src/core/stream.c @@ -908,6 +908,10 @@ QuicStreamParamGet( Status = QUIC_STATUS_INVALID_PARAMETER; break; } + if (Stream->ReliableOffsetSend == 0) { + Status = QUIC_STATUS_INVALID_STATE; + break; + } *(uint64_t*) Buffer = Stream->ReliableOffsetSend; Status = QUIC_STATUS_SUCCESS; break; @@ -923,7 +927,8 @@ QuicStreamParamGet( break; } if (!Stream->Flags.RemoteCloseResetReliable) { - *(uint64_t*)Buffer = 0; + Status = QUIC_STATUS_INVALID_STATE; + break; } else { *(uint64_t*)Buffer = Stream->RecvMaxLength; } diff --git a/src/core/stream.h b/src/core/stream.h index 310fa31264..263c270647 100644 --- a/src/core/stream.h +++ b/src/core/stream.h @@ -489,10 +489,10 @@ QuicStreamRecvGetState( { if (Stream->Flags.RemoteNotAllowed) { return QUIC_STREAM_RECV_DISABLED; - } else if (Stream->Flags.RemoteCloseResetReliable) { - return QUIC_STREAM_RECV_RELIABLE_RESET; } else if (Stream->Flags.RemoteCloseReset) { return QUIC_STREAM_RECV_RESET; + } else if (Stream->Flags.RemoteCloseResetReliable) { + return QUIC_STREAM_RECV_RELIABLE_RESET; } else if (Stream->Flags.RemoteCloseFin) { return QUIC_STREAM_RECV_FIN; } else if (Stream->Flags.SentStopSending) { diff --git a/src/test/lib/DataTest.cpp b/src/test/lib/DataTest.cpp index e5e2a76eb1..e815365873 100644 --- a/src/test/lib/DataTest.cpp +++ b/src/test/lib/DataTest.cpp @@ -8,6 +8,7 @@ Tests various features related to the data path. --*/ + #include "precomp.h" #ifdef QUIC_CLOG #include "DataTest.cpp.clog.h" From a5ed9574f3efe874aa47db9bab551a0f4657ba5f Mon Sep 17 00:00:00 2001 From: Jack He Date: Thu, 21 Sep 2023 15:39:30 -0700 Subject: [PATCH 093/123] log state change --- src/core/stream_send.c | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/src/core/stream_send.c b/src/core/stream_send.c index fb1375f664..38e597e052 100644 --- a/src/core/stream_send.c +++ b/src/core/stream_send.c @@ -1612,6 +1612,7 @@ QuicStreamOnResetReliableAck( Stream, "Reset Reliable ACKed in OnResetReliableAck. Send side. UnAckedOffset=%llu, ReliableOffsetSend=%llu", Stream->UnAckedOffset, Stream->ReliableOffsetSend); + if (Stream->UnAckedOffset >= Stream->ReliableOffsetSend && !Stream->Flags.LocalCloseAcked) { Stream->Flags.LocalCloseAcked = TRUE; Stream->Flags.RemoteCloseAcked = TRUE; @@ -1623,6 +1624,12 @@ QuicStreamOnResetReliableAck( QuicStreamCleanupReliableReset(Stream); Stream->Flags.LocalCloseReset = TRUE; QuicStreamSendShutdown(Stream, FALSE, TRUE, FALSE, 0x21); + } else { + QuicTraceEvent( + StreamSendState, + "[strm][%p] Send State: %hhu", + Stream, + QuicStreamSendGetState(Stream)); } } From 260a416625480c57ee603e410b75c46ce2d8b921 Mon Sep 17 00:00:00 2001 From: Jack He Date: Thu, 21 Sep 2023 18:07:26 -0700 Subject: [PATCH 094/123] log state change --- src/core/stream_send.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/core/stream_send.c b/src/core/stream_send.c index 38e597e052..59cb0206d7 100644 --- a/src/core/stream_send.c +++ b/src/core/stream_send.c @@ -1606,7 +1606,6 @@ QuicStreamOnResetReliableAck( _In_ QUIC_STREAM* Stream ) { - Stream->Flags.LocalCloseResetReliableAcked = TRUE; QuicTraceLogStreamVerbose( ResetReliableAck, Stream, @@ -1614,6 +1613,7 @@ QuicStreamOnResetReliableAck( Stream->UnAckedOffset, Stream->ReliableOffsetSend); if (Stream->UnAckedOffset >= Stream->ReliableOffsetSend && !Stream->Flags.LocalCloseAcked) { + Stream->Flags.LocalCloseResetReliableAcked = TRUE; Stream->Flags.LocalCloseAcked = TRUE; Stream->Flags.RemoteCloseAcked = TRUE; QuicTraceEvent( @@ -1630,6 +1630,7 @@ QuicStreamOnResetReliableAck( "[strm][%p] Send State: %hhu", Stream, QuicStreamSendGetState(Stream)); + Stream->Flags.LocalCloseResetReliableAcked = TRUE; } } From 35c8cbb459c451ab9bac461c5661974bbede3b4d Mon Sep 17 00:00:00 2001 From: Jack He Date: Fri, 22 Sep 2023 12:41:21 -0700 Subject: [PATCH 095/123] proper error code logic --- src/core/stream_recv.c | 8 ++++++-- src/generated/linux/stream_send.c.clog.h | 8 ++++---- src/generated/linux/stream_send.c.clog.h.lttng.h | 8 ++++---- 3 files changed, 14 insertions(+), 10 deletions(-) diff --git a/src/core/stream_recv.c b/src/core/stream_recv.c index 24ffef119c..e714dac278 100644 --- a/src/core/stream_recv.c +++ b/src/core/stream_recv.c @@ -210,6 +210,8 @@ QuicStreamProcessReliableResetFrame( Stream, QuicStreamRecvGetState(Stream)); QuicStreamRecvShutdown(Stream, TRUE, ErrorCode); + } else { + Stream->RecvShutdownErrorCode = ErrorCode; } if (!Stream->Flags.SentStopSending) { @@ -1149,7 +1151,9 @@ QuicStreamReceiveComplete( &Stream->Connection->Send, Stream, QUIC_STREAM_SEND_FLAG_MAX_DATA | QUIC_STREAM_SEND_FLAG_RECV_ABORT); - } else if (Stream->Flags.RemoteCloseResetReliable && Stream->RecvBuffer.BaseOffset >= Stream->RecvMaxLength) { + } + + else if (Stream->Flags.RemoteCloseResetReliable && Stream->RecvBuffer.BaseOffset >= Stream->RecvMaxLength) { Stream->Flags.LocalCloseAcked = TRUE; Stream->Flags.RemoteCloseAcked = TRUE; QuicTraceEvent( @@ -1157,7 +1161,7 @@ QuicStreamReceiveComplete( "[strm][%p] Recv State: %hhu", Stream, QuicStreamRecvGetState(Stream)); - QuicStreamRecvShutdown(Stream, TRUE, 0x21); + QuicStreamRecvShutdown(Stream, TRUE, Stream->RecvShutdownErrorCode); } return FALSE; diff --git a/src/generated/linux/stream_send.c.clog.h b/src/generated/linux/stream_send.c.clog.h index 1ff0ee7dd6..2c4508c60d 100644 --- a/src/generated/linux/stream_send.c.clog.h +++ b/src/generated/linux/stream_send.c.clog.h @@ -293,10 +293,10 @@ tracepoint(CLOG_STREAM_SEND_C, SendQueueDrained , arg1);\ // Decoder Ring for ResetReliableAck // [strm][%p] Reset Reliable ACKed in OnResetReliableAck. Send side. UnAckedOffset=%llu, ReliableOffsetSend=%llu // QuicTraceLogStreamVerbose( - ResetReliableAck, - Stream, - "Reset Reliable ACKed in OnResetReliableAck. Send side. UnAckedOffset=%llu, ReliableOffsetSend=%llu", - Stream->UnAckedOffset, Stream->ReliableOffsetSend); + ResetReliableAck, + Stream, + "Reset Reliable ACKed in OnResetReliableAck. Send side. UnAckedOffset=%llu, ReliableOffsetSend=%llu", + Stream->UnAckedOffset, Stream->ReliableOffsetSend); // arg1 = arg1 = Stream = arg1 // arg3 = arg3 = Stream->UnAckedOffset = arg3 // arg4 = arg4 = Stream->ReliableOffsetSend = arg4 diff --git a/src/generated/linux/stream_send.c.clog.h.lttng.h b/src/generated/linux/stream_send.c.clog.h.lttng.h index 3914a3f9bf..f37ae2c3cb 100644 --- a/src/generated/linux/stream_send.c.clog.h.lttng.h +++ b/src/generated/linux/stream_send.c.clog.h.lttng.h @@ -312,10 +312,10 @@ TRACEPOINT_EVENT(CLOG_STREAM_SEND_C, SendQueueDrained, // Decoder Ring for ResetReliableAck // [strm][%p] Reset Reliable ACKed in OnResetReliableAck. Send side. UnAckedOffset=%llu, ReliableOffsetSend=%llu // QuicTraceLogStreamVerbose( - ResetReliableAck, - Stream, - "Reset Reliable ACKed in OnResetReliableAck. Send side. UnAckedOffset=%llu, ReliableOffsetSend=%llu", - Stream->UnAckedOffset, Stream->ReliableOffsetSend); + ResetReliableAck, + Stream, + "Reset Reliable ACKed in OnResetReliableAck. Send side. UnAckedOffset=%llu, ReliableOffsetSend=%llu", + Stream->UnAckedOffset, Stream->ReliableOffsetSend); // arg1 = arg1 = Stream = arg1 // arg3 = arg3 = Stream->UnAckedOffset = arg3 // arg4 = arg4 = Stream->ReliableOffsetSend = arg4 From c7b1997e2c0d26835c70279c1f561a6461fe7d22 Mon Sep 17 00:00:00 2001 From: Jack He Date: Mon, 25 Sep 2023 01:08:29 -0700 Subject: [PATCH 096/123] make the pipes independent from each other --- src/core/stream_recv.c | 7 +++---- src/core/stream_send.c | 6 ++---- 2 files changed, 5 insertions(+), 8 deletions(-) diff --git a/src/core/stream_recv.c b/src/core/stream_recv.c index e714dac278..3099b6b05a 100644 --- a/src/core/stream_recv.c +++ b/src/core/stream_recv.c @@ -202,8 +202,6 @@ QuicStreamProcessReliableResetFrame( } if (Stream->RecvBuffer.BaseOffset >= Stream->RecvMaxLength) { - Stream->Flags.LocalCloseAcked = TRUE; - Stream->Flags.RemoteCloseAcked = TRUE; QuicTraceEvent( StreamRecvState, "[strm][%p] Recv State: %hhu", @@ -1154,8 +1152,9 @@ QuicStreamReceiveComplete( } else if (Stream->Flags.RemoteCloseResetReliable && Stream->RecvBuffer.BaseOffset >= Stream->RecvMaxLength) { - Stream->Flags.LocalCloseAcked = TRUE; - Stream->Flags.RemoteCloseAcked = TRUE; + // + // ReliableReset + // QuicTraceEvent( StreamRecvState, "[strm][%p] Recv State: %hhu", diff --git a/src/core/stream_send.c b/src/core/stream_send.c index 59cb0206d7..bfa2acbc6f 100644 --- a/src/core/stream_send.c +++ b/src/core/stream_send.c @@ -1531,8 +1531,6 @@ QuicStreamOnAck( Stream->Flags.LocalCloseResetReliableAcked && Stream->UnAckedOffset >= Stream->ReliableOffsetSend; if (ReliableResetShutdown) { - Stream->Flags.LocalCloseAcked = TRUE; - Stream->Flags.RemoteCloseAcked = TRUE; QuicTraceEvent( StreamSendState, "[strm][%p] Send State: %hhu", @@ -1540,7 +1538,7 @@ QuicStreamOnAck( QuicStreamSendGetState(Stream)); QuicStreamCleanupReliableReset(Stream); Stream->Flags.LocalCloseReset = TRUE; - QuicStreamSendShutdown(Stream, FALSE, TRUE, FALSE, 0x21); + QuicStreamSendShutdown(Stream, FALSE, TRUE, FALSE, Stream->SendShutdownErrorCode); } if (!QuicStreamHasPendingStreamData(Stream)) { @@ -1623,7 +1621,7 @@ QuicStreamOnResetReliableAck( QuicStreamSendGetState(Stream)); QuicStreamCleanupReliableReset(Stream); Stream->Flags.LocalCloseReset = TRUE; - QuicStreamSendShutdown(Stream, FALSE, TRUE, FALSE, 0x21); + QuicStreamSendShutdown(Stream, FALSE, TRUE, FALSE, Stream->SendShutdownErrorCode); } else { QuicTraceEvent( StreamSendState, From c2795a232ff362ed54c083deda83ace1ed7fa530 Mon Sep 17 00:00:00 2001 From: Jack He Date: Mon, 25 Sep 2023 02:08:46 -0700 Subject: [PATCH 097/123] update event test --- src/test/lib/EventTest.cpp | 130 ++++++++++++++++++++++++++++++++++++- 1 file changed, 129 insertions(+), 1 deletion(-) diff --git a/src/test/lib/EventTest.cpp b/src/test/lib/EventTest.cpp index 98bc1b4005..64a4d5e8c7 100644 --- a/src/test/lib/EventTest.cpp +++ b/src/test/lib/EventTest.cpp @@ -1448,6 +1448,133 @@ QuicTestValidateStreamEvents8( } // Connections scope } +void +QuicTestValidateStreamEvents9( + _In_ MsQuicRegistration& Registration, + _In_ MsQuicListener& Listener, + _In_ QuicAddr& ServerLocalAddr + ) +{ + TestScopeLogger ScopeLogger(__FUNCTION__); + + MsQuicSettings Settings; + Settings.SetPeerBidiStreamCount(1).SetMinimumMtu(1280).SetMaximumMtu(1280); + Settings.SetReliableResetEnabled(true); + MsQuicConfiguration ServerConfiguration(Registration, "MsQuicTest", Settings, ServerSelfSignedCredConfig); + TEST_TRUE(ServerConfiguration.IsValid()); + + MsQuicConfiguration ClientConfiguration(Registration, "MsQuicTest", Settings, MsQuicCredentialConfig()); + TEST_TRUE(ClientConfiguration.IsValid()); + + { // Connections scope + ConnValidator Client, Server(ServerConfiguration); + + Listener.Context = &Server; + + TEST_QUIC_SUCCEEDED( + MsQuic->ConnectionOpen( + Registration, + ConnValidatorCallback, + &Client, + &Client.Handle)); + + { // Stream scope + + StreamValidator ClientStream( + new(std::nothrow) StreamEventValidator* [4] { + new(std::nothrow) StreamStartCompleteEventValidator(), + new(std::nothrow) StreamEventValidator(QUIC_STREAM_EVENT_SEND_COMPLETE, 0, true), + new(std::nothrow) StreamEventValidator(QUIC_STREAM_EVENT_SHUTDOWN_COMPLETE, QUIC_EVENT_ACTION_SHUTDOWN_CONNECTION), + nullptr + }); + StreamValidator ServerStream( + new(std::nothrow) StreamEventValidator* [5] { + new(std::nothrow) StreamEventValidator(QUIC_STREAM_EVENT_RECEIVE), + new(std::nothrow) StreamEventValidator(QUIC_STREAM_EVENT_PEER_RECEIVE_ABORTED), + new(std::nothrow) StreamEventValidator(QUIC_STREAM_EVENT_SEND_SHUTDOWN_COMPLETE), + new(std::nothrow) StreamEventValidator(QUIC_STREAM_EVENT_SHUTDOWN_COMPLETE), + nullptr + }); + + Client.SetExpectedEvents( + new(std::nothrow) ConnEventValidator* [8] { + new(std::nothrow) ConnEventValidator(QUIC_CONNECTION_EVENT_RELIABLE_RESET_NEGOTIATED), + new(std::nothrow) ConnEventValidator(QUIC_CONNECTION_EVENT_STREAMS_AVAILABLE), + new(std::nothrow) ConnEventValidator(QUIC_CONNECTION_EVENT_DATAGRAM_STATE_CHANGED), + new(std::nothrow) ConnEventValidator(QUIC_CONNECTION_EVENT_CONNECTED), + new(std::nothrow) ConnEventValidator(QUIC_CONNECTION_EVENT_STREAMS_AVAILABLE, 0, true), + new(std::nothrow) ConnEventValidator(QUIC_CONNECTION_EVENT_RESUMPTION_TICKET_RECEIVED, 0, true), // TODO - Schannel does resumption regardless + new(std::nothrow) ConnEventValidator(QUIC_CONNECTION_EVENT_SHUTDOWN_COMPLETE), + nullptr + }); + Server.SetExpectedEvents( + new(std::nothrow) ConnEventValidator* [7] { + new(std::nothrow) ConnEventValidator(QUIC_CONNECTION_EVENT_RELIABLE_RESET_NEGOTIATED), + new(std::nothrow) ConnEventValidator(QUIC_CONNECTION_EVENT_CONNECTED), + new(std::nothrow) NewStreamEventValidator(&ServerStream), + new(std::nothrow) ConnEventValidator(QUIC_CONNECTION_EVENT_SHUTDOWN_INITIATED_BY_PEER), + new(std::nothrow) ConnEventValidator(QUIC_CONNECTION_EVENT_SHUTDOWN_COMPLETE), + nullptr + }); + + TEST_QUIC_SUCCEEDED( + MsQuic->StreamOpen( + Client.Handle, + QUIC_STREAM_OPEN_FLAG_NONE, + StreamValidatorCallback, + &ClientStream, + &ClientStream.Handle)); + TEST_QUIC_SUCCEEDED( + MsQuic->StreamStart( + ClientStream.Handle, + QUIC_STREAM_START_FLAG_NONE)); + + TEST_QUIC_SUCCEEDED( + MsQuic->ConnectionStart( + Client.Handle, + ClientConfiguration, + QuicAddrGetFamily(&ServerLocalAddr.SockAddr), + QUIC_TEST_LOOPBACK_FOR_AF( + QuicAddrGetFamily(&ServerLocalAddr.SockAddr)), + ServerLocalAddr.GetPort())); + + TEST_TRUE(Client.HandshakeComplete.WaitTimeout(1000)); + CxPlatSleep(200); + + uint8_t Buffer[1] = {0x1}; + QUIC_BUFFER SendBuffer = { sizeof(Buffer), (uint8_t*) Buffer }; + TEST_QUIC_SUCCEEDED( + MsQuic->StreamSend( + ClientStream.Handle, + &SendBuffer, + 1, + QUIC_SEND_FLAG_NONE, + nullptr)); + + uint64_t ReliableOffset = 1; + TEST_QUIC_SUCCEEDED( + MsQuic->SetParam( + ClientStream.Handle, + QUIC_PARAM_STREAM_RELIABLE_OFFSET, + sizeof(ReliableOffset), + &ReliableOffset + ) + ); + + CxPlatSleep(100); // Wait for the sends to be processed + + TEST_QUIC_SUCCEEDED( + MsQuic->StreamShutdown( + ClientStream.Handle, + QUIC_STREAM_SHUTDOWN_FLAG_ABORT, + 0)); + + TEST_TRUE(Client.Complete.WaitTimeout(2000)); + TEST_TRUE(Server.Complete.WaitTimeout(1000)); + } // Stream scope + } // Connections scope +} + void QuicTestValidateStreamEvents(uint32_t Test) { MsQuicRegistration Registration(true); @@ -1473,7 +1600,8 @@ void QuicTestValidateStreamEvents(uint32_t Test) QuicTestValidateStreamEvents5, QuicTestValidateStreamEvents6, QuicTestValidateStreamEvents7, - QuicTestValidateStreamEvents8 + QuicTestValidateStreamEvents8, + QuicTestValidateStreamEvents9 }; Tests[Test](Registration, Listener, ServerLocalAddr); From c5e7a47d1c726d0c95663d952ec4f7050e5378cf Mon Sep 17 00:00:00 2001 From: Jack He Date: Mon, 25 Sep 2023 02:14:31 -0700 Subject: [PATCH 098/123] make send and abort more explicit --- src/test/lib/DataTest.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/test/lib/DataTest.cpp b/src/test/lib/DataTest.cpp index e815365873..97d0185e72 100644 --- a/src/test/lib/DataTest.cpp +++ b/src/test/lib/DataTest.cpp @@ -3291,7 +3291,8 @@ QuicTestStreamReliableReset( QUIC_STATUS_INVALID_STATE, Stream.SetReliableOffset(UINT64_MAX)); TEST_QUIC_SUCCEEDED(Stream.SetReliableOffset(RELIABLE_SIZE)); - TEST_QUIC_SUCCEEDED(Stream.Shutdown(0)); // Queues up a shutdown operation. + TEST_QUIC_SUCCEEDED(Stream.Shutdown(0, QUIC_STREAM_SHUTDOWN_FLAG_ABORT_SEND)); // Queues up a shutdown operation. + TEST_QUIC_SUCCEEDED(Stream.Shutdown(0, QUIC_STREAM_SHUTDOWN_FLAG_ABORT_RECEIVE)); TEST_QUIC_STATUS(QUIC_STATUS_INVALID_STATE, Stream.SetReliableOffset(RELIABLE_SIZE)); // Should behave similar to QUIC_STREAM_SHUTDOWN_FLAG_GRACEFUL, with some restrictions. TEST_TRUE(Context.ClientStreamShutdownComplete.WaitTimeout(TestWaitTimeout)); From 307a62f5eaa1f6800ea009560746e1337b8c702c Mon Sep 17 00:00:00 2001 From: Jack He Date: Mon, 25 Sep 2023 15:23:12 -0700 Subject: [PATCH 099/123] fix build errors --- src/core/stream.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/core/stream.c b/src/core/stream.c index eaf677335d..7183a9626a 100644 --- a/src/core/stream.c +++ b/src/core/stream.c @@ -929,9 +929,9 @@ QuicStreamParamGet( if (!Stream->Flags.RemoteCloseResetReliable) { Status = QUIC_STATUS_INVALID_STATE; break; - } else { - *(uint64_t*)Buffer = Stream->RecvMaxLength; - } + } + + *(uint64_t*)Buffer = Stream->RecvMaxLength; Status = QUIC_STATUS_SUCCESS; break; From a6275378bb4c39ba335e4cb86640e4fee82511a7 Mon Sep 17 00:00:00 2001 From: Jack He Date: Mon, 25 Sep 2023 16:11:14 -0700 Subject: [PATCH 100/123] add error code tests --- src/core/stream_recv.c | 29 +++++++++-------- src/cs/lib/msquic_generated.cs | 22 +++++++++++++ src/generated/linux/stream_recv.c.clog.h | 28 ++++++++++++++--- .../linux/stream_recv.c.clog.h.lttng.h | 31 ++++++++++++++++--- src/inc/msquic.h | 9 ++++++ src/manifest/clog.sidecar | 21 +++++++++++++ src/test/bin/quic_gtest.h | 2 +- src/test/lib/DataTest.cpp | 24 ++++++++++---- src/test/lib/EventTest.cpp | 13 ++++---- 9 files changed, 143 insertions(+), 36 deletions(-) diff --git a/src/core/stream_recv.c b/src/core/stream_recv.c index 3099b6b05a..3f290adc2f 100644 --- a/src/core/stream_recv.c +++ b/src/core/stream_recv.c @@ -199,6 +199,20 @@ QuicStreamProcessReliableResetFrame( Stream, "Reliable recv offset set to %llu", ReliableOffset); + + // + // Indicate to the app that the peer will abort after having sent and ACK'd ReliableOffset amount of data. + // + QUIC_STREAM_EVENT Event; + Event.Type = QUIC_STREAM_EVENT_PEER_RELIABLE_ABORT_SEND; + Event.PEER_RELIABLE_ABORT_SEND.ReliableSize = ReliableOffset; + Event.PEER_RELIABLE_ABORT_SEND.ErrorCode = ErrorCode; + QuicTraceLogStreamVerbose( + IndicatePeerSendReliableAbort, + Stream, + "Indicating QUIC_STREAM_EVENT_PEER_RELIABLE_ABORT_SEND (0x%llX)", + ErrorCode); + (void)QuicStreamIndicateEvent(Stream, &Event); } if (Stream->RecvBuffer.BaseOffset >= Stream->RecvMaxLength) { @@ -211,21 +225,6 @@ QuicStreamProcessReliableResetFrame( } else { Stream->RecvShutdownErrorCode = ErrorCode; } - - if (!Stream->Flags.SentStopSending) { - // - // Indicate to the app that the stream has been aborted by the peer. - // - QUIC_STREAM_EVENT Event; - Event.Type = QUIC_STREAM_EVENT_PEER_SEND_ABORTED; - Event.PEER_SEND_ABORTED.ErrorCode = ErrorCode; - QuicTraceLogStreamVerbose( - IndicatePeerSendAbort, - Stream, - "Indicating QUIC_STREAM_EVENT_PEER_SEND_ABORTED (0x%llX)", - ErrorCode); - (void)QuicStreamIndicateEvent(Stream, &Event); - } } // diff --git a/src/cs/lib/msquic_generated.cs b/src/cs/lib/msquic_generated.cs index ff686c2114..0d6d82d386 100644 --- a/src/cs/lib/msquic_generated.cs +++ b/src/cs/lib/msquic_generated.cs @@ -2695,6 +2695,7 @@ internal enum QUIC_STREAM_EVENT_TYPE SHUTDOWN_COMPLETE = 7, IDEAL_SEND_BUFFER_SIZE = 8, PEER_ACCEPTED = 9, + PEER_RELIABLE_ABORT_SEND = 10, } internal partial struct QUIC_STREAM_EVENT @@ -2768,6 +2769,14 @@ internal ref _Anonymous_e__Union._IDEAL_SEND_BUFFER_SIZE_e__Struct IDEAL_SEND_BU } } + internal ref _Anonymous_e__Union._PEER_RELIABLE_ABORT_SEND_e__Struct PEER_RELIABLE_ABORT_SEND + { + get + { + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.PEER_RELIABLE_ABORT_SEND, 1)); + } + } + [StructLayout(LayoutKind.Explicit)] internal partial struct _Anonymous_e__Union { @@ -2803,6 +2812,10 @@ internal partial struct _Anonymous_e__Union [NativeTypeName("struct (anonymous struct)")] internal _IDEAL_SEND_BUFFER_SIZE_e__Struct IDEAL_SEND_BUFFER_SIZE; + [FieldOffset(0)] + [NativeTypeName("struct (anonymous struct)")] + internal _PEER_RELIABLE_ABORT_SEND_e__Struct PEER_RELIABLE_ABORT_SEND; + internal partial struct _START_COMPLETE_e__Struct { [NativeTypeName("HRESULT")] @@ -2960,6 +2973,15 @@ internal partial struct _IDEAL_SEND_BUFFER_SIZE_e__Struct [NativeTypeName("uint64_t")] internal ulong ByteCount; } + + internal partial struct _PEER_RELIABLE_ABORT_SEND_e__Struct + { + [NativeTypeName("QUIC_UINT62")] + internal ulong ErrorCode; + + [NativeTypeName("uint64_t")] + internal ulong ReliableSize; + } } } diff --git a/src/generated/linux/stream_recv.c.clog.h b/src/generated/linux/stream_recv.c.clog.h index fb7e9f40db..49b186c39d 100644 --- a/src/generated/linux/stream_recv.c.clog.h +++ b/src/generated/linux/stream_recv.c.clog.h @@ -216,16 +216,36 @@ tracepoint(CLOG_STREAM_RECV_C, QueueRecvFlush , arg1);\ /*---------------------------------------------------------- -// Decoder Ring for IndicatePeerSendAbort -// [strm][%p] Indicating QUIC_STREAM_EVENT_PEER_SEND_ABORTED (0x%llX) +// Decoder Ring for IndicatePeerSendReliableAbort +// [strm][%p] Indicating QUIC_STREAM_EVENT_PEER_RELIABLE_ABORT_SEND (0x%llX) // QuicTraceLogStreamVerbose( - IndicatePeerSendAbort, + IndicatePeerSendReliableAbort, Stream, - "Indicating QUIC_STREAM_EVENT_PEER_SEND_ABORTED (0x%llX)", + "Indicating QUIC_STREAM_EVENT_PEER_RELIABLE_ABORT_SEND (0x%llX)", ErrorCode); // arg1 = arg1 = Stream = arg1 // arg3 = arg3 = ErrorCode = arg3 ----------------------------------------------------------*/ +#ifndef _clog_4_ARGS_TRACE_IndicatePeerSendReliableAbort +#define _clog_4_ARGS_TRACE_IndicatePeerSendReliableAbort(uniqueId, arg1, encoded_arg_string, arg3)\ +tracepoint(CLOG_STREAM_RECV_C, IndicatePeerSendReliableAbort , arg1, arg3);\ + +#endif + + + + +/*---------------------------------------------------------- +// Decoder Ring for IndicatePeerSendAbort +// [strm][%p] Indicating QUIC_STREAM_EVENT_PEER_SEND_ABORTED (0x%llX) +// QuicTraceLogStreamVerbose( + IndicatePeerSendAbort, + Stream, + "Indicating QUIC_STREAM_EVENT_PEER_SEND_ABORTED (0x%llX)", + ErrorCode); +// arg1 = arg1 = Stream = arg1 +// arg3 = arg3 = ErrorCode = arg3 +----------------------------------------------------------*/ #ifndef _clog_4_ARGS_TRACE_IndicatePeerSendAbort #define _clog_4_ARGS_TRACE_IndicatePeerSendAbort(uniqueId, arg1, encoded_arg_string, arg3)\ tracepoint(CLOG_STREAM_RECV_C, IndicatePeerSendAbort , arg1, arg3);\ diff --git a/src/generated/linux/stream_recv.c.clog.h.lttng.h b/src/generated/linux/stream_recv.c.clog.h.lttng.h index 61bfd6a234..4f4ec5d146 100644 --- a/src/generated/linux/stream_recv.c.clog.h.lttng.h +++ b/src/generated/linux/stream_recv.c.clog.h.lttng.h @@ -196,16 +196,39 @@ TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, QueueRecvFlush, /*---------------------------------------------------------- -// Decoder Ring for IndicatePeerSendAbort -// [strm][%p] Indicating QUIC_STREAM_EVENT_PEER_SEND_ABORTED (0x%llX) +// Decoder Ring for IndicatePeerSendReliableAbort +// [strm][%p] Indicating QUIC_STREAM_EVENT_PEER_RELIABLE_ABORT_SEND (0x%llX) // QuicTraceLogStreamVerbose( - IndicatePeerSendAbort, + IndicatePeerSendReliableAbort, Stream, - "Indicating QUIC_STREAM_EVENT_PEER_SEND_ABORTED (0x%llX)", + "Indicating QUIC_STREAM_EVENT_PEER_RELIABLE_ABORT_SEND (0x%llX)", ErrorCode); // arg1 = arg1 = Stream = arg1 // arg3 = arg3 = ErrorCode = arg3 ----------------------------------------------------------*/ +TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, IndicatePeerSendReliableAbort, + TP_ARGS( + const void *, arg1, + unsigned long long, arg3), + TP_FIELDS( + ctf_integer_hex(uint64_t, arg1, arg1) + ctf_integer(uint64_t, arg3, arg3) + ) +) + + + +/*---------------------------------------------------------- +// Decoder Ring for IndicatePeerSendAbort +// [strm][%p] Indicating QUIC_STREAM_EVENT_PEER_SEND_ABORTED (0x%llX) +// QuicTraceLogStreamVerbose( + IndicatePeerSendAbort, + Stream, + "Indicating QUIC_STREAM_EVENT_PEER_SEND_ABORTED (0x%llX)", + ErrorCode); +// arg1 = arg1 = Stream = arg1 +// arg3 = arg3 = ErrorCode = arg3 +----------------------------------------------------------*/ TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, IndicatePeerSendAbort, TP_ARGS( const void *, arg1, diff --git a/src/inc/msquic.h b/src/inc/msquic.h index 40639485ce..8b745addc9 100644 --- a/src/inc/msquic.h +++ b/src/inc/msquic.h @@ -1374,6 +1374,9 @@ typedef enum QUIC_STREAM_EVENT_TYPE { QUIC_STREAM_EVENT_SHUTDOWN_COMPLETE = 7, QUIC_STREAM_EVENT_IDEAL_SEND_BUFFER_SIZE = 8, QUIC_STREAM_EVENT_PEER_ACCEPTED = 9, +#ifdef QUIC_API_ENABLE_PREVIEW_FEATURES + QUIC_STREAM_EVENT_PEER_RELIABLE_ABORT_SEND = 10, +#endif } QUIC_STREAM_EVENT_TYPE; typedef struct QUIC_STREAM_EVENT { @@ -1419,6 +1422,12 @@ typedef struct QUIC_STREAM_EVENT { struct { uint64_t ByteCount; } IDEAL_SEND_BUFFER_SIZE; +#ifdef QUIC_API_ENABLE_PREVIEW_FEATURES + struct { + QUIC_UINT62 ErrorCode; + uint64_t ReliableSize; + } PEER_RELIABLE_ABORT_SEND; +#endif }; } QUIC_STREAM_EVENT; diff --git a/src/manifest/clog.sidecar b/src/manifest/clog.sidecar index 7a1c950792..f3f9437c7c 100644 --- a/src/manifest/clog.sidecar +++ b/src/manifest/clog.sidecar @@ -6095,6 +6095,22 @@ ], "macroName": "QuicTraceLogStreamVerbose" }, + "IndicatePeerSendReliableAbort": { + "ModuleProperites": {}, + "TraceString": "[strm][%p] Indicating QUIC_STREAM_EVENT_PEER_RELIABLE_ABORT_SEND (0x%llX)", + "UniqueId": "IndicatePeerSendReliableAbort", + "splitArgs": [ + { + "DefinationEncoding": "p", + "MacroVariableName": "arg1" + }, + { + "DefinationEncoding": "llX", + "MacroVariableName": "arg3" + } + ], + "macroName": "QuicTraceLogStreamVerbose" + }, "IndicatePeerSendShutdown": { "ModuleProperites": {}, "TraceString": "[strm][%p] Indicating QUIC_STREAM_EVENT_PEER_SEND_SHUTDOWN", @@ -15118,6 +15134,11 @@ "TraceID": "IndicatePeerSendAbort", "EncodingString": "[strm][%p] Indicating QUIC_STREAM_EVENT_PEER_SEND_ABORTED (0x%llX)" }, + { + "UniquenessHash": "7f8e2ccb-c362-e297-f242-eee58833499e", + "TraceID": "IndicatePeerSendReliableAbort", + "EncodingString": "[strm][%p] Indicating QUIC_STREAM_EVENT_PEER_RELIABLE_ABORT_SEND (0x%llX)" + }, { "UniquenessHash": "7b23cd90-0d41-8339-9622-e84277f95b5d", "TraceID": "IndicatePeerSendShutdown", diff --git a/src/test/bin/quic_gtest.h b/src/test/bin/quic_gtest.h index 0f940d51d5..ffb172cf40 100644 --- a/src/test/bin/quic_gtest.h +++ b/src/test/bin/quic_gtest.h @@ -766,7 +766,7 @@ struct ValidateStreamEventArgs { uint32_t Test; static ::std::vector Generate() { ::std::vector list; - for (uint32_t Test = 0; Test < 8; ++Test) + for (uint32_t Test = 0; Test < 9; ++Test) list.push_back({ Test }); return list; } diff --git a/src/test/lib/DataTest.cpp b/src/test/lib/DataTest.cpp index 97d0185e72..7d4ddf0ecb 100644 --- a/src/test/lib/DataTest.cpp +++ b/src/test/lib/DataTest.cpp @@ -3199,6 +3199,7 @@ struct StreamReliableReset { CxPlatEvent ServerStreamShutdownComplete; uint64_t ReceivedBufferSize; uint64_t SequenceNum; + QUIC_UINT62 ShutdownErrorCode; static QUIC_STATUS ClientStreamCallback(_In_ MsQuicStream*, _In_opt_ void* ClientContext, _Inout_ QUIC_STREAM_EVENT* Event) { @@ -3215,13 +3216,13 @@ struct StreamReliableReset { return QUIC_STATUS_SUCCESS; } - static QUIC_STATUS ServerStreamCallback(_In_ MsQuicStream* Stream, _In_opt_ void* ServerContext, _Inout_ QUIC_STREAM_EVENT* Event) { + static QUIC_STATUS ServerStreamCallback(_In_ MsQuicStream*, _In_opt_ void* ServerContext, _Inout_ QUIC_STREAM_EVENT* Event) { auto TestContext = (StreamReliableReset*)ServerContext; if (Event->Type == QUIC_STREAM_EVENT_RECEIVE) { TestContext->ReceivedBufferSize += Event->RECEIVE.TotalBufferLength; } - if (Event->Type == QUIC_STREAM_EVENT_PEER_SEND_SHUTDOWN) { - Stream->Shutdown(QUIC_STREAM_SHUTDOWN_FLAG_ABORT_SEND); + if (Event->Type == QUIC_STREAM_EVENT_PEER_RELIABLE_ABORT_SEND) { + TestContext->ShutdownErrorCode = Event->PEER_RELIABLE_ABORT_SEND.ErrorCode; } if (Event->Type == QUIC_STREAM_EVENT_SHUTDOWN_COMPLETE) { TestContext->ServerStreamShutdownComplete.Set(); @@ -3291,8 +3292,10 @@ QuicTestStreamReliableReset( QUIC_STATUS_INVALID_STATE, Stream.SetReliableOffset(UINT64_MAX)); TEST_QUIC_SUCCEEDED(Stream.SetReliableOffset(RELIABLE_SIZE)); - TEST_QUIC_SUCCEEDED(Stream.Shutdown(0, QUIC_STREAM_SHUTDOWN_FLAG_ABORT_SEND)); // Queues up a shutdown operation. - TEST_QUIC_SUCCEEDED(Stream.Shutdown(0, QUIC_STREAM_SHUTDOWN_FLAG_ABORT_RECEIVE)); + const QUIC_UINT62 AbortSendShutdownErrorCode = 0x696969696969; + const QUIC_UINT62 AbortRecvShutdownErrorCode = 0x420420420420; + TEST_QUIC_SUCCEEDED(Stream.Shutdown(AbortSendShutdownErrorCode, QUIC_STREAM_SHUTDOWN_FLAG_ABORT_SEND)); // Queues up a shutdown operation. + TEST_QUIC_SUCCEEDED(Stream.Shutdown(AbortRecvShutdownErrorCode, QUIC_STREAM_SHUTDOWN_FLAG_ABORT_RECEIVE)); TEST_QUIC_STATUS(QUIC_STATUS_INVALID_STATE, Stream.SetReliableOffset(RELIABLE_SIZE)); // Should behave similar to QUIC_STREAM_SHUTDOWN_FLAG_GRACEFUL, with some restrictions. TEST_TRUE(Context.ClientStreamShutdownComplete.WaitTimeout(TestWaitTimeout)); @@ -3301,6 +3304,9 @@ QuicTestStreamReliableReset( // We shouldn't be able to change ReliableSize now that the stream has already been reset. TEST_QUIC_STATUS(QUIC_STATUS_INVALID_STATE, Stream.SetReliableOffset(1)); + + // Test that the error code we got was for the SEND shutdown. + TEST_TRUE(Context.ShutdownErrorCode == AbortSendShutdownErrorCode); } } void @@ -3326,6 +3332,7 @@ QuicTestStreamReliableResetMultipleSends( QUIC_BUFFER SendBuffer { sizeof(SendDataBuffer), SendDataBuffer }; Context.ReceivedBufferSize = 0; Context.SequenceNum = 0; + Context.ShutdownErrorCode = 0; MsQuicAutoAcceptListener Listener(Registration, ServerConfiguration, StreamReliableReset::ConnCallback, &Context); TEST_QUIC_SUCCEEDED(Listener.GetInitStatus()); @@ -3357,7 +3364,9 @@ QuicTestStreamReliableResetMultipleSends( TEST_QUIC_SUCCEEDED(Stream.Send(&SendBuffer, 1, QUIC_SEND_FLAG_DELAY_SEND, &send4)); TEST_QUIC_SUCCEEDED(Stream.Send(&SendBuffer, 1, QUIC_SEND_FLAG_DELAY_SEND, &send5)); TEST_QUIC_SUCCEEDED(Stream.SetReliableOffset(RELIABLE_SIZE_MULTI_SENDS)); - TEST_QUIC_SUCCEEDED(Stream.Shutdown(0)); // Queues up a shutdown operation. + + const QUIC_UINT62 AbortShutdownErrorCode = 0x696969696969; + TEST_QUIC_SUCCEEDED(Stream.Shutdown(AbortShutdownErrorCode)); // Queues up a shutdown operation. // Should behave similar to QUIC_STREAM_SHUTDOWN_FLAG_GRACEFUL, with some restrictions. TEST_TRUE(Context.ClientStreamShutdownComplete.WaitTimeout(TestWaitTimeout)); TEST_TRUE(Context.ServerStreamShutdownComplete.WaitTimeout(TestWaitTimeout)); @@ -3370,4 +3379,7 @@ QuicTestStreamReliableResetMultipleSends( TEST_TRUE(send2.SeqNum < send3.SeqNum); TEST_TRUE(send3.SeqNum < send4.SeqNum); TEST_TRUE(send4.SeqNum < send5.SeqNum); + + // Test Error code matches what we sent. + TEST_TRUE(Context.ShutdownErrorCode == AbortShutdownErrorCode); } diff --git a/src/test/lib/EventTest.cpp b/src/test/lib/EventTest.cpp index 64a4d5e8c7..c62db91d7f 100644 --- a/src/test/lib/EventTest.cpp +++ b/src/test/lib/EventTest.cpp @@ -1488,8 +1488,9 @@ QuicTestValidateStreamEvents9( nullptr }); StreamValidator ServerStream( - new(std::nothrow) StreamEventValidator* [5] { + new(std::nothrow) StreamEventValidator* [6] { new(std::nothrow) StreamEventValidator(QUIC_STREAM_EVENT_RECEIVE), + new(std::nothrow) StreamEventValidator(QUIC_STREAM_EVENT_PEER_RELIABLE_ABORT_SEND), new(std::nothrow) StreamEventValidator(QUIC_STREAM_EVENT_PEER_RECEIVE_ABORTED), new(std::nothrow) StreamEventValidator(QUIC_STREAM_EVENT_SEND_SHUTDOWN_COMPLETE), new(std::nothrow) StreamEventValidator(QUIC_STREAM_EVENT_SHUTDOWN_COMPLETE), @@ -1537,7 +1538,7 @@ QuicTestValidateStreamEvents9( QUIC_TEST_LOOPBACK_FOR_AF( QuicAddrGetFamily(&ServerLocalAddr.SockAddr)), ServerLocalAddr.GetPort())); - + TEST_TRUE(Client.HandshakeComplete.WaitTimeout(1000)); CxPlatSleep(200); @@ -1554,13 +1555,13 @@ QuicTestValidateStreamEvents9( uint64_t ReliableOffset = 1; TEST_QUIC_SUCCEEDED( MsQuic->SetParam( - ClientStream.Handle, - QUIC_PARAM_STREAM_RELIABLE_OFFSET, + ClientStream.Handle, + QUIC_PARAM_STREAM_RELIABLE_OFFSET, sizeof(ReliableOffset), &ReliableOffset ) ); - + CxPlatSleep(100); // Wait for the sends to be processed TEST_QUIC_SUCCEEDED( @@ -1568,7 +1569,7 @@ QuicTestValidateStreamEvents9( ClientStream.Handle, QUIC_STREAM_SHUTDOWN_FLAG_ABORT, 0)); - + TEST_TRUE(Client.Complete.WaitTimeout(2000)); TEST_TRUE(Server.Complete.WaitTimeout(1000)); } // Stream scope From 91cc286f12c75686f20e888d01b010b5665650ff Mon Sep 17 00:00:00 2001 From: Jack He Date: Mon, 25 Sep 2023 18:55:15 -0700 Subject: [PATCH 101/123] update tests to adhere to public interface --- src/test/lib/ApiTest.cpp | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/test/lib/ApiTest.cpp b/src/test/lib/ApiTest.cpp index 43afa43e02..989653f5d3 100644 --- a/src/test/lib/ApiTest.cpp +++ b/src/test/lib/ApiTest.cpp @@ -5020,24 +5020,25 @@ void QuicTestStreamParam() &BufferSize, NULL)); + // + // Should return invalid state since we haven't set it yet. + // uint64_t Buffer = 10000; TEST_QUIC_STATUS( - QUIC_STATUS_SUCCESS, + QUIC_STATUS_INVALID_STATE, MsQuic->GetParam( Stream.Handle, QUIC_PARAM_STREAM_RELIABLE_OFFSET, &BufferSize, &Buffer)); - TEST_TRUE(Buffer == 0); Buffer = 10000; TEST_QUIC_STATUS( - QUIC_STATUS_SUCCESS, + QUIC_STATUS_INVALID_STATE, MsQuic->GetParam( Stream.Handle, QUIC_PARAM_STREAM_RELIABLE_OFFSET_RECV, &BufferSize, &Buffer)); - TEST_TRUE(Buffer == 0); } } } From 1bcc0a2bb2cc0ed06d31b5e01f79c95729ca0b78 Mon Sep 17 00:00:00 2001 From: Jack He Date: Tue, 26 Sep 2023 11:46:35 -0700 Subject: [PATCH 102/123] revert brand new event --- src/core/stream_recv.c | 56 ++++++++-------- src/cs/lib/msquic_generated.cs | 22 ------ src/generated/linux/stream_recv.c.clog.h | 64 ++++++------------ .../linux/stream_recv.c.clog.h.lttng.h | 67 ++++++------------- src/inc/msquic.h | 9 --- src/test/lib/DataTest.cpp | 4 +- src/test/lib/EventTest.cpp | 2 +- 7 files changed, 75 insertions(+), 149 deletions(-) diff --git a/src/core/stream_recv.c b/src/core/stream_recv.c index 3f290adc2f..cc0d548440 100644 --- a/src/core/stream_recv.c +++ b/src/core/stream_recv.c @@ -162,6 +162,31 @@ QuicStreamRecvQueueFlush( } } +// +// Deliver a notification to the app that the peer has aborted their send path. +// +_IRQL_requires_max_(PASSIVE_LEVEL) +void +QuicStreamAlertAppPeerSendAborted( + _In_ QUIC_STREAM* Stream, + _In_ QUIC_VAR_INT ErrorCode + ) +{ + QuicTraceLogStreamInfo( + RemoteCloseReset, + Stream, + "Closed remotely (reset)"); + QUIC_STREAM_EVENT Event; + Event.Type = QUIC_STREAM_EVENT_PEER_SEND_ABORTED; + Event.PEER_SEND_ABORTED.ErrorCode = ErrorCode; + QuicTraceLogStreamVerbose( + IndicatePeerSendAbort, + Stream, + "Indicating QUIC_STREAM_EVENT_PEER_SEND_ABORTED (0x%llX)", + ErrorCode); + (void)QuicStreamIndicateEvent(Stream, &Event); +} + // // Processes a received RELIABLE_RESET frame's payload. // @@ -199,20 +224,6 @@ QuicStreamProcessReliableResetFrame( Stream, "Reliable recv offset set to %llu", ReliableOffset); - - // - // Indicate to the app that the peer will abort after having sent and ACK'd ReliableOffset amount of data. - // - QUIC_STREAM_EVENT Event; - Event.Type = QUIC_STREAM_EVENT_PEER_RELIABLE_ABORT_SEND; - Event.PEER_RELIABLE_ABORT_SEND.ReliableSize = ReliableOffset; - Event.PEER_RELIABLE_ABORT_SEND.ErrorCode = ErrorCode; - QuicTraceLogStreamVerbose( - IndicatePeerSendReliableAbort, - Stream, - "Indicating QUIC_STREAM_EVENT_PEER_RELIABLE_ABORT_SEND (0x%llX)", - ErrorCode); - (void)QuicStreamIndicateEvent(Stream, &Event); } if (Stream->RecvBuffer.BaseOffset >= Stream->RecvMaxLength) { @@ -221,6 +232,7 @@ QuicStreamProcessReliableResetFrame( "[strm][%p] Recv State: %hhu", Stream, QuicStreamRecvGetState(Stream)); + QuicStreamAlertAppPeerSendAborted(Stream, ErrorCode); QuicStreamRecvShutdown(Stream, TRUE, ErrorCode); } else { Stream->RecvShutdownErrorCode = ErrorCode; @@ -306,20 +318,7 @@ QuicStreamProcessResetFrame( QuicStreamRecvGetState(Stream)); if (!Stream->Flags.SentStopSending) { - QuicTraceLogStreamInfo( - RemoteCloseReset, - Stream, - "Closed remotely (reset)"); - - QUIC_STREAM_EVENT Event; - Event.Type = QUIC_STREAM_EVENT_PEER_SEND_ABORTED; - Event.PEER_SEND_ABORTED.ErrorCode = ErrorCode; - QuicTraceLogStreamVerbose( - IndicatePeerSendAbort, - Stream, - "Indicating QUIC_STREAM_EVENT_PEER_SEND_ABORTED (0x%llX)", - ErrorCode); - (void)QuicStreamIndicateEvent(Stream, &Event); + QuicStreamAlertAppPeerSendAborted(Stream, ErrorCode); } // @@ -1159,6 +1158,7 @@ QuicStreamReceiveComplete( "[strm][%p] Recv State: %hhu", Stream, QuicStreamRecvGetState(Stream)); + QuicStreamAlertAppPeerSendAborted(Stream, Stream->RecvShutdownErrorCode); QuicStreamRecvShutdown(Stream, TRUE, Stream->RecvShutdownErrorCode); } diff --git a/src/cs/lib/msquic_generated.cs b/src/cs/lib/msquic_generated.cs index 0d6d82d386..ff686c2114 100644 --- a/src/cs/lib/msquic_generated.cs +++ b/src/cs/lib/msquic_generated.cs @@ -2695,7 +2695,6 @@ internal enum QUIC_STREAM_EVENT_TYPE SHUTDOWN_COMPLETE = 7, IDEAL_SEND_BUFFER_SIZE = 8, PEER_ACCEPTED = 9, - PEER_RELIABLE_ABORT_SEND = 10, } internal partial struct QUIC_STREAM_EVENT @@ -2769,14 +2768,6 @@ internal ref _Anonymous_e__Union._IDEAL_SEND_BUFFER_SIZE_e__Struct IDEAL_SEND_BU } } - internal ref _Anonymous_e__Union._PEER_RELIABLE_ABORT_SEND_e__Struct PEER_RELIABLE_ABORT_SEND - { - get - { - return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.PEER_RELIABLE_ABORT_SEND, 1)); - } - } - [StructLayout(LayoutKind.Explicit)] internal partial struct _Anonymous_e__Union { @@ -2812,10 +2803,6 @@ internal partial struct _Anonymous_e__Union [NativeTypeName("struct (anonymous struct)")] internal _IDEAL_SEND_BUFFER_SIZE_e__Struct IDEAL_SEND_BUFFER_SIZE; - [FieldOffset(0)] - [NativeTypeName("struct (anonymous struct)")] - internal _PEER_RELIABLE_ABORT_SEND_e__Struct PEER_RELIABLE_ABORT_SEND; - internal partial struct _START_COMPLETE_e__Struct { [NativeTypeName("HRESULT")] @@ -2973,15 +2960,6 @@ internal partial struct _IDEAL_SEND_BUFFER_SIZE_e__Struct [NativeTypeName("uint64_t")] internal ulong ByteCount; } - - internal partial struct _PEER_RELIABLE_ABORT_SEND_e__Struct - { - [NativeTypeName("QUIC_UINT62")] - internal ulong ErrorCode; - - [NativeTypeName("uint64_t")] - internal ulong ReliableSize; - } } } diff --git a/src/generated/linux/stream_recv.c.clog.h b/src/generated/linux/stream_recv.c.clog.h index 49b186c39d..a8139244e2 100644 --- a/src/generated/linux/stream_recv.c.clog.h +++ b/src/generated/linux/stream_recv.c.clog.h @@ -124,19 +124,17 @@ tracepoint(CLOG_STREAM_RECV_C, ReceiveBeyondFlowControl , arg1);\ /*---------------------------------------------------------- -// Decoder Ring for ReliableRecvOffsetSet -// [strm][%p] Reliable recv offset set to %llu +// Decoder Ring for RemoteCloseReset +// [strm][%p] Closed remotely (reset) // QuicTraceLogStreamInfo( - ReliableRecvOffsetSet, - Stream, - "Reliable recv offset set to %llu", - ReliableOffset); + RemoteCloseReset, + Stream, + "Closed remotely (reset)"); // arg1 = arg1 = Stream = arg1 -// arg3 = arg3 = ReliableOffset = arg3 ----------------------------------------------------------*/ -#ifndef _clog_4_ARGS_TRACE_ReliableRecvOffsetSet -#define _clog_4_ARGS_TRACE_ReliableRecvOffsetSet(uniqueId, arg1, encoded_arg_string, arg3)\ -tracepoint(CLOG_STREAM_RECV_C, ReliableRecvOffsetSet , arg1, arg3);\ +#ifndef _clog_3_ARGS_TRACE_RemoteCloseReset +#define _clog_3_ARGS_TRACE_RemoteCloseReset(uniqueId, arg1, encoded_arg_string)\ +tracepoint(CLOG_STREAM_RECV_C, RemoteCloseReset , arg1);\ #endif @@ -144,17 +142,19 @@ tracepoint(CLOG_STREAM_RECV_C, ReliableRecvOffsetSet , arg1, arg3);\ /*---------------------------------------------------------- -// Decoder Ring for RemoteCloseReset -// [strm][%p] Closed remotely (reset) +// Decoder Ring for ReliableRecvOffsetSet +// [strm][%p] Reliable recv offset set to %llu // QuicTraceLogStreamInfo( - RemoteCloseReset, - Stream, - "Closed remotely (reset)"); + ReliableRecvOffsetSet, + Stream, + "Reliable recv offset set to %llu", + ReliableOffset); // arg1 = arg1 = Stream = arg1 +// arg3 = arg3 = ReliableOffset = arg3 ----------------------------------------------------------*/ -#ifndef _clog_3_ARGS_TRACE_RemoteCloseReset -#define _clog_3_ARGS_TRACE_RemoteCloseReset(uniqueId, arg1, encoded_arg_string)\ -tracepoint(CLOG_STREAM_RECV_C, RemoteCloseReset , arg1);\ +#ifndef _clog_4_ARGS_TRACE_ReliableRecvOffsetSet +#define _clog_4_ARGS_TRACE_ReliableRecvOffsetSet(uniqueId, arg1, encoded_arg_string, arg3)\ +tracepoint(CLOG_STREAM_RECV_C, ReliableRecvOffsetSet , arg1, arg3);\ #endif @@ -215,34 +215,14 @@ tracepoint(CLOG_STREAM_RECV_C, QueueRecvFlush , arg1);\ -/*---------------------------------------------------------- -// Decoder Ring for IndicatePeerSendReliableAbort -// [strm][%p] Indicating QUIC_STREAM_EVENT_PEER_RELIABLE_ABORT_SEND (0x%llX) -// QuicTraceLogStreamVerbose( - IndicatePeerSendReliableAbort, - Stream, - "Indicating QUIC_STREAM_EVENT_PEER_RELIABLE_ABORT_SEND (0x%llX)", - ErrorCode); -// arg1 = arg1 = Stream = arg1 -// arg3 = arg3 = ErrorCode = arg3 -----------------------------------------------------------*/ -#ifndef _clog_4_ARGS_TRACE_IndicatePeerSendReliableAbort -#define _clog_4_ARGS_TRACE_IndicatePeerSendReliableAbort(uniqueId, arg1, encoded_arg_string, arg3)\ -tracepoint(CLOG_STREAM_RECV_C, IndicatePeerSendReliableAbort , arg1, arg3);\ - -#endif - - - - /*---------------------------------------------------------- // Decoder Ring for IndicatePeerSendAbort // [strm][%p] Indicating QUIC_STREAM_EVENT_PEER_SEND_ABORTED (0x%llX) // QuicTraceLogStreamVerbose( - IndicatePeerSendAbort, - Stream, - "Indicating QUIC_STREAM_EVENT_PEER_SEND_ABORTED (0x%llX)", - ErrorCode); + IndicatePeerSendAbort, + Stream, + "Indicating QUIC_STREAM_EVENT_PEER_SEND_ABORTED (0x%llX)", + ErrorCode); // arg1 = arg1 = Stream = arg1 // arg3 = arg3 = ErrorCode = arg3 ----------------------------------------------------------*/ diff --git a/src/generated/linux/stream_recv.c.clog.h.lttng.h b/src/generated/linux/stream_recv.c.clog.h.lttng.h index 4f4ec5d146..c2f849a57f 100644 --- a/src/generated/linux/stream_recv.c.clog.h.lttng.h +++ b/src/generated/linux/stream_recv.c.clog.h.lttng.h @@ -97,42 +97,42 @@ TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, ReceiveBeyondFlowControl, /*---------------------------------------------------------- -// Decoder Ring for ReliableRecvOffsetSet -// [strm][%p] Reliable recv offset set to %llu +// Decoder Ring for RemoteCloseReset +// [strm][%p] Closed remotely (reset) // QuicTraceLogStreamInfo( - ReliableRecvOffsetSet, - Stream, - "Reliable recv offset set to %llu", - ReliableOffset); + RemoteCloseReset, + Stream, + "Closed remotely (reset)"); // arg1 = arg1 = Stream = arg1 -// arg3 = arg3 = ReliableOffset = arg3 ----------------------------------------------------------*/ -TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, ReliableRecvOffsetSet, +TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, RemoteCloseReset, TP_ARGS( - const void *, arg1, - unsigned long long, arg3), + const void *, arg1), TP_FIELDS( ctf_integer_hex(uint64_t, arg1, arg1) - ctf_integer(uint64_t, arg3, arg3) ) ) /*---------------------------------------------------------- -// Decoder Ring for RemoteCloseReset -// [strm][%p] Closed remotely (reset) +// Decoder Ring for ReliableRecvOffsetSet +// [strm][%p] Reliable recv offset set to %llu // QuicTraceLogStreamInfo( - RemoteCloseReset, - Stream, - "Closed remotely (reset)"); + ReliableRecvOffsetSet, + Stream, + "Reliable recv offset set to %llu", + ReliableOffset); // arg1 = arg1 = Stream = arg1 +// arg3 = arg3 = ReliableOffset = arg3 ----------------------------------------------------------*/ -TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, RemoteCloseReset, +TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, ReliableRecvOffsetSet, TP_ARGS( - const void *, arg1), + const void *, arg1, + unsigned long long, arg3), TP_FIELDS( ctf_integer_hex(uint64_t, arg1, arg1) + ctf_integer(uint64_t, arg3, arg3) ) ) @@ -195,37 +195,14 @@ TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, QueueRecvFlush, -/*---------------------------------------------------------- -// Decoder Ring for IndicatePeerSendReliableAbort -// [strm][%p] Indicating QUIC_STREAM_EVENT_PEER_RELIABLE_ABORT_SEND (0x%llX) -// QuicTraceLogStreamVerbose( - IndicatePeerSendReliableAbort, - Stream, - "Indicating QUIC_STREAM_EVENT_PEER_RELIABLE_ABORT_SEND (0x%llX)", - ErrorCode); -// arg1 = arg1 = Stream = arg1 -// arg3 = arg3 = ErrorCode = arg3 -----------------------------------------------------------*/ -TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, IndicatePeerSendReliableAbort, - TP_ARGS( - const void *, arg1, - unsigned long long, arg3), - TP_FIELDS( - ctf_integer_hex(uint64_t, arg1, arg1) - ctf_integer(uint64_t, arg3, arg3) - ) -) - - - /*---------------------------------------------------------- // Decoder Ring for IndicatePeerSendAbort // [strm][%p] Indicating QUIC_STREAM_EVENT_PEER_SEND_ABORTED (0x%llX) // QuicTraceLogStreamVerbose( - IndicatePeerSendAbort, - Stream, - "Indicating QUIC_STREAM_EVENT_PEER_SEND_ABORTED (0x%llX)", - ErrorCode); + IndicatePeerSendAbort, + Stream, + "Indicating QUIC_STREAM_EVENT_PEER_SEND_ABORTED (0x%llX)", + ErrorCode); // arg1 = arg1 = Stream = arg1 // arg3 = arg3 = ErrorCode = arg3 ----------------------------------------------------------*/ diff --git a/src/inc/msquic.h b/src/inc/msquic.h index 8b745addc9..40639485ce 100644 --- a/src/inc/msquic.h +++ b/src/inc/msquic.h @@ -1374,9 +1374,6 @@ typedef enum QUIC_STREAM_EVENT_TYPE { QUIC_STREAM_EVENT_SHUTDOWN_COMPLETE = 7, QUIC_STREAM_EVENT_IDEAL_SEND_BUFFER_SIZE = 8, QUIC_STREAM_EVENT_PEER_ACCEPTED = 9, -#ifdef QUIC_API_ENABLE_PREVIEW_FEATURES - QUIC_STREAM_EVENT_PEER_RELIABLE_ABORT_SEND = 10, -#endif } QUIC_STREAM_EVENT_TYPE; typedef struct QUIC_STREAM_EVENT { @@ -1422,12 +1419,6 @@ typedef struct QUIC_STREAM_EVENT { struct { uint64_t ByteCount; } IDEAL_SEND_BUFFER_SIZE; -#ifdef QUIC_API_ENABLE_PREVIEW_FEATURES - struct { - QUIC_UINT62 ErrorCode; - uint64_t ReliableSize; - } PEER_RELIABLE_ABORT_SEND; -#endif }; } QUIC_STREAM_EVENT; diff --git a/src/test/lib/DataTest.cpp b/src/test/lib/DataTest.cpp index 7d4ddf0ecb..c176baffa0 100644 --- a/src/test/lib/DataTest.cpp +++ b/src/test/lib/DataTest.cpp @@ -3221,8 +3221,8 @@ struct StreamReliableReset { if (Event->Type == QUIC_STREAM_EVENT_RECEIVE) { TestContext->ReceivedBufferSize += Event->RECEIVE.TotalBufferLength; } - if (Event->Type == QUIC_STREAM_EVENT_PEER_RELIABLE_ABORT_SEND) { - TestContext->ShutdownErrorCode = Event->PEER_RELIABLE_ABORT_SEND.ErrorCode; + if (Event->Type == QUIC_STREAM_EVENT_PEER_SEND_ABORTED) { + TestContext->ShutdownErrorCode = Event->PEER_SEND_ABORTED.ErrorCode; } if (Event->Type == QUIC_STREAM_EVENT_SHUTDOWN_COMPLETE) { TestContext->ServerStreamShutdownComplete.Set(); diff --git a/src/test/lib/EventTest.cpp b/src/test/lib/EventTest.cpp index c62db91d7f..9e04980a8f 100644 --- a/src/test/lib/EventTest.cpp +++ b/src/test/lib/EventTest.cpp @@ -1490,7 +1490,7 @@ QuicTestValidateStreamEvents9( StreamValidator ServerStream( new(std::nothrow) StreamEventValidator* [6] { new(std::nothrow) StreamEventValidator(QUIC_STREAM_EVENT_RECEIVE), - new(std::nothrow) StreamEventValidator(QUIC_STREAM_EVENT_PEER_RELIABLE_ABORT_SEND), + new(std::nothrow) StreamEventValidator(QUIC_STREAM_EVENT_PEER_SEND_ABORTED), new(std::nothrow) StreamEventValidator(QUIC_STREAM_EVENT_PEER_RECEIVE_ABORTED), new(std::nothrow) StreamEventValidator(QUIC_STREAM_EVENT_SEND_SHUTDOWN_COMPLETE), new(std::nothrow) StreamEventValidator(QUIC_STREAM_EVENT_SHUTDOWN_COMPLETE), From 54241c39a812f94fffd7d25163b60e47319e2e67 Mon Sep 17 00:00:00 2001 From: Jack He Date: Tue, 26 Sep 2023 12:34:02 -0700 Subject: [PATCH 103/123] add docs for Reliable Reset --- docs/Settings.md | 1 + docs/api/StreamShutdown.md | 5 +++++ 2 files changed, 6 insertions(+) diff --git a/docs/Settings.md b/docs/Settings.md index 36c0349f18..e34a1c1807 100644 --- a/docs/Settings.md +++ b/docs/Settings.md @@ -208,6 +208,7 @@ These parameters are access by calling [GetParam](./api/GetParam.md) or [SetPara | `QUIC_PARAM_STREAM_IDEAL_SEND_BUFFER_SIZE`
2 | uint64_t - bytes | Get-only | Ideal buffer size to queue to the stream. Assumes only one stream sends steadily. | | `QUIC_PARAM_STREAM_PRIORITY`
3 | uint16_t | Get/Set | Stream priority. | | `QUIC_PARAM_STREAM_STATISTICS`
4 | QUIC_STREAM_STATISTICS | Get-only | Stream-level statistics. | +| `QUIC_PARAM_STREAM_RELIABLE_OFFSET`
5 | uint64_t | Get/Set | Part of the new Reliable Reset preview feature. Sets/Gets the number of bytes a sender must send before closing SEND path. ## See Also diff --git a/docs/api/StreamShutdown.md b/docs/api/StreamShutdown.md index b5d58dd390..a0e7e47bec 100644 --- a/docs/api/StreamShutdown.md +++ b/docs/api/StreamShutdown.md @@ -54,6 +54,11 @@ The stream can also be gracefully shutdown via the `QUIC_SEND_FLAG_FIN` flag. Se Any stream (even one that hasn't been started) may be called to shutdown. If the stream has not been started yet, then the shutdown is effectively queued. If the app never calls [StreamStart](StreamStart.md) then the shutdown will never been sent out on the wire. +# Reliable Reset + +If an app decides to enable Preview Features, the shutdown path can be configured with the QUIC_PARAM_STREAM_RELIABLE_OFFSET Stream +Parameter, which determines the amount of bytes a sender must deliver before it can shutdown their SEND path. + # See Also [StreamOpen](StreamOpen.md)
From 31e8364ea2315433d820d5177775118919b07a58 Mon Sep 17 00:00:00 2001 From: "Jack He (Github)" Date: Wed, 27 Sep 2023 10:39:50 -0700 Subject: [PATCH 104/123] Update docs/api/StreamShutdown.md Co-authored-by: Nick Banks --- docs/api/StreamShutdown.md | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/docs/api/StreamShutdown.md b/docs/api/StreamShutdown.md index a0e7e47bec..f6791dce9f 100644 --- a/docs/api/StreamShutdown.md +++ b/docs/api/StreamShutdown.md @@ -56,8 +56,7 @@ Any stream (even one that hasn't been started) may be called to shutdown. If the # Reliable Reset -If an app decides to enable Preview Features, the shutdown path can be configured with the QUIC_PARAM_STREAM_RELIABLE_OFFSET Stream -Parameter, which determines the amount of bytes a sender must deliver before it can shutdown their SEND path. +If an app decides to enable Preview Features, the shutdown path can be configured with the QUIC_PARAM_STREAM_RELIABLE_OFFSET Stream parameter, which determines the number of bytes a sender must deliver before it can shut down their SEND path. # See Also From 4177358327da0904a8d7c662744e0f6478ec547a Mon Sep 17 00:00:00 2001 From: "Jack He (Github)" Date: Wed, 27 Sep 2023 10:42:53 -0700 Subject: [PATCH 105/123] Update src/core/stream_recv.c Co-authored-by: Nick Banks --- src/core/stream_recv.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/core/stream_recv.c b/src/core/stream_recv.c index cc0d548440..4305e2075d 100644 --- a/src/core/stream_recv.c +++ b/src/core/stream_recv.c @@ -173,9 +173,9 @@ QuicStreamAlertAppPeerSendAborted( ) { QuicTraceLogStreamInfo( - RemoteCloseReset, - Stream, - "Closed remotely (reset)"); + RemoteCloseReset, + Stream, + "Closed remotely (reset)"); QUIC_STREAM_EVENT Event; Event.Type = QUIC_STREAM_EVENT_PEER_SEND_ABORTED; Event.PEER_SEND_ABORTED.ErrorCode = ErrorCode; From 7cc1f3feaaf89d918c0ae55bea95a3633024e726 Mon Sep 17 00:00:00 2001 From: "Jack He (Github)" Date: Wed, 27 Sep 2023 10:43:43 -0700 Subject: [PATCH 106/123] Update src/core/stream_send.c Co-authored-by: Nick Banks --- src/core/stream_send.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/core/stream_send.c b/src/core/stream_send.c index bfa2acbc6f..743c98f6df 100644 --- a/src/core/stream_send.c +++ b/src/core/stream_send.c @@ -1624,10 +1624,10 @@ QuicStreamOnResetReliableAck( QuicStreamSendShutdown(Stream, FALSE, TRUE, FALSE, Stream->SendShutdownErrorCode); } else { QuicTraceEvent( - StreamSendState, - "[strm][%p] Send State: %hhu", - Stream, - QuicStreamSendGetState(Stream)); + StreamSendState, + "[strm][%p] Send State: %hhu", + Stream, + QuicStreamSendGetState(Stream)); Stream->Flags.LocalCloseResetReliableAcked = TRUE; } } From c106ceef75b7c6c6768eea64c3d98bb424c00a0a Mon Sep 17 00:00:00 2001 From: "Jack He (Github)" Date: Wed, 27 Sep 2023 10:43:58 -0700 Subject: [PATCH 107/123] Update src/test/lib/ApiTest.cpp Co-authored-by: Nick Banks --- src/test/lib/ApiTest.cpp | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/test/lib/ApiTest.cpp b/src/test/lib/ApiTest.cpp index 989653f5d3..1737d07fb2 100644 --- a/src/test/lib/ApiTest.cpp +++ b/src/test/lib/ApiTest.cpp @@ -4971,8 +4971,6 @@ void QuicTestStreamParam() TEST_EQUAL(Length, sizeof(QUIC_STREAM_STATISTICS)); } } - - // // QUIC_PARAM_STREAM_RELIABLE_OFFSET // QUIC_PARAM_STREAM_RELIABLE_OFFSET_RECV From 1fb82d224df06ee3f8a3796fed6dec76ed383d2d Mon Sep 17 00:00:00 2001 From: "Jack He (Github)" Date: Wed, 27 Sep 2023 10:44:09 -0700 Subject: [PATCH 108/123] Update src/test/lib/DataTest.cpp Co-authored-by: Nick Banks --- src/test/lib/DataTest.cpp | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/test/lib/DataTest.cpp b/src/test/lib/DataTest.cpp index c176baffa0..4818c2067a 100644 --- a/src/test/lib/DataTest.cpp +++ b/src/test/lib/DataTest.cpp @@ -3182,8 +3182,6 @@ QuicTestConnectAndIdleForDestCidChange( #define RELIABLE_SIZE 5000 #define BUFFER_SIZE_MULTI_SENDS 10000 #define RELIABLE_SIZE_MULTI_SENDS 20000 - - // // These Context Structs are useful helpers for the StreamReliableReset test suite. // It keeps track of the order of absolute offsets of all the send requests received, and the total number of bytes received. From 0000359604e9ecf51252fef92aeaa2478b939701 Mon Sep 17 00:00:00 2001 From: "Jack He (Github)" Date: Wed, 27 Sep 2023 10:44:38 -0700 Subject: [PATCH 109/123] Update src/test/lib/DataTest.cpp Co-authored-by: Nick Banks --- src/test/lib/DataTest.cpp | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/test/lib/DataTest.cpp b/src/test/lib/DataTest.cpp index 4818c2067a..e073365b42 100644 --- a/src/test/lib/DataTest.cpp +++ b/src/test/lib/DataTest.cpp @@ -3198,8 +3198,6 @@ struct StreamReliableReset { uint64_t ReceivedBufferSize; uint64_t SequenceNum; QUIC_UINT62 ShutdownErrorCode; - - static QUIC_STATUS ClientStreamCallback(_In_ MsQuicStream*, _In_opt_ void* ClientContext, _Inout_ QUIC_STREAM_EVENT* Event) { auto TestContext = (StreamReliableReset*)ClientContext; if (Event->Type == QUIC_STREAM_EVENT_SHUTDOWN_COMPLETE) { From c8fe100469408e0198287b5e7dc1cae6bb7f3d7e Mon Sep 17 00:00:00 2001 From: "Jack He (Github)" Date: Wed, 27 Sep 2023 10:45:54 -0700 Subject: [PATCH 110/123] Update src/test/lib/DataTest.cpp Co-authored-by: Nick Banks --- src/test/lib/DataTest.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/test/lib/DataTest.cpp b/src/test/lib/DataTest.cpp index e073365b42..071b7bbf3e 100644 --- a/src/test/lib/DataTest.cpp +++ b/src/test/lib/DataTest.cpp @@ -3203,7 +3203,7 @@ struct StreamReliableReset { if (Event->Type == QUIC_STREAM_EVENT_SHUTDOWN_COMPLETE) { TestContext->ClientStreamShutdownComplete.Set(); } - // Get the send context of the Event + // Get the send context of the Event if (Event->Type == QUIC_STREAM_EVENT_SEND_COMPLETE) { auto Context = (SendContext*)Event->SEND_COMPLETE.ClientContext; Context->Successful = Event->SEND_COMPLETE.Canceled == FALSE; From 8d63d3e241405be6df86c6dd30ca605989dcf672 Mon Sep 17 00:00:00 2001 From: "Jack He (Github)" Date: Wed, 27 Sep 2023 10:46:16 -0700 Subject: [PATCH 111/123] Update src/test/lib/DataTest.cpp Co-authored-by: Nick Banks --- src/test/lib/DataTest.cpp | 1 - 1 file changed, 1 deletion(-) diff --git a/src/test/lib/DataTest.cpp b/src/test/lib/DataTest.cpp index 071b7bbf3e..617a988ded 100644 --- a/src/test/lib/DataTest.cpp +++ b/src/test/lib/DataTest.cpp @@ -3239,7 +3239,6 @@ void QuicTestStreamReliableReset( ) { - MsQuicRegistration Registration(true); TEST_TRUE(Registration.IsValid()); From 094bc8f3287e00df4960b6955c04ad72e7b6eed3 Mon Sep 17 00:00:00 2001 From: Jack He Date: Wed, 27 Sep 2023 10:53:22 -0700 Subject: [PATCH 112/123] improve recv comment --- src/core/stream_recv.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/core/stream_recv.c b/src/core/stream_recv.c index 4305e2075d..743bcb0af3 100644 --- a/src/core/stream_recv.c +++ b/src/core/stream_recv.c @@ -1151,7 +1151,8 @@ QuicStreamReceiveComplete( else if (Stream->Flags.RemoteCloseResetReliable && Stream->RecvBuffer.BaseOffset >= Stream->RecvMaxLength) { // - // ReliableReset + // ReliableReset was initiated by the peer, and we sent enough data to the app, we can alert the app + // we're done and shutdown the RECV direction of this stream. // QuicTraceEvent( StreamRecvState, From fdc78abe16e9e07e3cbe6e9f8133888186737de7 Mon Sep 17 00:00:00 2001 From: Jack He Date: Wed, 27 Sep 2023 11:38:19 -0700 Subject: [PATCH 113/123] clean up code --- src/core/stream_send.c | 4 ---- src/test/lib/EventTest.cpp | 5 +++-- 2 files changed, 3 insertions(+), 6 deletions(-) diff --git a/src/core/stream_send.c b/src/core/stream_send.c index 743c98f6df..17519272fc 100644 --- a/src/core/stream_send.c +++ b/src/core/stream_send.c @@ -1537,7 +1537,6 @@ QuicStreamOnAck( Stream, QuicStreamSendGetState(Stream)); QuicStreamCleanupReliableReset(Stream); - Stream->Flags.LocalCloseReset = TRUE; QuicStreamSendShutdown(Stream, FALSE, TRUE, FALSE, Stream->SendShutdownErrorCode); } @@ -1612,15 +1611,12 @@ QuicStreamOnResetReliableAck( if (Stream->UnAckedOffset >= Stream->ReliableOffsetSend && !Stream->Flags.LocalCloseAcked) { Stream->Flags.LocalCloseResetReliableAcked = TRUE; - Stream->Flags.LocalCloseAcked = TRUE; - Stream->Flags.RemoteCloseAcked = TRUE; QuicTraceEvent( StreamSendState, "[strm][%p] Send State: %hhu", Stream, QuicStreamSendGetState(Stream)); QuicStreamCleanupReliableReset(Stream); - Stream->Flags.LocalCloseReset = TRUE; QuicStreamSendShutdown(Stream, FALSE, TRUE, FALSE, Stream->SendShutdownErrorCode); } else { QuicTraceEvent( diff --git a/src/test/lib/EventTest.cpp b/src/test/lib/EventTest.cpp index 9e04980a8f..bade9c0dc0 100644 --- a/src/test/lib/EventTest.cpp +++ b/src/test/lib/EventTest.cpp @@ -1481,9 +1481,10 @@ QuicTestValidateStreamEvents9( { // Stream scope StreamValidator ClientStream( - new(std::nothrow) StreamEventValidator* [4] { + new(std::nothrow) StreamEventValidator* [5] { new(std::nothrow) StreamStartCompleteEventValidator(), new(std::nothrow) StreamEventValidator(QUIC_STREAM_EVENT_SEND_COMPLETE, 0, true), + new(std::nothrow) StreamEventValidator(QUIC_STREAM_EVENT_SEND_SHUTDOWN_COMPLETE), new(std::nothrow) StreamEventValidator(QUIC_STREAM_EVENT_SHUTDOWN_COMPLETE, QUIC_EVENT_ACTION_SHUTDOWN_CONNECTION), nullptr }); @@ -1509,7 +1510,7 @@ QuicTestValidateStreamEvents9( nullptr }); Server.SetExpectedEvents( - new(std::nothrow) ConnEventValidator* [7] { + new(std::nothrow) ConnEventValidator* [6] { new(std::nothrow) ConnEventValidator(QUIC_CONNECTION_EVENT_RELIABLE_RESET_NEGOTIATED), new(std::nothrow) ConnEventValidator(QUIC_CONNECTION_EVENT_CONNECTED), new(std::nothrow) NewStreamEventValidator(&ServerStream), From c21430d6502c40bb0d1e26c23e06ee8b54aad2b4 Mon Sep 17 00:00:00 2001 From: Jack He Date: Wed, 27 Sep 2023 15:27:13 -0700 Subject: [PATCH 114/123] update man pages and C hashtag (sharp) code --- src/generated/linux/stream_recv.c.clog.h | 6 ++--- .../linux/stream_recv.c.clog.h.lttng.h | 6 ++--- src/manifest/MsQuicEtw.man | 24 +++++++++++++++++++ src/plugins/trace/dll/DataModel/QuicEvents.cs | 7 ++++-- src/plugins/trace/dll/DataModel/QuicStream.cs | 4 ++-- 5 files changed, 37 insertions(+), 10 deletions(-) diff --git a/src/generated/linux/stream_recv.c.clog.h b/src/generated/linux/stream_recv.c.clog.h index a8139244e2..57e768e3f0 100644 --- a/src/generated/linux/stream_recv.c.clog.h +++ b/src/generated/linux/stream_recv.c.clog.h @@ -127,9 +127,9 @@ tracepoint(CLOG_STREAM_RECV_C, ReceiveBeyondFlowControl , arg1);\ // Decoder Ring for RemoteCloseReset // [strm][%p] Closed remotely (reset) // QuicTraceLogStreamInfo( - RemoteCloseReset, - Stream, - "Closed remotely (reset)"); + RemoteCloseReset, + Stream, + "Closed remotely (reset)"); // arg1 = arg1 = Stream = arg1 ----------------------------------------------------------*/ #ifndef _clog_3_ARGS_TRACE_RemoteCloseReset diff --git a/src/generated/linux/stream_recv.c.clog.h.lttng.h b/src/generated/linux/stream_recv.c.clog.h.lttng.h index c2f849a57f..87d5cf587b 100644 --- a/src/generated/linux/stream_recv.c.clog.h.lttng.h +++ b/src/generated/linux/stream_recv.c.clog.h.lttng.h @@ -100,9 +100,9 @@ TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, ReceiveBeyondFlowControl, // Decoder Ring for RemoteCloseReset // [strm][%p] Closed remotely (reset) // QuicTraceLogStreamInfo( - RemoteCloseReset, - Stream, - "Closed remotely (reset)"); + RemoteCloseReset, + Stream, + "Closed remotely (reset)"); // arg1 = arg1 = Stream = arg1 ----------------------------------------------------------*/ TRACEPOINT_EVENT(CLOG_STREAM_RECV_C, RemoteCloseReset, diff --git a/src/manifest/MsQuicEtw.man b/src/manifest/MsQuicEtw.man index 3ee4917c47..83741b35f1 100644 --- a/src/manifest/MsQuicEtw.man +++ b/src/manifest/MsQuicEtw.man @@ -308,6 +308,14 @@ message="$(string.Enum.QUIC_STREAM_SEND_STATE.FIN_ACKED)" value="5" /> + + + + + + Date: Thu, 28 Sep 2023 10:02:24 -0700 Subject: [PATCH 115/123] Update src/core/stream_recv.c Co-authored-by: Nick Banks --- src/core/stream_recv.c | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/src/core/stream_recv.c b/src/core/stream_recv.c index 743bcb0af3..3061e8b3da 100644 --- a/src/core/stream_recv.c +++ b/src/core/stream_recv.c @@ -1147,9 +1147,7 @@ QuicStreamReceiveComplete( &Stream->Connection->Send, Stream, QUIC_STREAM_SEND_FLAG_MAX_DATA | QUIC_STREAM_SEND_FLAG_RECV_ABORT); - } - - else if (Stream->Flags.RemoteCloseResetReliable && Stream->RecvBuffer.BaseOffset >= Stream->RecvMaxLength) { + } else if (Stream->Flags.RemoteCloseResetReliable && Stream->RecvBuffer.BaseOffset >= Stream->RecvMaxLength) { // // ReliableReset was initiated by the peer, and we sent enough data to the app, we can alert the app // we're done and shutdown the RECV direction of this stream. From c4a1de7f0fe348d6b225db9f4ff78a135cf11fc5 Mon Sep 17 00:00:00 2001 From: Jack He Date: Thu, 28 Sep 2023 10:15:26 -0700 Subject: [PATCH 116/123] rename and add comment --- src/core/stream_recv.c | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/src/core/stream_recv.c b/src/core/stream_recv.c index 743bcb0af3..20d5202955 100644 --- a/src/core/stream_recv.c +++ b/src/core/stream_recv.c @@ -167,7 +167,7 @@ QuicStreamRecvQueueFlush( // _IRQL_requires_max_(PASSIVE_LEVEL) void -QuicStreamAlertAppPeerSendAborted( +QuicStreamIndicatePeerSendAbortedEvent( _In_ QUIC_STREAM* Stream, _In_ QUIC_VAR_INT ErrorCode ) @@ -232,9 +232,12 @@ QuicStreamProcessReliableResetFrame( "[strm][%p] Recv State: %hhu", Stream, QuicStreamRecvGetState(Stream)); - QuicStreamAlertAppPeerSendAborted(Stream, ErrorCode); + QuicStreamIndicatePeerSendAbortedEvent(Stream, ErrorCode); QuicStreamRecvShutdown(Stream, TRUE, ErrorCode); } else { + // + // We still have data to deliver to the app, just cache the error code for later. + // Stream->RecvShutdownErrorCode = ErrorCode; } } @@ -318,7 +321,7 @@ QuicStreamProcessResetFrame( QuicStreamRecvGetState(Stream)); if (!Stream->Flags.SentStopSending) { - QuicStreamAlertAppPeerSendAborted(Stream, ErrorCode); + QuicStreamIndicatePeerSendAbortedEvent(Stream, ErrorCode); } // @@ -1159,7 +1162,7 @@ QuicStreamReceiveComplete( "[strm][%p] Recv State: %hhu", Stream, QuicStreamRecvGetState(Stream)); - QuicStreamAlertAppPeerSendAborted(Stream, Stream->RecvShutdownErrorCode); + QuicStreamIndicatePeerSendAbortedEvent(Stream, Stream->RecvShutdownErrorCode); QuicStreamRecvShutdown(Stream, TRUE, Stream->RecvShutdownErrorCode); } From e3eabc54278f4cfe13ed2edaaa0050c0530a8406 Mon Sep 17 00:00:00 2001 From: Jack He Date: Thu, 28 Sep 2023 10:53:43 -0700 Subject: [PATCH 117/123] update hasstreamcontrolframes --- src/core/send.h | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/core/send.h b/src/core/send.h index 1568fee19a..5ccb148775 100644 --- a/src/core/send.h +++ b/src/core/send.h @@ -212,7 +212,8 @@ inline BOOLEAN HasStreamControlFrames(uint32_t Flags) (QUIC_STREAM_SEND_FLAG_DATA_BLOCKED | QUIC_STREAM_SEND_FLAG_MAX_DATA | QUIC_STREAM_SEND_FLAG_SEND_ABORT | - QUIC_STREAM_SEND_FLAG_RECV_ABORT); + QUIC_STREAM_SEND_FLAG_RECV_ABORT | + QUIC_STREAM_SEND_FLAG_RELIABLE_ABORT); } inline BOOLEAN HasStreamDataFrames(uint32_t Flags) From da57e637f28a8995412fc2d39ba2d264948d792f Mon Sep 17 00:00:00 2001 From: Jack He Date: Thu, 28 Sep 2023 15:12:25 -0700 Subject: [PATCH 118/123] reset > reset reliable --- src/core/stream_recv.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/core/stream_recv.c b/src/core/stream_recv.c index c6a8384a46..a50ea255cd 100644 --- a/src/core/stream_recv.c +++ b/src/core/stream_recv.c @@ -347,7 +347,7 @@ QuicStreamProcessStopSendingFrame( _In_ QUIC_VAR_INT ErrorCode ) { - if (!Stream->Flags.LocalCloseAcked && !Stream->Flags.LocalCloseReset && !Stream->Flags.LocalCloseResetReliable) { + if (!Stream->Flags.LocalCloseAcked && !Stream->Flags.LocalCloseReset) { // // The STOP_SENDING frame only triggers a state change if we aren't // completely closed gracefully (i.e. our close has been acknowledged) From a33c3368bdceb97f6fc6a4e66be7776dfb53bd1f Mon Sep 17 00:00:00 2001 From: Jack He Date: Thu, 28 Sep 2023 17:15:39 -0700 Subject: [PATCH 119/123] make comment more readable --- src/core/stream_send.c | 1 + 1 file changed, 1 insertion(+) diff --git a/src/core/stream_send.c b/src/core/stream_send.c index 17519272fc..042e6c7028 100644 --- a/src/core/stream_send.c +++ b/src/core/stream_send.c @@ -162,6 +162,7 @@ QuicStreamSendShutdown( } else if (Stream->ReliableOffsetSend == 0 || Stream->Flags.LocalCloseResetReliable) { // // Enter abortive branch if we are not aborting reliablely or we have done it already. + // Essentially, Reset trumps Reliable Reset, so if we have to call shutdown again, we reset. // // From da323507b41100e782a03d3fd484d4013fb0de1f Mon Sep 17 00:00:00 2001 From: "Jack He (Github)" Date: Fri, 29 Sep 2023 12:49:51 -0700 Subject: [PATCH 120/123] Update src/test/MsQuicTests.h Co-authored-by: Nick Banks --- src/test/MsQuicTests.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/test/MsQuicTests.h b/src/test/MsQuicTests.h index 0a0f367d7e..bad1f1eb7f 100644 --- a/src/test/MsQuicTests.h +++ b/src/test/MsQuicTests.h @@ -550,7 +550,7 @@ QuicTestStreamReliableReset( void QuicTestStreamReliableResetMultipleSends( -); + ); void QuicTestStreamBlockUnblockConnFlowControl( From 4e7f90c09d3c06bfdf68b7c9289bcd39ae25c3ed Mon Sep 17 00:00:00 2001 From: "Jack He (Github)" Date: Fri, 29 Sep 2023 12:50:05 -0700 Subject: [PATCH 121/123] Update src/test/MsQuicTests.h Co-authored-by: Nick Banks --- src/test/MsQuicTests.h | 1 - 1 file changed, 1 deletion(-) diff --git a/src/test/MsQuicTests.h b/src/test/MsQuicTests.h index bad1f1eb7f..acf746bbc2 100644 --- a/src/test/MsQuicTests.h +++ b/src/test/MsQuicTests.h @@ -1224,7 +1224,6 @@ typedef struct { QUIC_CTL_CODE(112, METHOD_BUFFERED, FILE_WRITE_DATA) // QUIC_RUN_FEATURE_NEGOTIATION - #define IOCTL_QUIC_RUN_STATELESS_RESET_KEY \ QUIC_CTL_CODE(113, METHOD_BUFFERED, FILE_WRITE_DATA) From e5d64118e8fcda55c30b2b064473b80b4e28712b Mon Sep 17 00:00:00 2001 From: "Jack He (Github)" Date: Fri, 29 Sep 2023 12:50:16 -0700 Subject: [PATCH 122/123] Update src/test/MsQuicTests.h Co-authored-by: Nick Banks --- src/test/MsQuicTests.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/test/MsQuicTests.h b/src/test/MsQuicTests.h index acf746bbc2..29d9a40144 100644 --- a/src/test/MsQuicTests.h +++ b/src/test/MsQuicTests.h @@ -1227,7 +1227,7 @@ typedef struct { #define IOCTL_QUIC_RUN_STATELESS_RESET_KEY \ QUIC_CTL_CODE(113, METHOD_BUFFERED, FILE_WRITE_DATA) - #define IOCTL_QUIC_RUN_STREAM_RELIABLE_RESET \ +#define IOCTL_QUIC_RUN_STREAM_RELIABLE_RESET \ QUIC_CTL_CODE(114, METHOD_BUFFERED, FILE_WRITE_DATA) #define IOCTL_QUIC_RUN_STREAM_RELIABLE_RESET_MULTIPLE_SENDS \ From 9a2318eb60e4f6508ea6c9e3e6efb0cd04c79eca Mon Sep 17 00:00:00 2001 From: "Jack He (Github)" Date: Fri, 29 Sep 2023 12:50:38 -0700 Subject: [PATCH 123/123] Update src/test/bin/winkernel/control.cpp Co-authored-by: Nick Banks --- src/test/bin/winkernel/control.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/test/bin/winkernel/control.cpp b/src/test/bin/winkernel/control.cpp index a65e9f96c4..3f6285fa64 100644 --- a/src/test/bin/winkernel/control.cpp +++ b/src/test/bin/winkernel/control.cpp @@ -486,7 +486,7 @@ size_t QUIC_IOCTL_BUFFER_SIZES[] = sizeof(QUIC_RUN_FEATURE_NEGOTIATION), 0, 0, - 0 + 0, }; CXPLAT_STATIC_ASSERT(