Enforce 64KB event payload size limit on EventPipe

src/native/eventpipe/ep-buffer-manager.c

@@ -897,6 +897,9 @@ ep_buffer_manager_write_event (
 	// Before we pick a buffer, make sure the event is enabled.
 	ep_return_false_if_nok (ep_event_is_enabled (ep_event));
 
+	// Check that the payload size is less than 64 KB (max size for ETW events)
+	ep_return_false_if_nok (ep_event_payload_get_size (payload) <= 64 * 1024);
+
 	// Check to see an event thread was specified. If not, then use the current thread.
 	if (event_thread == NULL)
 		event_thread = thread;

src/native/eventpipe/ep-file.c

@@ -317,7 +317,7 @@ ep_file_alloc (
 	instance->stream_writer = stream_writer;
 	instance->format = format;
 
-	instance->event_block = ep_event_block_alloc (100 * 1024, format);
+	instance->event_block = ep_event_block_alloc (1024 * 1024, format);
 	ep_raise_error_if_nok (instance->event_block != NULL);
 
 	instance->metadata_block = ep_metadata_block_alloc (100 * 1024);

src/tests/tracing/eventpipe/bigevent/bigevent.cs

@@ -0,0 +1,89 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Diagnostics.Tracing;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Collections.Generic;
+using Microsoft.Diagnostics.Tools.RuntimeClient;
+using Microsoft.Diagnostics.Tracing;
+using Tracing.Tests.Common;
+using Microsoft.Diagnostics.Tracing.Parsers.Clr;
+
+namespace Tracing.Tests.BigEventsValidation
+{
+
+    public sealed class BigEventSource : EventSource
+    {
+        private static string bigString = new String('a', 100 * 1024);
+        private static string smallString = new String('a', 10);
+
+        private BigEventSource()
+        {
+        }
+
+        public static BigEventSource Log = new BigEventSource();
+
+        public void BigEvent()
+        {
+            WriteEvent(1, bigString);        
+        }
+
+        public void SmallEvent()
+        {
+            WriteEvent(2, smallString);
+        }
+    }
+
+
+    public class BigEventsValidation
+    {
+        public static int Main(string[] args)
+        {
+            // This test tries to send a big event (>100KB) and checks that the app does not crash
+            // See https://github.com/dotnet/runtime/issues/50515 for the regression issue
+            var providers = new List<Provider>()
+            {
+                new Provider("BigEventSource")
+            };
+
+            var configuration = new SessionConfiguration(circularBufferSizeMB: 1024, format: EventPipeSerializationFormat.NetTrace,  providers: providers);
+            return IpcTraceTest.RunAndValidateEventCounts(_expectedEventCounts, _eventGeneratingAction, configuration, _Verify);
+        }
+
+        private static Dictionary<string, ExpectedEventCount> _expectedEventCounts = new Dictionary<string, ExpectedEventCount>()
+        {
+            { "BigEventSource", -1 }
+        };
+
+        private static Action _eventGeneratingAction = () => 
+        {
+            // Write 10 big events
+            for (int i = 0; i < 10; i++)
+            {
+                BigEventSource.Log.BigEvent();
+            }
+            // Write 10 small events
+            for (int i = 0; i < 10; i++)
+            {
+                BigEventSource.Log.SmallEvent();
+            }
+        };
+
+        private static Func<EventPipeEventSource, Func<int>> _Verify = (source) =>
+        {
+            bool hasSmallEvent = false;
+            source.Dynamic.All += (TraceEvent data) =>
+            {
+                if (data.EventName == "SmallEvent")
+                {
+                    hasSmallEvent = true;
+                }
+            };
+            return () => hasSmallEvent ? 100 : -1;
+        };
+    }
+}

src/tests/tracing/eventpipe/bigevent/bigevent.csproj

@@ -0,0 +1,15 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFrameworkIdentifier>.NETCoreApp</TargetFrameworkIdentifier>
+    <OutputType>exe</OutputType>
+    <CLRTestKind>BuildAndRun</CLRTestKind>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <CLRTestPriority>0</CLRTestPriority>
+    <JitOptimizationSensitive>true</JitOptimizationSensitive>
+    <UnloadabilityIncompatible>true</UnloadabilityIncompatible>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="$(MSBuildProjectName).cs" />
+    <ProjectReference Include="../common/common.csproj" />
+  </ItemGroup>
+</Project>