UefiCpuPkg CpuCommFeaturesLib: Disable TraceEn at the beginning
[mirror_edk2.git] / UefiCpuPkg / Library / CpuCommonFeaturesLib / ProcTrace.c
1 /** @file\r
2   Intel Processor Trace feature.\r
3 \r
4   Copyright (c) 2017 - 2018, Intel Corporation. All rights reserved.<BR>\r
5   SPDX-License-Identifier: BSD-2-Clause-Patent\r
6 \r
7 **/\r
8 \r
9 #include "CpuCommonFeatures.h"\r
10 \r
11 ///\r
12 /// This macro define the max entries in the Topa table.\r
13 /// Each entry in the table contains some attribute bits, a pointer to an output region, and the size of the region.\r
14 /// The last entry in the table may hold a pointer to the next table. This pointer can either point to the top of the\r
15 /// current table (for circular array) or to the base of another table.\r
16 /// At least 2 entries are needed because the list of entries must\r
17 /// be terminated by an entry with the END bit set to 1, so 2\r
18 /// entries are required to use a single valid entry.\r
19 ///\r
20 #define MAX_TOPA_ENTRY_COUNT         2\r
21 \r
22 \r
23 ///\r
24 /// Processor trace output scheme selection.\r
25 ///\r
26 typedef enum {\r
27   RtitOutputSchemeSingleRange = 0,\r
28   RtitOutputSchemeToPA\r
29 } RTIT_OUTPUT_SCHEME;\r
30 \r
31 typedef struct  {\r
32   BOOLEAN  ProcTraceSupported;\r
33   BOOLEAN  TopaSupported;\r
34   BOOLEAN  SingleRangeSupported;\r
35 } PROC_TRACE_PROCESSOR_DATA;\r
36 \r
37 typedef struct  {\r
38   UINT32                      NumberOfProcessors;\r
39 \r
40   UINT8                       ProcTraceOutputScheme;\r
41   UINT32                      ProcTraceMemSize;\r
42 \r
43   UINTN                       *ThreadMemRegionTable;\r
44   UINTN                       AllocatedThreads;\r
45 \r
46   UINTN                       *TopaMemArray;\r
47   UINTN                       TopaMemArrayCount;\r
48 \r
49   PROC_TRACE_PROCESSOR_DATA   *ProcessorData;\r
50 } PROC_TRACE_DATA;\r
51 \r
52 typedef struct {\r
53   RTIT_TOPA_TABLE_ENTRY    TopaEntry[MAX_TOPA_ENTRY_COUNT];\r
54 } PROC_TRACE_TOPA_TABLE;\r
55 \r
56 /**\r
57   Prepares for the data used by CPU feature detection and initialization.\r
58 \r
59   @param[in]  NumberOfProcessors  The number of CPUs in the platform.\r
60 \r
61   @return  Pointer to a buffer of CPU related configuration data.\r
62 \r
63   @note This service could be called by BSP only.\r
64 **/\r
65 VOID *\r
66 EFIAPI\r
67 ProcTraceGetConfigData (\r
68   IN UINTN  NumberOfProcessors\r
69   )\r
70 {\r
71   PROC_TRACE_DATA  *ConfigData;\r
72 \r
73   ConfigData = AllocateZeroPool (sizeof (PROC_TRACE_DATA) + sizeof (PROC_TRACE_PROCESSOR_DATA) * NumberOfProcessors);\r
74   ASSERT (ConfigData != NULL);\r
75   ConfigData->ProcessorData = (PROC_TRACE_PROCESSOR_DATA *) ((UINT8*) ConfigData + sizeof (PROC_TRACE_DATA));\r
76 \r
77   ConfigData->NumberOfProcessors = (UINT32) NumberOfProcessors;\r
78   ConfigData->ProcTraceMemSize = PcdGet32 (PcdCpuProcTraceMemSize);\r
79   ConfigData->ProcTraceOutputScheme = PcdGet8 (PcdCpuProcTraceOutputScheme);\r
80 \r
81   return ConfigData;\r
82 }\r
83 \r
84 /**\r
85   Detects if Intel Processor Trace feature supported on current\r
86   processor.\r
87 \r
88   @param[in]  ProcessorNumber  The index of the CPU executing this function.\r
89   @param[in]  CpuInfo          A pointer to the REGISTER_CPU_FEATURE_INFORMATION\r
90                                structure for the CPU executing this function.\r
91   @param[in]  ConfigData       A pointer to the configuration buffer returned\r
92                                by CPU_FEATURE_GET_CONFIG_DATA.  NULL if\r
93                                CPU_FEATURE_GET_CONFIG_DATA was not provided in\r
94                                RegisterCpuFeature().\r
95 \r
96   @retval TRUE     Processor Trace feature is supported.\r
97   @retval FALSE    Processor Trace feature is not supported.\r
98 \r
99   @note This service could be called by BSP/APs.\r
100 **/\r
101 BOOLEAN\r
102 EFIAPI\r
103 ProcTraceSupport (\r
104   IN UINTN                             ProcessorNumber,\r
105   IN REGISTER_CPU_FEATURE_INFORMATION  *CpuInfo,\r
106   IN VOID                              *ConfigData  OPTIONAL\r
107   )\r
108 {\r
109   PROC_TRACE_DATA                             *ProcTraceData;\r
110   CPUID_STRUCTURED_EXTENDED_FEATURE_FLAGS_EBX Ebx;\r
111   CPUID_INTEL_PROCESSOR_TRACE_MAIN_LEAF_ECX   Ecx;\r
112 \r
113   //\r
114   // Check if ProcTraceMemorySize option is enabled (0xFF means disable by user)\r
115   //\r
116   ProcTraceData = (PROC_TRACE_DATA *) ConfigData;\r
117   ASSERT (ProcTraceData != NULL);\r
118   if ((ProcTraceData->ProcTraceMemSize > RtitTopaMemorySize128M) ||\r
119       (ProcTraceData->ProcTraceOutputScheme > RtitOutputSchemeToPA)) {\r
120     return FALSE;\r
121   }\r
122 \r
123   //\r
124   // Check if Processor Trace is supported\r
125   //\r
126   AsmCpuidEx (CPUID_STRUCTURED_EXTENDED_FEATURE_FLAGS, 0, NULL, &Ebx.Uint32, NULL, NULL);\r
127   ProcTraceData->ProcessorData[ProcessorNumber].ProcTraceSupported = (BOOLEAN) (Ebx.Bits.IntelProcessorTrace == 1);\r
128   if (!ProcTraceData->ProcessorData[ProcessorNumber].ProcTraceSupported) {\r
129     return FALSE;\r
130   }\r
131 \r
132   AsmCpuidEx (CPUID_INTEL_PROCESSOR_TRACE, CPUID_INTEL_PROCESSOR_TRACE_MAIN_LEAF, NULL, NULL, &Ecx.Uint32, NULL);\r
133   ProcTraceData->ProcessorData[ProcessorNumber].TopaSupported = (BOOLEAN) (Ecx.Bits.RTIT == 1);\r
134   ProcTraceData->ProcessorData[ProcessorNumber].SingleRangeSupported = (BOOLEAN) (Ecx.Bits.SingleRangeOutput == 1);\r
135   if ((ProcTraceData->ProcessorData[ProcessorNumber].TopaSupported && (ProcTraceData->ProcTraceOutputScheme == RtitOutputSchemeToPA)) ||\r
136       (ProcTraceData->ProcessorData[ProcessorNumber].SingleRangeSupported && (ProcTraceData->ProcTraceOutputScheme == RtitOutputSchemeSingleRange))) {\r
137     return TRUE;\r
138   }\r
139 \r
140   return FALSE;\r
141 }\r
142 \r
143 /**\r
144   Initializes Intel Processor Trace feature to specific state.\r
145 \r
146   @param[in]  ProcessorNumber  The index of the CPU executing this function.\r
147   @param[in]  CpuInfo          A pointer to the REGISTER_CPU_FEATURE_INFORMATION\r
148                                structure for the CPU executing this function.\r
149   @param[in]  ConfigData       A pointer to the configuration buffer returned\r
150                                by CPU_FEATURE_GET_CONFIG_DATA.  NULL if\r
151                                CPU_FEATURE_GET_CONFIG_DATA was not provided in\r
152                                RegisterCpuFeature().\r
153   @param[in]  State            If TRUE, then the Processor Trace feature must be\r
154                                enabled.\r
155                                If FALSE, then the Processor Trace feature must be\r
156                                disabled.\r
157 \r
158   @retval RETURN_SUCCESS       Intel Processor Trace feature is initialized.\r
159 \r
160 **/\r
161 RETURN_STATUS\r
162 EFIAPI\r
163 ProcTraceInitialize (\r
164   IN UINTN                             ProcessorNumber,\r
165   IN REGISTER_CPU_FEATURE_INFORMATION  *CpuInfo,\r
166   IN VOID                              *ConfigData,  OPTIONAL\r
167   IN BOOLEAN                           State\r
168   )\r
169 {\r
170   UINT32                               MemRegionSize;\r
171   UINTN                                Pages;\r
172   UINTN                                Alignment;\r
173   UINTN                                MemRegionBaseAddr;\r
174   UINTN                                *ThreadMemRegionTable;\r
175   UINTN                                Index;\r
176   UINTN                                TopaTableBaseAddr;\r
177   UINTN                                AlignedAddress;\r
178   UINTN                                *TopaMemArray;\r
179   PROC_TRACE_TOPA_TABLE                *TopaTable;\r
180   PROC_TRACE_DATA                      *ProcTraceData;\r
181   BOOLEAN                              FirstIn;\r
182   MSR_IA32_RTIT_CTL_REGISTER           CtrlReg;\r
183   MSR_IA32_RTIT_STATUS_REGISTER        StatusReg;\r
184   MSR_IA32_RTIT_OUTPUT_BASE_REGISTER   OutputBaseReg;\r
185   MSR_IA32_RTIT_OUTPUT_MASK_PTRS_REGISTER  OutputMaskPtrsReg;\r
186   RTIT_TOPA_TABLE_ENTRY                *TopaEntryPtr;\r
187 \r
188   //\r
189   // The scope of the MSR_IA32_RTIT_* is core for below processor type, only program\r
190   // MSR_IA32_RTIT_* for thread 0 in each core.\r
191   //\r
192   if (IS_GOLDMONT_PROCESSOR (CpuInfo->DisplayFamily, CpuInfo->DisplayModel) ||\r
193       IS_GOLDMONT_PLUS_PROCESSOR (CpuInfo->DisplayFamily, CpuInfo->DisplayModel)) {\r
194     if (CpuInfo->ProcessorInfo.Location.Thread != 0) {\r
195       return RETURN_SUCCESS;\r
196     }\r
197   }\r
198 \r
199   ProcTraceData = (PROC_TRACE_DATA *) ConfigData;\r
200   ASSERT (ProcTraceData != NULL);\r
201 \r
202   //\r
203   // Clear MSR_IA32_RTIT_CTL[0] and IA32_RTIT_STS only if MSR_IA32_RTIT_CTL[0]==1b\r
204   //\r
205   CtrlReg.Uint64 = AsmReadMsr64 (MSR_IA32_RTIT_CTL);\r
206   if (CtrlReg.Bits.TraceEn != 0) {\r
207     ///\r
208     /// Clear bit 0 in MSR IA32_RTIT_CTL (570)\r
209     ///\r
210     CtrlReg.Bits.TraceEn = 0;\r
211     CPU_REGISTER_TABLE_WRITE64 (\r
212       ProcessorNumber,\r
213       Msr,\r
214       MSR_IA32_RTIT_CTL,\r
215       CtrlReg.Uint64\r
216       );\r
217 \r
218     ///\r
219     /// Clear MSR IA32_RTIT_STS (571h) to all zeros\r
220     ///\r
221     StatusReg.Uint64 = 0x0;\r
222     CPU_REGISTER_TABLE_WRITE64 (\r
223       ProcessorNumber,\r
224       Msr,\r
225       MSR_IA32_RTIT_STATUS,\r
226       StatusReg.Uint64\r
227       );\r
228   }\r
229 \r
230   if (!State) {\r
231     return RETURN_SUCCESS;\r
232   }\r
233 \r
234   MemRegionBaseAddr = 0;\r
235   FirstIn = FALSE;\r
236 \r
237   if (ProcTraceData->ThreadMemRegionTable == NULL) {\r
238     FirstIn = TRUE;\r
239     DEBUG ((DEBUG_INFO, "Initialize Processor Trace\n"));\r
240   }\r
241 \r
242   ///\r
243   /// Refer to PROC_TRACE_MEM_SIZE Table for Size Encoding\r
244   ///\r
245   MemRegionSize = (UINT32) (1 << (ProcTraceData->ProcTraceMemSize + 12));\r
246   if (FirstIn) {\r
247     DEBUG ((DEBUG_INFO, "ProcTrace: MemSize requested: 0x%X \n", MemRegionSize));\r
248   }\r
249 \r
250   if (FirstIn) {\r
251     //\r
252     //   Let BSP allocate and create the necessary memory region (Aligned to the size of\r
253     //   the memory region from setup option(ProcTraceMemSize) which is an integral multiple of 4kB)\r
254     //   for the all the enabled threads for storing Processor Trace debug data. Then Configure the trace\r
255     //   address base in MSR, IA32_RTIT_OUTPUT_BASE (560h) bits 47:12. Note that all regions must be\r
256     //   aligned based on their size, not just 4K. Thus a 2M region must have bits 20:12 clear.\r
257     //\r
258     ThreadMemRegionTable = (UINTN *) AllocatePool (ProcTraceData->NumberOfProcessors * sizeof (UINTN *));\r
259     if (ThreadMemRegionTable == NULL) {\r
260       DEBUG ((DEBUG_ERROR, "Allocate ProcTrace ThreadMemRegionTable Failed\n"));\r
261       return RETURN_OUT_OF_RESOURCES;\r
262     }\r
263     ProcTraceData->ThreadMemRegionTable = ThreadMemRegionTable;\r
264 \r
265     for (Index = 0; Index < ProcTraceData->NumberOfProcessors; Index++, ProcTraceData->AllocatedThreads++) {\r
266       Pages = EFI_SIZE_TO_PAGES (MemRegionSize);\r
267       Alignment = MemRegionSize;\r
268       AlignedAddress = (UINTN) AllocateAlignedReservedPages (Pages, Alignment);\r
269       if (AlignedAddress == 0) {\r
270         DEBUG ((DEBUG_ERROR, "ProcTrace: Out of mem, allocated only for %d threads\n", ProcTraceData->AllocatedThreads));\r
271         if (Index == 0) {\r
272           //\r
273           // Could not allocate for BSP even\r
274           //\r
275           FreePool ((VOID *) ThreadMemRegionTable);\r
276           ThreadMemRegionTable = NULL;\r
277           return RETURN_OUT_OF_RESOURCES;\r
278         }\r
279         break;\r
280       }\r
281 \r
282       ThreadMemRegionTable[Index] = AlignedAddress;\r
283       DEBUG ((DEBUG_INFO, "ProcTrace: PT MemRegionBaseAddr(aligned) for thread %d: 0x%llX \n", Index, (UINT64) ThreadMemRegionTable[Index]));\r
284     }\r
285 \r
286     DEBUG ((DEBUG_INFO, "ProcTrace: Allocated PT mem for %d thread \n", ProcTraceData->AllocatedThreads));\r
287     MemRegionBaseAddr = ThreadMemRegionTable[0];\r
288   } else {\r
289     if (ProcessorNumber < ProcTraceData->AllocatedThreads) {\r
290       MemRegionBaseAddr = ProcTraceData->ThreadMemRegionTable[ProcessorNumber];\r
291     } else {\r
292       return RETURN_SUCCESS;\r
293     }\r
294   }\r
295 \r
296   ///\r
297   /// Check Processor Trace output scheme: Single Range output or ToPA table\r
298   ///\r
299 \r
300   //\r
301   //  Single Range output scheme\r
302   //\r
303   if (ProcTraceData->ProcessorData[ProcessorNumber].SingleRangeSupported &&\r
304       (ProcTraceData->ProcTraceOutputScheme == RtitOutputSchemeSingleRange)) {\r
305     if (FirstIn) {\r
306       DEBUG ((DEBUG_INFO, "ProcTrace: Enabling Single Range Output scheme \n"));\r
307     }\r
308 \r
309     //\r
310     // Clear MSR IA32_RTIT_CTL (0x570) ToPA (Bit 8)\r
311     //\r
312     CtrlReg.Uint64 = AsmReadMsr64 (MSR_IA32_RTIT_CTL);\r
313     CtrlReg.Bits.ToPA = 0;\r
314     CPU_REGISTER_TABLE_WRITE64 (\r
315       ProcessorNumber,\r
316       Msr,\r
317       MSR_IA32_RTIT_CTL,\r
318       CtrlReg.Uint64\r
319       );\r
320 \r
321     //\r
322     // Program MSR IA32_RTIT_OUTPUT_BASE (0x560) bits[63:7] with the allocated Memory Region\r
323     //\r
324     OutputBaseReg.Bits.Base = (MemRegionBaseAddr >> 7) & 0x01FFFFFF;\r
325     OutputBaseReg.Bits.BaseHi = RShiftU64 ((UINT64) MemRegionBaseAddr, 32) & 0xFFFFFFFF;\r
326     CPU_REGISTER_TABLE_WRITE64 (\r
327       ProcessorNumber,\r
328       Msr,\r
329       MSR_IA32_RTIT_OUTPUT_BASE,\r
330       OutputBaseReg.Uint64\r
331       );\r
332 \r
333     //\r
334     // Program the Mask bits for the Memory Region to MSR IA32_RTIT_OUTPUT_MASK_PTRS (561h)\r
335     //\r
336     OutputMaskPtrsReg.Bits.MaskOrTableOffset = ((MemRegionSize - 1) >> 7) & 0x01FFFFFF;\r
337     OutputMaskPtrsReg.Bits.OutputOffset = RShiftU64 (MemRegionSize - 1, 32) & 0xFFFFFFFF;\r
338     CPU_REGISTER_TABLE_WRITE64 (\r
339       ProcessorNumber,\r
340       Msr,\r
341       MSR_IA32_RTIT_OUTPUT_MASK_PTRS,\r
342       OutputMaskPtrsReg.Uint64\r
343       );\r
344   }\r
345 \r
346   //\r
347   //  ToPA(Table of physical address) scheme\r
348   //\r
349   if (ProcTraceData->ProcessorData[ProcessorNumber].TopaSupported &&\r
350       (ProcTraceData->ProcTraceOutputScheme == RtitOutputSchemeToPA)) {\r
351     //\r
352     //  Create ToPA structure aligned at 4KB for each logical thread\r
353     //  with at least 2 entries by 8 bytes size each. The first entry\r
354     //  should have the trace output base address in bits 47:12, 6:9\r
355     //  for Size, bits 4,2 and 0 must be cleared. The second entry\r
356     //  should have the base address of the table location in bits\r
357     //  47:12, bits 4 and 2 must be cleared and bit 0 must be set.\r
358     //\r
359     if (FirstIn) {\r
360       DEBUG ((DEBUG_INFO, "ProcTrace: Enabling ToPA scheme \n"));\r
361       //\r
362       // Let BSP allocate ToPA table mem for all threads\r
363       //\r
364       TopaMemArray = (UINTN *) AllocatePool (ProcTraceData->AllocatedThreads * sizeof (UINTN *));\r
365       if (TopaMemArray == NULL) {\r
366         DEBUG ((DEBUG_ERROR, "ProcTrace: Allocate mem for ToPA Failed\n"));\r
367         return RETURN_OUT_OF_RESOURCES;\r
368       }\r
369       ProcTraceData->TopaMemArray = TopaMemArray;\r
370 \r
371       for (Index = 0; Index < ProcTraceData->AllocatedThreads; Index++) {\r
372         Pages = EFI_SIZE_TO_PAGES (sizeof (PROC_TRACE_TOPA_TABLE));\r
373         Alignment = 0x1000;\r
374         AlignedAddress = (UINTN) AllocateAlignedReservedPages (Pages, Alignment);\r
375         if (AlignedAddress == 0) {\r
376           if (Index < ProcTraceData->AllocatedThreads) {\r
377             ProcTraceData->AllocatedThreads = Index;\r
378           }\r
379           DEBUG ((DEBUG_ERROR, "ProcTrace:  Out of mem, allocating ToPA mem only for %d threads\n", ProcTraceData->AllocatedThreads));\r
380           if (Index == 0) {\r
381             //\r
382             // Could not allocate for BSP\r
383             //\r
384             FreePool ((VOID *) TopaMemArray);\r
385             TopaMemArray = NULL;\r
386             return RETURN_OUT_OF_RESOURCES;\r
387           }\r
388           break;\r
389         }\r
390 \r
391         TopaMemArray[Index] = AlignedAddress;\r
392         DEBUG ((DEBUG_INFO, "ProcTrace: Topa table address(aligned) for thread %d is 0x%llX \n", Index,  (UINT64) TopaMemArray[Index]));\r
393       }\r
394 \r
395       DEBUG ((DEBUG_INFO, "ProcTrace: Allocated ToPA mem for %d thread \n", ProcTraceData->AllocatedThreads));\r
396       //\r
397       // BSP gets the first block\r
398       //\r
399       TopaTableBaseAddr = TopaMemArray[0];\r
400     } else {\r
401       //\r
402       // Count for currently executing AP.\r
403       //\r
404       if (ProcessorNumber < ProcTraceData->AllocatedThreads) {\r
405         TopaTableBaseAddr = ProcTraceData->TopaMemArray[ProcessorNumber];\r
406       } else {\r
407         return RETURN_SUCCESS;\r
408       }\r
409     }\r
410 \r
411     TopaTable = (PROC_TRACE_TOPA_TABLE *) TopaTableBaseAddr;\r
412     TopaEntryPtr = &TopaTable->TopaEntry[0];\r
413     TopaEntryPtr->Bits.Base = (MemRegionBaseAddr >> 12) & 0x000FFFFF;\r
414     TopaEntryPtr->Bits.BaseHi = RShiftU64 ((UINT64) MemRegionBaseAddr, 32) & 0xFFFFFFFF;\r
415     TopaEntryPtr->Bits.Size = ProcTraceData->ProcTraceMemSize;\r
416     TopaEntryPtr->Bits.END = 0;\r
417 \r
418     TopaEntryPtr = &TopaTable->TopaEntry[1];\r
419     TopaEntryPtr->Bits.Base = (TopaTableBaseAddr >> 12) & 0x000FFFFF;\r
420     TopaEntryPtr->Bits.BaseHi = RShiftU64 ((UINT64) TopaTableBaseAddr, 32) & 0xFFFFFFFF;\r
421     TopaEntryPtr->Bits.END = 1;\r
422 \r
423     //\r
424     // Program the MSR IA32_RTIT_OUTPUT_BASE (0x560) bits[63:7] with ToPA base\r
425     //\r
426     OutputBaseReg.Bits.Base = (TopaTableBaseAddr >> 7) & 0x01FFFFFF;\r
427     OutputBaseReg.Bits.BaseHi = RShiftU64 ((UINT64) TopaTableBaseAddr, 32) & 0xFFFFFFFF;\r
428     CPU_REGISTER_TABLE_WRITE64 (\r
429       ProcessorNumber,\r
430       Msr,\r
431       MSR_IA32_RTIT_OUTPUT_BASE,\r
432       OutputBaseReg.Uint64\r
433       );\r
434 \r
435     //\r
436     // Set the MSR IA32_RTIT_OUTPUT_MASK (0x561) bits[63:7] to 0\r
437     //\r
438     OutputMaskPtrsReg.Bits.MaskOrTableOffset = 0;\r
439     OutputMaskPtrsReg.Bits.OutputOffset = 0;\r
440     CPU_REGISTER_TABLE_WRITE64 (\r
441       ProcessorNumber,\r
442       Msr,\r
443       MSR_IA32_RTIT_OUTPUT_MASK_PTRS,\r
444       OutputMaskPtrsReg.Uint64\r
445       );\r
446     //\r
447     // Enable ToPA output scheme by enabling MSR IA32_RTIT_CTL (0x570) ToPA (Bit 8)\r
448     //\r
449     CtrlReg.Uint64 = AsmReadMsr64 (MSR_IA32_RTIT_CTL);\r
450     CtrlReg.Bits.ToPA = 1;\r
451     CPU_REGISTER_TABLE_WRITE64 (\r
452       ProcessorNumber,\r
453       Msr,\r
454       MSR_IA32_RTIT_CTL,\r
455       CtrlReg.Uint64\r
456       );\r
457   }\r
458 \r
459   ///\r
460   /// Enable the Processor Trace feature from MSR IA32_RTIT_CTL (570h)\r
461   ///\r
462   CtrlReg.Uint64 = AsmReadMsr64 (MSR_IA32_RTIT_CTL);\r
463   CtrlReg.Bits.OS = 1;\r
464   CtrlReg.Bits.User = 1;\r
465   CtrlReg.Bits.BranchEn = 1;\r
466   CtrlReg.Bits.TraceEn = 1;\r
467   CPU_REGISTER_TABLE_WRITE64 (\r
468     ProcessorNumber,\r
469     Msr,\r
470     MSR_IA32_RTIT_CTL,\r
471     CtrlReg.Uint64\r
472     );\r
473 \r
474   return RETURN_SUCCESS;\r
475 }\r