flushtb.c File Reference

#include "ki.h"

Go to the source code of this file.

Functions
VOID	KiFlushEntireTbTarget (IN PKIPI_CONTEXT SignalDone, IN PVOID Parameter1, IN PVOID Parameter2, IN PVOID Parameter3)
VOID	KiFlushMultipleTbTarget (IN PKIPI_CONTEXT SignalDone, IN PVOID Number, IN PVOID Virtual, IN PVOID Pid)
VOID	KiFlushSingleTbTarget (IN PKIPI_CONTEXT SignalDone, IN PVOID Virtual, IN PVOID Pid, IN PVOID Parameter3)
VOID	KiFlushMultipleTbTarget64 (IN PKIPI_CONTEXT SignalDone, IN PVOID Number, IN PVOID Virtual, IN PVOID Pid)
VOID	KiFlushSingleTbTarget64 (IN PKIPI_CONTEXT SignalDone, IN PVOID Virtual, IN PVOID Pid, IN PVOID Parameter3)
VOID	KeFlushEntireTb (IN BOOLEAN Invalid, IN BOOLEAN AllProcessors)
VOID	KeFlushMultipleTb (IN ULONG Number, IN PVOID *Virtual, IN BOOLEAN Invalid, IN BOOLEAN AllProcessors, IN PHARDWARE_PTE *PtePointer OPTIONAL, IN HARDWARE_PTE PteValue)
HARDWARE_PTE	KeFlushSingleTb (IN PVOID Virtual, IN BOOLEAN Invalid, IN BOOLEAN AllProcessors, IN PHARDWARE_PTE PtePointer, IN HARDWARE_PTE PteValue)
VOID	KeFlushMultipleTb64 (IN ULONG Number, IN PULONG_PTR Virtual, IN BOOLEAN Invalid, IN BOOLEAN AllProcessors, IN PHARDWARE_PTE *PtePointer OPTIONAL, IN HARDWARE_PTE PteValue)
HARDWARE_PTE	KeFlushSingleTb64 (IN ULONG_PTR Virtual, IN BOOLEAN Invalid, IN BOOLEAN AllProcessors, IN PHARDWARE_PTE PtePointer, IN HARDWARE_PTE PteValue)

---

Function Documentation

VOID KeFlushEntireTb (  IN BOOLEAN  Invalid, IN BOOLEAN  AllProcessors )

Definition at line 86 of file alpha/flushtb.c. References _KPROCESS::ActiveProcessors, _KTHREAD::ApcState, FALSE, IPI_INSTRUMENT_COUNT, KeActiveProcessors, KeGetCurrentPrcb, KeGetCurrentThread, KeLowerIrql(), KiFlushEntireTbTarget(), KiIpiSendPacket(), KiIpiStallOnPacketTargets(), KiLockContextSwap, KiUnlockContextSwap, NULL, and _KAPC_STATE::Process. : This function flushes the entire translation buffer (TB) on all processors that are currently running threads which are children of the current process or flushes the entire translation buffer on all processors in the host configuration. Arguments: Invalid - Supplies a boolean value that specifies the reason for flushing the translation buffer. AllProcessors - Supplies a boolean value that determines which translation buffers are to be flushed. Return Value: None. --*/ { KIRQL OldIrql; PKPROCESS Process; PKTHREAD Thread; KAFFINITY TargetProcessors; // // Compute the target set of processors, disable context switching, // and send the flush entire parameters to the target processors, // if any, for execution. // #if defined(NT_UP) __tbia(); #else if (AllProcessors != FALSE) { OldIrql = KeRaiseIrqlToSynchLevel(); TargetProcessors = KeActiveProcessors; } else { KiLockContextSwap(&OldIrql); Thread = KeGetCurrentThread(); Process = Thread->ApcState.Process; TargetProcessors = Process->ActiveProcessors; if (TargetProcessors != Process->RunOnProcessors) { Process->ProcessSequence = KiMasterSequence - 1; } } TargetProcessors &= PCR->NotMember; if (TargetProcessors != 0) { KiIpiSendPacket(TargetProcessors, KiFlushEntireTbTarget, NULL, NULL, NULL); } IPI_INSTRUMENT_COUNT(KeGetCurrentPrcb()->Number, FlushEntireTb); // // Flush TB on current processor. // // KeFlushCurrentTb(); __tbia(); // // Wait until all target processors have finished. // if (TargetProcessors != 0) { KiIpiStallOnPacketTargets(TargetProcessors); } if (AllProcessors != FALSE) { KeLowerIrql(OldIrql); } else { KiUnlockContextSwap(OldIrql); } #endif return; }

VOID KeFlushMultipleTb (  IN ULONG  Number, IN PVOID *  Virtual, IN BOOLEAN  Invalid, IN BOOLEAN  AllProcessors, IN PHARDWARE_PTE *PtePointer  OPTIONAL, IN HARDWARE_PTE  PteValue )

Definition at line 231 of file alpha/flushtb.c. References _KPROCESS::ActiveProcessors, _KTHREAD::ApcState, FALSE, Index, IPI_INSTRUMENT_COUNT, KeActiveProcessors, KeGetCurrentPrcb, KeGetCurrentThread, KeLowerIrql(), KiFlushMultipleTb(), KiFlushMultipleTbTarget(), KiIpiSendPacket(), KiIpiStallOnPacketTargets(), KiLockContextSwap, KiUnlockContextSwap, NULL, _KAPC_STATE::Process, and Virtual. 00242 : 00243 00244 This function flushes multiple entries from the translation buffer 00245 on all processors that are currently running threads which are 00246 children of the current process or flushes a multiple entries from 00247 the translation buffer on all processors in the host configuration. 00248 00249 Arguments: 00250 00251 Number - Supplies the number of TB entries to flush. 00252 00253 Virtual - Supplies a pointer to an array of virtual addresses that 00254 are within the pages whose translation buffer entries are to be 00255 flushed. 00256 00257 Invalid - Supplies a boolean value that specifies the reason for 00258 flushing the translation buffer. 00259 00260 AllProcessors - Supplies a boolean value that determines which 00261 translation buffers are to be flushed. 00262 00263 PtePointer - Supplies an optional pointer to an array of pointers to 00264 page table entries that receive the specified page table entry 00265 value. 00266 00267 PteValue - Supplies the the new page table entry value. 00268 00269 Return Value: 00270 00271 The previous contents of the specified page table entry is returned 00272 as the function value. 00273 00274 --*/ 00275 00276 { 00277 00278 ULONG Index; 00279 KIRQL OldIrql; 00280 PKPROCESS Process; 00281 KAFFINITY TargetProcessors; 00282 PKTHREAD Thread; 00283 00284 // 00285 // Compute the target set of processors and send the flush multiple 00286 // parameters to the target processors, if any, for execution. 00287 // 00288 00289 if (AllProcessors != FALSE) { 00290 OldIrql = KeRaiseIrqlToSynchLevel(); 00291 TargetProcessors = KeActiveProcessors; 00292 00293 } else { 00294 KiLockContextSwap(&OldIrql); 00295 Thread = KeGetCurrentThread(); 00296 Process = Thread->ApcState.Process; 00297 TargetProcessors = Process->ActiveProcessors; 00298 if (TargetProcessors != Process->RunOnProcessors) { 00299 Process->ProcessSequence = KiMasterSequence - 1; 00300 } 00301 } 00302 00303 // 00304 // If a page table entry address address is specified, then set the 00305 // specified page table entries to the specific value. 00306 // 00307 00308 if (ARGUMENT_PRESENT(PtePointer)) { 00309 for (Index = 0; Index < Number; Index += 1) { 00310 *PtePointer[Index] = PteValue; 00311 } 00312 } 00313 00314 TargetProcessors &= PCR->NotMember; 00315 if (TargetProcessors != 0) { 00316 KiIpiSendPacket(TargetProcessors, 00317 KiFlushMultipleTbTarget, 00318 ULongToPtr(Number), 00319 (PVOID)Virtual, 00320 NULL); 00321 } 00322 00323 IPI_INSTRUMENT_COUNT(KeGetCurrentPrcb()->Number, FlushMultipleTb); 00324 00325 // 00326 // Flush the specified entries from the TB on the current processor. 00327 // 00328 00329 KiFlushMultipleTb(Invalid, &Virtual[0], Number); 00330 00331 // 00332 // Wait until all target processors have finished. 00333 // 00334 00335 if (TargetProcessors != 0) { 00336 KiIpiStallOnPacketTargets(TargetProcessors); 00337 } 00338 00339 // 00340 // If the context swap lock was acquired, release it. 00341 // 00342 if (AllProcessors != FALSE) { 00343 KeLowerIrql(OldIrql); 00344 00345 } else { 00346 KiUnlockContextSwap(OldIrql); 00347 } 00348 00349 return; 00350 }

VOID KeFlushMultipleTb64 (  IN ULONG  Number, IN PULONG_PTR  Virtual, IN BOOLEAN  Invalid, IN BOOLEAN  AllProcessors, IN PHARDWARE_PTE *PtePointer  OPTIONAL, IN HARDWARE_PTE  PteValue )

Definition at line 587 of file alpha/flushtb.c. References _KPROCESS::ActiveProcessors, _KTHREAD::ApcState, ASSERT, FALSE, Index, KeActiveProcessors, KeGetCurrentThread, KeLowerIrql(), KiFlushMultipleTbTarget64(), KiIpiSendPacket(), KiIpiStallOnPacketTargets(), KiLockContextSwap, KiUnlockContextSwap, NULL, _KAPC_STATE::Process, and Virtual. : This function flushes multiple entries from the translation buffer on all processors that are currently running threads which are children of the current process or flushes a multiple entries from the translation buffer on all processors in the host configuration. Arguments: Number - Supplies the number of TB entries to flush. Virtual - Supplies a pointer to an array of virtual page numbers that are flushed from the TB. Invalid - Supplies a boolean value that specifies the reason for flushing the translation buffer. AllProcessors - Supplies a boolean value that determines which translation buffers are to be flushed. PtePointer - Supplies an optional pointer to an array of pointers to page table entries that receive the specified page table entry value. PteValue - Supplies the the new page table entry value. Return Value: The previous contents of the specified page table entry is returned as the function value. --*/ { ULONG Index; KIRQL OldIrql; PKPROCESS Process; KAFFINITY TargetProcessors; PKTHREAD Thread; ASSERT(Number <= FLUSH_MULTIPLE_MAXIMUM); // // Compute the target set of processors. // #if defined(NT_UP) OldIrql = KeRaiseIrqlToSynchLevel(); #else if (AllProcessors != FALSE) { OldIrql = KeRaiseIrqlToSynchLevel(); TargetProcessors = KeActiveProcessors; } else { KiLockContextSwap(&OldIrql); Thread = KeGetCurrentThread(); Process = Thread->ApcState.Process; TargetProcessors = Process->ActiveProcessors; if (TargetProcessors != Process->RunOnProcessors) { Process->ProcessSequence = KiMasterSequence - 1; } } TargetProcessors &= PCR->NotMember; #endif // // If a page table entry address array is specified, then set the // specified page table entries to the specific value. // if (ARGUMENT_PRESENT(PtePointer)) { for (Index = 0; Index < Number; Index += 1) { *PtePointer[Index] = PteValue; } } // // If any target processors are specified, then send a flush multiple // packet to the target set of processor. // #if !defined(NT_UP) if (TargetProcessors != 0) { KiIpiSendPacket(TargetProcessors, KiFlushMultipleTbTarget64, ULongToPtr(Number), (PVOID)Virtual, NULL); } #endif // // Flush the specified entries from the TB on the current processor. // KiFlushMultipleTb64(Invalid, &Virtual[0], Number); // // Wait until all target processors have finished. // #if defined(NT_UP) KeLowerIrql(OldIrql); #else if (TargetProcessors != 0) { KiIpiStallOnPacketTargets(TargetProcessors); } if (AllProcessors != FALSE) { KeLowerIrql(OldIrql); } else { KiUnlockContextSwap(OldIrql); } #endif return; }

HARDWARE_PTE KeFlushSingleTb (  IN PVOID  Virtual, IN BOOLEAN  Invalid, IN BOOLEAN  AllProcessors, IN PHARDWARE_PTE  PtePointer, IN HARDWARE_PTE  PteValue )

Definition at line 420 of file alpha/flushtb.c. References _KPROCESS::ActiveProcessors, _KTHREAD::ApcState, FALSE, IPI_INSTRUMENT_COUNT, KeActiveProcessors, KeGetCurrentPrcb, KeGetCurrentThread, KeLowerIrql(), KiFlushSingleTbTarget(), KiIpiSendPacket(), KiIpiStallOnPacketTargets(), KiLockContextSwap, KiUnlockContextSwap, NULL, _KAPC_STATE::Process, and Virtual. 00430 : 00431 00432 This function flushes a single entry from the translation buffer 00433 on all processors that are currently running threads which are 00434 children of the current process or flushes a single entry from 00435 the translation buffer on all processors in the host configuration. 00436 00437 Arguments: 00438 00439 Virtual - Supplies a virtual address that is within the page whose 00440 translation buffer entry is to be flushed. 00441 00442 Invalid - Supplies a boolean value that specifies the reason for 00443 flushing the translation buffer. 00444 00445 AllProcessors - Supplies a boolean value that determines which 00446 translation buffers are to be flushed. 00447 00448 PtePointer - Supplies a pointer to the page table entry which 00449 receives the specified value. 00450 00451 PteValue - Supplies the the new page table entry value. 00452 00453 Return Value: 00454 00455 The previous contents of the specified page table entry is returned 00456 as the function value. 00457 00458 --*/ 00459 00460 { 00461 00462 KIRQL OldIrql; 00463 HARDWARE_PTE OldPte; 00464 PKPROCESS Process; 00465 KAFFINITY TargetProcessors; 00466 PKTHREAD Thread; 00467 00468 // 00469 // Compute the target set of processors and send the flush single 00470 // paramters to the target processors, if any, for execution. 00471 // 00472 00473 if (AllProcessors != FALSE) { 00474 OldIrql = KeRaiseIrqlToSynchLevel(); 00475 TargetProcessors = KeActiveProcessors; 00476 00477 } else { 00478 KiLockContextSwap(&OldIrql); 00479 Thread = KeGetCurrentThread(); 00480 Process = Thread->ApcState.Process; 00481 TargetProcessors = Process->ActiveProcessors; 00482 if (TargetProcessors != Process->RunOnProcessors) { 00483 Process->ProcessSequence = KiMasterSequence - 1; 00484 } 00485 } 00486 00487 // 00488 // Capture the previous contents of the page table entry and set the 00489 // page table entry to the new value. 00490 // 00491 00492 OldPte = *PtePointer; 00493 *PtePointer = PteValue; 00494 TargetProcessors &= PCR->NotMember; 00495 if (TargetProcessors != 0) { 00496 KiIpiSendPacket(TargetProcessors, 00497 KiFlushSingleTbTarget, 00498 (PVOID)Virtual, 00499 NULL, 00500 NULL); 00501 } 00502 00503 IPI_INSTRUMENT_COUNT(KeGetCurrentPrcb()->Number, FlushSingleTb); 00504 00505 // 00506 // Flush the specified entry from the TB on the current processor. 00507 // 00508 00509 // KiFlushSingleTb(Invalid, Virtual); 00510 __tbis(Virtual); 00511 00512 // 00513 // Wait until all target processors have finished. 00514 // 00515 00516 if (TargetProcessors != 0) { 00517 KiIpiStallOnPacketTargets(TargetProcessors); 00518 } 00519 00520 if (AllProcessors != FALSE) { 00521 KeLowerIrql(OldIrql); 00522 00523 } else { 00524 KiUnlockContextSwap(OldIrql); 00525 } 00526 00527 // 00528 // return the previous page table entry value. 00529 // 00530 00531 return OldPte; 00532 }

HARDWARE_PTE KeFlushSingleTb64 (  IN ULONG_PTR  Virtual, IN BOOLEAN  Invalid, IN BOOLEAN  AllProcessors, IN PHARDWARE_PTE  PtePointer, IN HARDWARE_PTE  PteValue )

Definition at line 797 of file alpha/flushtb.c. References _KPROCESS::ActiveProcessors, _KTHREAD::ApcState, FALSE, KeActiveProcessors, KeGetCurrentThread, KeLowerIrql(), KiFlushSingleTbTarget64(), KiIpiSendPacket(), KiIpiStallOnPacketTargets(), KiLockContextSwap, KiUnlockContextSwap, NULL, _KAPC_STATE::Process, and Virtual. : This function flushes a single entry from the translation buffer on all processors that are currently running threads which are children of the current process or flushes a single entry from the translation buffer on all processors in the host configuration. Arguments: Virtual - Supplies a virtual page number that is flushed from the TB. Invalid - Supplies a boolean value that specifies the reason for flushing the translation buffer. AllProcessors - Supplies a boolean value that determines which translation buffers are to be flushed. PtePointer - Supplies a pointer to the page table entry which receives the specified value. PteValue - Supplies the the new page table entry value. Return Value: The previous contents of the specified page table entry is returned as the function value. --*/ { KIRQL OldIrql; HARDWARE_PTE OldPte; PKPROCESS Process; KAFFINITY TargetProcessors; PKTHREAD Thread; // // Compute the target set of processors. // #if defined(NT_UP) OldIrql = KeRaiseIrqlToSynchLevel(); #else if (AllProcessors != FALSE) { OldIrql = KeRaiseIrqlToSynchLevel(); TargetProcessors = KeActiveProcessors; } else { KiLockContextSwap(&OldIrql); Thread = KeGetCurrentThread(); Process = Thread->ApcState.Process; TargetProcessors = Process->ActiveProcessors; if (TargetProcessors != Process->RunOnProcessors) { Process->ProcessSequence = KiMasterSequence - 1; } } TargetProcessors &= PCR->NotMember; #endif // // Capture the previous contents of the page table entry and set the // page table entry to the new value. // OldPte = *PtePointer; *PtePointer = PteValue; // // If any target processors are specified, then send a flush single // packet to the target set of processors. #if !defined(NT_UP) if (TargetProcessors != 0) { KiIpiSendPacket(TargetProcessors, KiFlushSingleTbTarget64, (PVOID)Virtual, NULL, NULL); } #endif // // Flush the specified entry from the TB on the current processor. // KiFlushSingleTb64(Invalid, Virtual); // // Wait until all target processors have finished. // #if defined(NT_UP) KeLowerIrql(OldIrql); #else if (TargetProcessors != 0) { KiIpiStallOnPacketTargets(TargetProcessors); } if (AllProcessors != FALSE) { KeLowerIrql(OldIrql); } else { KiUnlockContextSwap(OldIrql); } #endif return OldPte; }

VOID KiFlushEntireTbTarget (  IN PKIPI_CONTEXT  SignalDone, IN PVOID  Parameter1, IN PVOID  Parameter2, IN PVOID  Parameter3 )

Definition at line 188 of file alpha/flushtb.c. References IPI_INSTRUMENT_COUNT, KeGetCurrentPrcb, and KiIpiSignalPacketDone(). Referenced by KeFlushEntireTb(), and KiGetNewRid(). 00197 : 00198 00199 This is the target function for flushing the entire TB. 00200 00201 Arguments: 00202 00203 SignalDone - Supplies a pointer to a variable that is cleared when the 00204 requested operation has been performed. 00205 00206 Parameter1 - Parameter3 - not used 00207 00208 Return Value: 00209 00210 None. 00211 00212 --*/ 00213 00214 { 00215 00216 // 00217 // Flush the entire TB on the current processor 00218 // 00219 00220 KiIpiSignalPacketDone(SignalDone); 00221 00222 // KeFlushCurrentTb(); 00223 __tbia(); 00224 00225 IPI_INSTRUMENT_COUNT(KeGetCurrentPrcb()->Number, FlushEntireTb); 00226 00227 return; 00228 }

VOID KiFlushMultipleTbTarget (  IN PKIPI_CONTEXT  SignalDone, IN PVOID  Number, IN PVOID  Virtual, IN PVOID  Pid )

Definition at line 353 of file alpha/flushtb.c. References Index, IPI_INSTRUMENT_COUNT, KeGetCurrentPrcb, KiFlushMultipleTb(), KiIpiSignalPacketDone(), TRUE, and Virtual. Referenced by KeFlushMultipleTb(). 00362 : 00363 00364 This is the target function for flushing multiple TB entries. 00365 00366 Arguments: 00367 00368 SignalDone Supplies a pointer to a variable that is cleared when the 00369 requested operation has been performed. 00370 00371 Number - Supplies the number of TB entries to flush. 00372 00373 Virtual - Supplies a pointer to an array of virtual addresses that 00374 are within the pages whose translation buffer entries are to be 00375 flushed. 00376 00377 Pid - Supplies the PID of the TB entries to flush. 00378 00379 Return Value: 00380 00381 None. 00382 00383 --*/ 00384 00385 { 00386 00387 ULONG Index; 00388 ULONG Limit; 00389 PVOID Array[FLUSH_MULTIPLE_MAXIMUM]; 00390 00391 // 00392 // Flush multiple entries from the TB on the current processor 00393 // 00394 00395 // 00396 // Capture the virtual addresses that are to be flushed from the TB 00397 // on the current processor and clear the packet address. 00398 // 00399 00400 Limit = (ULONG)((ULONG_PTR)Number); 00401 for (Index = 0; Index < Limit; Index += 1) { 00402 Array[Index] = ((PVOID *)(Virtual))[Index]; 00403 } 00404 00405 KiIpiSignalPacketDone(SignalDone); 00406 00407 // 00408 // Flush the specified virtual addresses from the TB on the current 00409 // processor. 00410 // 00411 00412 KiFlushMultipleTb(TRUE, &Array[0], Limit); 00413 00414 IPI_INSTRUMENT_COUNT(KeGetCurrentPrcb()->Number, FlushMultipleTb); 00415 00416 return; 00417 }

VOID KiFlushMultipleTbTarget64 (  IN PKIPI_CONTEXT  SignalDone, IN PVOID  Number, IN PVOID  Virtual, IN PVOID  Pid )

Definition at line 733 of file alpha/flushtb.c. References ASSERT, Index, KiIpiSignalPacketDone(), TRUE, and Virtual. Referenced by KeFlushMultipleTb64(). : This is the target function for flushing multiple TB entries. Arguments: SignalDone Supplies a pointer to a variable that is cleared when the requested operation has been performed. Number - Supplies the number of TB entries to flush. Virtual - Supplies a pointer to an array of virtual page numbers that are flushed from the TB. Pid - Supplies the PID of the TB entries to flush. Return Value: None. --*/ { ULONG Index; ULONG Limit; ULONG_PTR Array[FLUSH_MULTIPLE_MAXIMUM]; ASSERT((ULONG_PTR)Number <= FLUSH_MULTIPLE_MAXIMUM); // // Capture the virtual addresses that are to be flushed from the TB // on the current processor and clear the packet address. // Limit = (ULONG)((ULONG_PTR)Number); for (Index = 0; Index < Limit; Index += 1) { Array[Index] = ((PULONG_PTR)(Virtual))[Index]; } KiIpiSignalPacketDone(SignalDone); // // Flush the specified virtual addresses from the TB on the current // processor. // KiFlushMultipleTb64(TRUE, &Array[0], Limit); return; }

VOID KiFlushSingleTbTarget (  IN PKIPI_CONTEXT  SignalDone, IN PVOID  Virtual, IN PVOID  Pid, IN PVOID  Parameter3 )

Definition at line 535 of file alpha/flushtb.c. References IPI_INSTRUMENT_COUNT, KeGetCurrentPrcb, KiIpiSignalPacketDone(), and Virtual. Referenced by KeFlushSingleTb(). : This is the target function for flushing a single TB entry. Arguments: SignalDone Supplies a pointer to a variable that is cleared when the requested operation has been performed. Virtual - Supplies a virtual address that is within the page whose translation buffer entry is to be flushed. RequestPacket - Supplies a pointer to a flush single TB packet address. Pid - Supplies the PID of the TB entries to flush. Parameter3 - Not used. Return Value: None. --*/ { // // Flush a single entry form the TB on the current processor. // KiIpiSignalPacketDone(SignalDone); // KiFlushSingleTb(TRUE, Virtual); __tbis(Virtual); IPI_INSTRUMENT_COUNT(KeGetCurrentPrcb()->Number, FlushSingleTb); return; }

VOID KiFlushSingleTbTarget64 (  IN PKIPI_CONTEXT  SignalDone, IN PVOID  Virtual, IN PVOID  Pid, IN PVOID  Parameter3 )

Definition at line 932 of file alpha/flushtb.c. References KiIpiSignalPacketDone(), TRUE, and Virtual. Referenced by KeFlushSingleTb64(). : This is the target function for flushing a single TB entry. Arguments: SignalDone Supplies a pointer to a variable that is cleared when the requested operation has been performed. Virtual - Supplies a virtual page number that is flushed from the TB. RequestPacket - Supplies a pointer to a flush single TB packet address. Pid - Not used. Parameter3 - Not used. Return Value: None. --*/ { // // Flush a single entry form the TB on the current processor. // KiIpiSignalPacketDone(SignalDone); KiFlushSingleTb64(TRUE, (ULONG_PTR)Virtual); return; }

---