-/* $Id: cntrller.c,v 1.11 2004/08/15 16:39:03 chorns Exp $
+/* $Id: cntrller.c,v 1.12 2004/10/22 20:25:52 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
PCONTROLLER_QUEUE_ENTRY entry;
IO_ALLOCATION_ACTION Result;
- assert(KeGetCurrentIrql() == DISPATCH_LEVEL);
+ ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);
entry =
ExAllocatePoolWithTag(NonPagedPool, sizeof(CONTROLLER_QUEUE_ENTRY),
TAG_CQE);
- assert(entry!=NULL);
+ ASSERT(entry!=NULL);
entry->DeviceObject = DeviceObject;
entry->ExecutionRoutine = ExecutionRoutine;
{
PCONTROLLER_OBJECT controller;
- assert_irql(PASSIVE_LEVEL);
+ ASSERT_IRQL(PASSIVE_LEVEL);
controller =
ExAllocatePoolWithTag(NonPagedPool, sizeof(CONTROLLER_OBJECT),
* ControllerObject = Controller object to be released
*/
{
- assert_irql(PASSIVE_LEVEL);
+ ASSERT_IRQL(PASSIVE_LEVEL);
ExFreePool(ControllerObject->ControllerExtension);
ExFreePool(ControllerObject);
}
Result = Entry->ExecutionRoutine(Entry->DeviceObject,
Entry->DeviceObject->CurrentIrp,
- NULL,
+ NULL,
Entry->Context);
ExFreePool(Entry);
} while (Result == DeallocateObject);
-/* $Id: create.c,v 1.74 2004/08/15 16:39:03 chorns Exp $
+/* $Id: create.c,v 1.75 2004/10/22 20:25:52 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
DPRINT("IoCreateStreamFileObject(FileObject %x, DeviceObject %x)\n",
FileObject, DeviceObject);
- assert_irql(PASSIVE_LEVEL);
+ ASSERT_IRQL(PASSIVE_LEVEL);
Status = ObCreateObject(KernelMode,
IoFileObjectType,
FileHandle,DesiredAccess,ObjectAttributes,
ObjectAttributes->ObjectName->Buffer);
- assert_irql(PASSIVE_LEVEL);
+ ASSERT_IRQL(PASSIVE_LEVEL);
if (IoStatusBlock == NULL)
return STATUS_ACCESS_VIOLATION;
ZwClose(*FileHandle);
}
- assert_irql(PASSIVE_LEVEL);
+ ASSERT_IRQL(PASSIVE_LEVEL);
DPRINT("Finished IoCreateFile() (*FileHandle) %x\n", (*FileHandle));
-/* $Id: device.c,v 1.78 2004/10/22 11:00:41 ekohl Exp $
+/* $Id: device.c,v 1.79 2004/10/22 20:25:53 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
#define NDEBUG
#include <internal/debug.h>
-#define ASSERT assert
-
/* GLOBALS ********************************************************************/
#define TAG_DEVICE_EXTENSION TAG('D', 'E', 'X', 'T')
OBJECT_ATTRIBUTES ObjectAttributes;
NTSTATUS Status;
- assert_irql(PASSIVE_LEVEL);
+ ASSERT_IRQL(PASSIVE_LEVEL);
if (DeviceName != NULL)
{
-/* $Id: file.c,v 1.34 2004/08/21 20:51:26 tamlin Exp $
+/* $Id: file.c,v 1.35 2004/10/22 20:25:53 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
PVOID SystemBuffer;
KPROCESSOR_MODE PreviousMode;
- assert(IoStatusBlock != NULL);
- assert(FileInformation != NULL);
+ ASSERT(IoStatusBlock != NULL);
+ ASSERT(FileInformation != NULL);
DPRINT("NtQueryInformationFile(Handle %x StatBlk %x FileInfo %x Length %d "
"Class %d)\n", FileHandle, IoStatusBlock, FileInformation,
PIO_STACK_LOCATION StackPtr;
NTSTATUS Status;
- assert(FileInformation != NULL)
+ ASSERT(FileInformation != NULL);
Status = ObReferenceObjectByPointer(FileObject,
FILE_READ_ATTRIBUTES,
PVOID SystemBuffer;
KPROCESSOR_MODE PreviousMode;
- assert(IoStatusBlock != NULL)
- assert(FileInformation != NULL)
+ ASSERT(IoStatusBlock != NULL);
+ ASSERT(FileInformation != NULL);
DPRINT("NtSetInformationFile(Handle %x StatBlk %x FileInfo %x Length %d "
"Class %d)\n", FileHandle, IoStatusBlock, FileInformation,
DPRINT("IopMountFileSystem(DeviceObject %x, DeviceToMount %x)\n",
DeviceObject,DeviceToMount);
- assert_irql(PASSIVE_LEVEL);
+ ASSERT_IRQL(PASSIVE_LEVEL);
KeInitializeEvent(&Event, NotificationEvent, FALSE);
Irp = IoAllocateIrp(DeviceObject->StackSize, TRUE);
DPRINT("IopLoadFileSystem(DeviceObject %x)\n", DeviceObject);
- assert_irql(PASSIVE_LEVEL);
+ ASSERT_IRQL(PASSIVE_LEVEL);
KeInitializeEvent(&Event, NotificationEvent, FALSE);
Irp = IoAllocateIrp(DeviceObject->StackSize, TRUE);
DEVICE_TYPE MatchingDeviceType;
PDEVICE_OBJECT DevObject;
- assert_irql(PASSIVE_LEVEL);
+ ASSERT_IRQL(PASSIVE_LEVEL);
DPRINT("IoMountVolume(DeviceObject %x AllowRawMount %x)\n",
DeviceObject, AllowRawMount);
Fs = ExAllocatePoolWithTag(NonPagedPool,
sizeof(FILE_SYSTEM_OBJECT),
TAG_FILE_SYSTEM);
- assert(Fs!=NULL);
+ ASSERT(Fs!=NULL);
Fs->DeviceObject = DeviceObject;
KeEnterCriticalRegion();
RemoveEntryList(current_entry);
ExFreePool(current);
ExReleaseResourceLite(&FileSystemListLock);
- KeLeaveCriticalRegion();
+ KeLeaveCriticalRegion();
IopNotifyFileSystemChange(DeviceObject, FALSE);
return;
}
-/* $Id: irp.c,v 1.67 2004/08/21 20:51:26 tamlin Exp $
+/* $Id: irp.c,v 1.68 2004/10/22 20:25:53 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* StackSize = Number of stack locations in the IRP
*/
{
- assert(Irp != NULL);
+ ASSERT(Irp != NULL);
memset(Irp, 0, PacketSize);
Irp->Size = PacketSize;
{
PDRIVER_OBJECT DriverObject;
PIO_STACK_LOCATION Param;
-
+
DPRINT("IofCallDriver(DeviceObject %x, Irp %x)\n",DeviceObject,Irp);
-
- assert(Irp);
- assert(DeviceObject);
+
+ ASSERT(Irp);
+ ASSERT(DeviceObject);
DriverObject = DeviceObject->DriverObject;
- assert(DriverObject);
+ ASSERT(DriverObject);
IoSetNextIrpStackLocation(Irp);
Param = IoGetCurrentIrpStackLocation(Irp);
DPRINT("IrpSp 0x%X\n", Param);
-
+
Param->DeviceObject = DeviceObject;
DPRINT("MajorFunction %d\n", Param->MajorFunction);
DPRINT("IoCompleteRequest(Irp %x, PriorityBoost %d) Event %x THread %x\n",
Irp,PriorityBoost, Irp->UserEvent, PsGetCurrentThread());
- assert(KeGetCurrentIrql() <= DISPATCH_LEVEL);
- assert(Irp->CancelRoutine == NULL);
- assert(Irp->IoStatus.Status != STATUS_PENDING);
+ ASSERT(KeGetCurrentIrql() <= DISPATCH_LEVEL);
+ ASSERT(Irp->CancelRoutine == NULL);
+ ASSERT(Irp->IoStatus.Status != STATUS_PENDING);
if (IoGetCurrentIrpStackLocation(Irp)->Control & SL_PENDING_RETURNED)
{
if (Irp->MdlAddress->MdlFlags & MDL_MAPPED_TO_SYSTEM_VA)
{
- MmUnmapLockedPages(Irp->MdlAddress->MappedSystemVa, Irp->MdlAddress);
+ MmUnmapLockedPages(Irp->MdlAddress->MappedSystemVa, Irp->MdlAddress);
}
-
+
ExFreePool(Irp->MdlAddress);
}
FileHandle,DesiredAccess,ObjectAttributes,
ObjectAttributes->ObjectName->Buffer);
- assert_irql(PASSIVE_LEVEL);
+ ASSERT_IRQL(PASSIVE_LEVEL);
if (TimeOut != NULL)
{
-/* $Id: mdl.c,v 1.18 2004/08/21 20:47:28 tamlin Exp $
+/* $Id: mdl.c,v 1.19 2004/10/22 20:25:54 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
{
if (SecondaryBuffer)
{
- assert(Irp->MdlAddress);
+ ASSERT(Irp->MdlAddress);
/* FIXME: add to end of list maybe?? */
Mdl->Next = Irp->MdlAddress->Next;
FileHandle,DesiredAccess,ObjectAttributes,
ObjectAttributes->ObjectName->Buffer);
- assert_irql(PASSIVE_LEVEL);
+ ASSERT_IRQL(PASSIVE_LEVEL);
if (TimeOut != NULL)
{
-/* $Id: pnpmgr.c,v 1.42 2004/10/22 18:34:11 ekohl Exp $
+/* $Id: pnpmgr.c,v 1.43 2004/10/22 20:25:54 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
/* FUNCTIONS *****************************************************************/
-/*
- * @unimplemented
- */
-VOID
-STDCALL
-IoAdjustPagingPathCount(
- IN PLONG Count,
- IN BOOLEAN Increment)
-{
-}
-
/*
* @unimplemented
*/
KIRQL OldIrql;
/* All children must be deleted before a parent is deleted */
- assert(!DeviceNode->Child);
+ ASSERT(!DeviceNode->Child);
KeAcquireSpinLock(&IopDeviceTreeLock, &OldIrql);
- assert(DeviceNode->Pdo);
+ ASSERT(DeviceNode->Pdo);
ObDereferenceObject(DeviceNode->Pdo);
-/* $Id: rawfs.c,v 1.12 2004/08/15 16:39:03 chorns Exp $
+/* $Id: rawfs.c,v 1.13 2004/10/22 20:25:54 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
DPRINT("RawFsAllocateIrpContext(DeviceObject %x, Irp %x)\n", DeviceObject, Irp);
- assert(DeviceObject);
- assert(Irp);
+ ASSERT(DeviceObject);
+ ASSERT(Irp);
GlobalData = (PRAWFS_GLOBAL_DATA) DeviceObject->DeviceExtension;
IrpContext = ExAllocateFromNPagedLookasideList(&IrpContextLookasideList);
IrpContext->DeviceObject = DeviceObject;
IrpContext->DeviceExt = DeviceObject->DeviceExtension;
IrpContext->Stack = IoGetCurrentIrpStackLocation(Irp);
- assert(IrpContext->Stack);
+ ASSERT(IrpContext->Stack);
MajorFunction = IrpContext->MajorFunction = IrpContext->Stack->MajorFunction;
IrpContext->MinorFunction = IrpContext->Stack->MinorFunction;
IrpContext->FileObject = IrpContext->Stack->FileObject;
{
DPRINT("RawFsFreeIrpContext(IrpContext %x)\n", IrpContext);
- assert(IrpContext);
+ ASSERT(IrpContext);
ExFreeToNPagedLookasideList(&IrpContextLookasideList, IrpContext);
}
{
ULONG Count;
- assert(IrpContext != NULL);
- assert(IrpContext->Irp != NULL);
+ ASSERT(IrpContext != NULL);
+ ASSERT(IrpContext->Irp != NULL);
Count = InterlockedIncrement(&RawFsQueueCount);
DPRINT("RawFsCreate(IrpContext %x)\n", IrpContext);
- assert(IrpContext);
+ ASSERT(IrpContext);
if (RawFsIsRawFileSystemDeviceObject(IrpContext->DeviceObject))
{
DPRINT("RawFsMount(IrpContext %x)\n", IrpContext);
- assert(IrpContext);
+ ASSERT(IrpContext);
if (!RawFsIsRawFileSystemDeviceObject(IrpContext->DeviceObject))
{
DPRINT("RawFsFileSystemControl(IrpContext %x)\n", IrpContext);
- assert (IrpContext);
+ ASSERT(IrpContext);
switch (IrpContext->MinorFunction)
{
DPRINT("RawFsDispatchRequest(IrpContext %x), MajorFunction %x\n",
IrpContext, IrpContext->MajorFunction);
- assert (IrpContext);
+ ASSERT(IrpContext);
switch (IrpContext->MajorFunction)
{
DPRINT("RawFsBuildRequest(DeviceObject %x, Irp %x)\n", DeviceObject, Irp);
- assert(DeviceObject);
- assert(Irp);
+ ASSERT(DeviceObject);
+ ASSERT(Irp);
IrpContext = RawFsAllocateIrpContext(DeviceObject, Irp);
if (IrpContext == NULL)
-/* $Id: symlink.c,v 1.34 2004/08/15 16:39:03 chorns Exp $
+/* $Id: symlink.c,v 1.35 2004/10/22 20:25:54 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
HANDLE Handle;
NTSTATUS Status;
- assert_irql(PASSIVE_LEVEL);
+ ASSERT_IRQL(PASSIVE_LEVEL);
DPRINT("IoCreateSymbolicLink(SymbolicLinkName %wZ, DeviceName %wZ)\n",
SymbolicLinkName,
HANDLE Handle;
NTSTATUS Status;
- assert_irql(PASSIVE_LEVEL);
+ ASSERT_IRQL(PASSIVE_LEVEL);
DPRINT("IoCreateUnprotectedSymbolicLink(SymbolicLinkName %wZ, DeviceName %wZ)\n",
SymbolicLinkName,
HANDLE Handle;
NTSTATUS Status;
- assert_irql(PASSIVE_LEVEL);
+ ASSERT_IRQL(PASSIVE_LEVEL);
DPRINT("IoDeleteSymbolicLink (SymbolicLinkName %S)\n",
SymbolicLinkName->Buffer);
-/* $Id: vpb.c,v 1.25 2004/08/15 16:39:03 chorns Exp $
+/* $Id: vpb.c,v 1.26 2004/10/22 20:25:54 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
PVOID SystemBuffer;
KPROCESSOR_MODE PreviousMode;
- assert(IoStatusBlock != NULL);
- assert(FsInformation != NULL);
+ ASSERT(IoStatusBlock != NULL);
+ ASSERT(FsInformation != NULL);
DPRINT("FsInformation %p\n", FsInformation);
PIRP Irp;
NTSTATUS Status;
- assert(FsInformation != NULL);
+ ASSERT(FsInformation != NULL);
DPRINT("FsInformation %p\n", FsInformation);
PVOID SystemBuffer;
KPROCESSOR_MODE PreviousMode;
- assert(IoStatusBlock != NULL);
- assert(FsInformation != NULL);
+ ASSERT(IoStatusBlock != NULL);
+ ASSERT(FsInformation != NULL);
PreviousMode = ExGetPreviousMode();
-/* $Id: xhaldrv.c,v 1.48 2004/08/21 19:13:22 hbirr Exp $
+/* $Id: xhaldrv.c,v 1.49 2004/10/22 20:25:54 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
DPRINT("xHalpReadSector() called\n");
- assert(DeviceObject);
- assert(Sector);
+ ASSERT(DeviceObject);
+ ASSERT(Sector);
KeInitializeEvent(&Event,
NotificationEvent,
NumberOfHeads,
PartitionBuffer);
- assert(DeviceObject);
- assert(PartitionBuffer);
+ ASSERT(DeviceObject);
+ ASSERT(PartitionBuffer);
DiskManager = NoDiskManager;
if (Thread->ApcStateIndex == AttachedApcEnvironment)
{
/* NewProcess must be the same as in the original-environment */
- assert(NewProcess == Thread->ApcStatePointer[OriginalApcEnvironment]->Process);
+ ASSERT(NewProcess == Thread->ApcStatePointer[OriginalApcEnvironment]->Process);
/*
FIXME: Deliver any pending apc's queued to the attached environment before
*/
/* we don't support targeting apc's at attached-environments (yet)... */
- assert(IsListEmpty(&Thread->ApcState.ApcListHead[KernelMode]));
- assert(IsListEmpty(&Thread->ApcState.ApcListHead[UserMode]));
- assert(Thread->ApcState.KernelApcInProgress == FALSE);
- assert(Thread->ApcState.KernelApcPending == FALSE);
- assert(Thread->ApcState.UserApcPending == FALSE);
+ ASSERT(IsListEmpty(&Thread->ApcState.ApcListHead[KernelMode]));
+ ASSERT(IsListEmpty(&Thread->ApcState.ApcListHead[UserMode]));
+ ASSERT(Thread->ApcState.KernelApcInProgress == FALSE);
+ ASSERT(Thread->ApcState.KernelApcPending == FALSE);
+ ASSERT(Thread->ApcState.UserApcPending == FALSE);
/* restore backup of original environment */
Thread->ApcState = Thread->SavedApcState;
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
-/* $Id: dpc.c,v 1.38 2004/10/17 15:39:29 hbirr Exp $
+/* $Id: dpc.c,v 1.39 2004/10/22 20:30:47 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
KIRQL oldlvl;
PKPCR Pcr;
- assert_irql(DISPATCH_LEVEL);
+ ASSERT_IRQL(DISPATCH_LEVEL);
Pcr = KeGetCurrentKPCR();
while (!IsListEmpty(&Pcr->PrcbData.DpcData[0].DpcListHead))
{
- assert(Pcr->PrcbData.DpcData[0].DpcQueueDepth > 0);
+ ASSERT(Pcr->PrcbData.DpcData[0].DpcQueueDepth > 0);
current_entry = RemoveHeadList(&Pcr->PrcbData.DpcData[0].DpcListHead);
Pcr->PrcbData.DpcData[0].DpcQueueDepth--;
Pcr->PrcbData.DpcData[0].DpcCount++;
- assert((Pcr->PrcbData.DpcData[0].DpcQueueDepth == 0 && IsListEmpty(&Pcr->PrcbData.DpcData[0].DpcListHead)) ||
+ ASSERT((Pcr->PrcbData.DpcData[0].DpcQueueDepth == 0 && IsListEmpty(&Pcr->PrcbData.DpcData[0].DpcListHead)) ||
(Pcr->PrcbData.DpcData[0].DpcQueueDepth > 0 && !IsListEmpty(&Pcr->PrcbData.DpcData[0].DpcListHead)));
current = CONTAINING_RECORD(current_entry,KDPC,DpcListEntry);
Dpc->Lock=0;
}
- assert((Pcr->PrcbData.DpcData[0].DpcQueueDepth == 0 && IsListEmpty(&Pcr->PrcbData.DpcData[0].DpcListHead)) ||
+ ASSERT((Pcr->PrcbData.DpcData[0].DpcQueueDepth == 0 && IsListEmpty(&Pcr->PrcbData.DpcData[0].DpcListHead)) ||
(Pcr->PrcbData.DpcData[0].DpcQueueDepth > 0 && !IsListEmpty(&Pcr->PrcbData.DpcData[0].DpcListHead)));
KiReleaseSpinLock(&Pcr->PrcbData.DpcData[0].DpcLock);
DPRINT("KeInsertQueueDpc(dpc %x, SystemArgument1 %x, SystemArgument2 %x)\n",
Dpc, SystemArgument1, SystemArgument2);
- assert(KeGetCurrentIrql()>=DISPATCH_LEVEL);
+ ASSERT(KeGetCurrentIrql()>=DISPATCH_LEVEL);
Dpc->Number=0;
Dpc->Importance=MediumImportance;
Pcr = KeGetCurrentKPCR();
KeRaiseIrql(HIGH_LEVEL, &oldlvl);
KiAcquireSpinLock(&Pcr->PrcbData.DpcData[0].DpcLock);
- assert((Pcr->PrcbData.DpcData[0].DpcQueueDepth == 0 && IsListEmpty(&Pcr->PrcbData.DpcData[0].DpcListHead)) ||
+ ASSERT((Pcr->PrcbData.DpcData[0].DpcQueueDepth == 0 && IsListEmpty(&Pcr->PrcbData.DpcData[0].DpcListHead)) ||
(Pcr->PrcbData.DpcData[0].DpcQueueDepth > 0 && !IsListEmpty(&Pcr->PrcbData.DpcData[0].DpcListHead)));
InsertHeadList(&Pcr->PrcbData.DpcData[0].DpcListHead,&Dpc->DpcListEntry);
DPRINT("Dpc->DpcListEntry.Flink %x\n", Dpc->DpcListEntry.Flink);
}
else
{
- assert(FALSE);
+ ASSERT(FALSE);
return;
}
static void set_trap_gate(unsigned int sel, unsigned int func, unsigned int dpl)
{
DPRINT("set_trap_gate(sel %d, func %x, dpl %d)\n",sel, func, dpl);
- assert(dpl <= 3);
+ ASSERT(dpl <= 3);
KiIdt[sel].a = (((int)func)&0xffff) +
(KERNEL_CS << 16);
KiIdt[sel].b = 0x8f00 + (dpl << 13) + (((int)func)&0xffff0000);
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
-/* $Id: irq.c,v 1.47 2004/10/17 15:39:29 hbirr Exp $
+/* $Id: irq.c,v 1.48 2004/10/22 20:32:49 ekohl Exp $
*
* PROJECT: ReactOS kernel
* FILE: ntoskrnl/ke/i386/irq.c
KiDeliverNormalApc();
- assert(KeGetCurrentThread() == CurrentThread);
+ ASSERT(KeGetCurrentThread() == CurrentThread);
if (CurrentThread->TrapFrame == &KernelTrapFrame)
{
KeTrapFrameToIRQTrapFrame(&KernelTrapFrame, Trapframe);
-/* $Id: usercall.c,v 1.29 2004/08/21 21:20:08 tamlin Exp $
+/* $Id: usercall.c,v 1.30 2004/10/22 20:32:49 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
DbgPrint("%x, ", va_arg(ap, ULONG));
}
DbgPrint(")\n");
- assert_irql(PASSIVE_LEVEL);
+ ASSERT_IRQL(PASSIVE_LEVEL);
va_end(ap);
#endif
}
IN ULONG SortKey)
{
DPRINT("KeInsertByKeyDeviceQueue()\n");
- assert(KeGetCurrentIrql() == DISPATCH_LEVEL);
-
+ ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);
+
DeviceQueueEntry->SortKey=SortKey;
KeAcquireSpinLockAtDpcLevel(&DeviceQueue->Lock);
)
{
PLIST_ENTRY current;
- PKDEVICE_QUEUE_ENTRY entry;
-
- assert(KeGetCurrentIrql() == DISPATCH_LEVEL);
- assert(DeviceQueue!=NULL);
- assert(DeviceQueue->Busy);
-
+ PKDEVICE_QUEUE_ENTRY entry;
+
+ ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);
+ ASSERT(DeviceQueue!=NULL);
+ ASSERT(DeviceQueue->Busy);
+
KeAcquireSpinLockAtDpcLevel(&DeviceQueue->Lock);
/* an attempt to remove an entry from an empty (and busy) queue sets the queue to idle */
DPRINT("KeRemoveDeviceQueue(DeviceQueue %x)\n",DeviceQueue);
- assert(KeGetCurrentIrql() == DISPATCH_LEVEL);
- assert(DeviceQueue!=NULL);
- assert(DeviceQueue->Busy);
+ ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);
+ ASSERT(DeviceQueue!=NULL);
+ ASSERT(DeviceQueue->Busy);
KeAcquireSpinLockAtDpcLevel(&DeviceQueue->Lock);
* DeviceQueue = Device queue to initialize
*/
{
- assert(DeviceQueue!=NULL);
+ ASSERT(DeviceQueue!=NULL);
InitializeListHead(&DeviceQueue->DeviceListHead);
DeviceQueue->Busy=FALSE;
KeInitializeSpinLock(&DeviceQueue->Lock);
* True otherwise
*/
{
- assert(KeGetCurrentIrql() == DISPATCH_LEVEL);
+ ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);
KeAcquireSpinLockAtDpcLevel(&DeviceQueue->Lock);
KIRQL oldIrql;
PKDEVICE_QUEUE_ENTRY entry;
- assert(KeGetCurrentIrql() <= DISPATCH_LEVEL);
+ ASSERT(KeGetCurrentIrql() <= DISPATCH_LEVEL);
KeAcquireSpinLock(&DeviceQueue->Lock, &oldIrql);
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
-/* $Id: kthread.c,v 1.54 2004/10/13 01:42:14 ion Exp $
+/* $Id: kthread.c,v 1.55 2004/10/22 20:30:47 ekohl Exp $
*
* FILE: ntoskrnl/ke/kthread.c
* PURPOSE: Microkernel thread support
KeFreeStackPage(PVOID Context, MEMORY_AREA* MemoryArea, PVOID Address,
PFN_TYPE Page, SWAPENTRY SwapEntry, BOOLEAN Dirty)
{
- assert(SwapEntry == 0);
+ ASSERT(SwapEntry == 0);
if (Page != 0)
{
MmReleasePageMemoryConsumer(MC_NPPOOL, Page);
}
VOID STDCALL
-KeRescheduleThread()
+KeRescheduleThread(VOID)
{
PsDispatchThread(THREAD_STATE_READY);
}
*/
VOID
STDCALL
-KeRevertToUserAffinityThread(
- VOID
-)
+KeRevertToUserAffinityThread(VOID)
{
PKTHREAD CurrentThread;
CurrentThread = KeGetCurrentThread();
STDCALL
KeSetIdealProcessorThread (
IN PKTHREAD Thread,
- IN CCHAR Processor
- )
+ IN CCHAR Processor)
{
CCHAR PreviousIdealProcessor;
*/
VOID
STDCALL
-KeSetSystemAffinityThread(
- IN KAFFINITY Affinity
-)
+KeSetSystemAffinityThread(IN KAFFINITY Affinity)
{
PKTHREAD CurrentThread;
CurrentThread = KeGetCurrentThread();
/*
* @implemented
*/
-VOID
+VOID
STDCALL
-KeTerminateThread(
- IN KPRIORITY Increment
-)
+KeTerminateThread(IN KPRIORITY Increment)
{
/* The Increment Argument seems to be ignored by NT and always 0 when called */
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
-/* $Id: main.c,v 1.199 2004/10/13 22:27:03 ion Exp $
+/* $Id: main.c,v 1.200 2004/10/22 20:30:47 ekohl Exp $
*
* PROJECT: ReactOS kernel
* FILE: ntoskrnl/ke/main.c
* Fail at runtime if someone has changed various structures without
* updating the offsets used for the assembler code.
*/
- assert(FIELD_OFFSET(KTHREAD, InitialStack) == KTHREAD_INITIAL_STACK);
- assert(FIELD_OFFSET(KTHREAD, Teb) == KTHREAD_TEB);
- assert(FIELD_OFFSET(KTHREAD, KernelStack) == KTHREAD_KERNEL_STACK);
- assert(FIELD_OFFSET(KTHREAD, ServiceTable) == KTHREAD_SERVICE_TABLE);
- assert(FIELD_OFFSET(KTHREAD, PreviousMode) == KTHREAD_PREVIOUS_MODE);
- assert(FIELD_OFFSET(KTHREAD, TrapFrame) == KTHREAD_TRAP_FRAME);
- assert(FIELD_OFFSET(KTHREAD, CallbackStack) == KTHREAD_CALLBACK_STACK);
- assert(FIELD_OFFSET(KTHREAD, ApcState.Process) == KTHREAD_APCSTATE_PROCESS);
- assert(FIELD_OFFSET(KPROCESS, DirectoryTableBase) ==
+ ASSERT(FIELD_OFFSET(KTHREAD, InitialStack) == KTHREAD_INITIAL_STACK);
+ ASSERT(FIELD_OFFSET(KTHREAD, Teb) == KTHREAD_TEB);
+ ASSERT(FIELD_OFFSET(KTHREAD, KernelStack) == KTHREAD_KERNEL_STACK);
+ ASSERT(FIELD_OFFSET(KTHREAD, ServiceTable) == KTHREAD_SERVICE_TABLE);
+ ASSERT(FIELD_OFFSET(KTHREAD, PreviousMode) == KTHREAD_PREVIOUS_MODE);
+ ASSERT(FIELD_OFFSET(KTHREAD, TrapFrame) == KTHREAD_TRAP_FRAME);
+ ASSERT(FIELD_OFFSET(KTHREAD, CallbackStack) == KTHREAD_CALLBACK_STACK);
+ ASSERT(FIELD_OFFSET(KTHREAD, ApcState.Process) == KTHREAD_APCSTATE_PROCESS);
+ ASSERT(FIELD_OFFSET(KPROCESS, DirectoryTableBase) ==
KPROCESS_DIRECTORY_TABLE_BASE);
- assert(FIELD_OFFSET(KPROCESS, IopmOffset) == KPROCESS_IOPM_OFFSET);
- assert(FIELD_OFFSET(KPROCESS, LdtDescriptor) == KPROCESS_LDT_DESCRIPTOR0);
- assert(FIELD_OFFSET(KTRAP_FRAME, Reserved9) == KTRAP_FRAME_RESERVED9);
- assert(FIELD_OFFSET(KV86M_TRAP_FRAME, regs) == TF_REGS);
- assert(FIELD_OFFSET(KV86M_TRAP_FRAME, orig_ebp) == TF_ORIG_EBP);
-
- assert(FIELD_OFFSET(KPCR, Tib.ExceptionList) == KPCR_EXCEPTION_LIST);
- assert(FIELD_OFFSET(KPCR, Self) == KPCR_SELF);
- assert(FIELD_OFFSET(KPCR, PrcbData) + FIELD_OFFSET(KPRCB, CurrentThread) == KPCR_CURRENT_THREAD);
+ ASSERT(FIELD_OFFSET(KPROCESS, IopmOffset) == KPROCESS_IOPM_OFFSET);
+ ASSERT(FIELD_OFFSET(KPROCESS, LdtDescriptor) == KPROCESS_LDT_DESCRIPTOR0);
+ ASSERT(FIELD_OFFSET(KTRAP_FRAME, Reserved9) == KTRAP_FRAME_RESERVED9);
+ ASSERT(FIELD_OFFSET(KV86M_TRAP_FRAME, regs) == TF_REGS);
+ ASSERT(FIELD_OFFSET(KV86M_TRAP_FRAME, orig_ebp) == TF_ORIG_EBP);
+
+ ASSERT(FIELD_OFFSET(KPCR, Tib.ExceptionList) == KPCR_EXCEPTION_LIST);
+ ASSERT(FIELD_OFFSET(KPCR, Self) == KPCR_SELF);
+ ASSERT(FIELD_OFFSET(KPCR, PrcbData) + FIELD_OFFSET(KPRCB, CurrentThread) == KPCR_CURRENT_THREAD);
LdrInit1();
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
-/* $Id: mutex.c,v 1.17 2004/08/15 16:39:05 chorns Exp $
+/* $Id: mutex.c,v 1.18 2004/10/22 20:30:48 ekohl Exp $
*
* PROJECT: ReactOS kernel
* FILE: ntoskrnl/ke/mutex.c
KEBUGCHECK(THREAD_NOT_MUTEX_OWNER);
}
Mutex->Header.SignalState++;
- assert(Mutex->Header.SignalState <= 1);
+ ASSERT(Mutex->Header.SignalState <= 1);
if (Mutex->Header.SignalState == 1)
{
Mutex->OwnerThread = NULL;
KEBUGCHECK(THREAD_NOT_MUTEX_OWNER);
}
Mutant->Header.SignalState++;
- assert(Mutant->Header.SignalState <= 1);
+ ASSERT(Mutant->Header.SignalState <= 1);
}
else
{
-/* $Id: spinlock.c,v 1.23 2004/08/21 21:19:06 tamlin Exp $
+/* $Id: spinlock.c,v 1.24 2004/10/22 20:30:48 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
VOID FASTCALL
KefAcquireSpinLockAtDpcLevel(PKSPIN_LOCK SpinLock)
{
- assert(KeGetCurrentIrql() == DISPATCH_LEVEL);
+ ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);
KiAcquireSpinLock(SpinLock);
}
VOID FASTCALL
KefReleaseSpinLockFromDpcLevel(PKSPIN_LOCK SpinLock)
{
- assert(KeGetCurrentIrql() == DISPATCH_LEVEL);
+ ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);
KiReleaseSpinLock(SpinLock);
}
-/* $Id: timer.c,v 1.81 2004/10/17 15:39:29 hbirr Exp $
+/* $Id: timer.c,v 1.82 2004/10/22 20:30:48 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
DPRINT("KeSetTimerEx(Timer %x), DueTime: \n",Timer);
- assert(KeGetCurrentIrql() <= DISPATCH_LEVEL);
+ ASSERT(KeGetCurrentIrql() <= DISPATCH_LEVEL);
KeAcquireSpinLock(&TimerListLock, &oldlvl);
Timer->Period = Period;
Timer->Header.SignalState = FALSE;
AlreadyInList = (Timer->TimerListEntry.Flink == NULL) ? FALSE : TRUE;
- assert((Timer->TimerListEntry.Flink == NULL && Timer->TimerListEntry.Blink == NULL) ||
+ ASSERT((Timer->TimerListEntry.Flink == NULL && Timer->TimerListEntry.Blink == NULL) ||
(Timer->TimerListEntry.Flink != NULL && Timer->TimerListEntry.Blink != NULL));
if (AlreadyInList)
{
}
if (Timer->Header.Absolute)
{
- assert(&Timer->TimerListEntry != &AbsoluteTimerListHead);
+ ASSERT(&Timer->TimerListEntry != &AbsoluteTimerListHead);
}
else
{
- assert(&Timer->TimerListEntry != &RelativeTimerListHead);
+ ASSERT(&Timer->TimerListEntry != &RelativeTimerListHead);
}
- assert(Timer->TimerListEntry.Flink != &Timer->TimerListEntry);
+ ASSERT(Timer->TimerListEntry.Flink != &Timer->TimerListEntry);
RemoveEntryList(&Timer->TimerListEntry);
Timer->TimerListEntry.Flink = Timer->TimerListEntry.Blink = NULL;
KeReleaseSpinLock(&TimerListLock, oldlvl);
}
else
{
- assert(FALSE);
+ ASSERT(FALSE);
return;
}
DPRINT("Finished dpc routine\n");
}
- assert(KeGetCurrentIrql() == DISPATCH_LEVEL);
+ ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);
KeAcquireDispatcherDatabaseLockAtDpcLevel();
Timer->Header.SignalState = TRUE;
DPRINT("KeExpireTimers()\n");
- assert(KeGetCurrentIrql() == DISPATCH_LEVEL);
+ ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);
InitializeListHead(&TimerList);
KeQuerySystemTime(&SystemTime);
current_entry = RelativeTimerListHead.Flink;
- assert(current_entry);
+ ASSERT(current_entry);
while (current_entry != &RelativeTimerListHead)
{
current = CONTAINING_RECORD(current_entry, KTIMER, TimerListEntry);
- assert(current);
- assert(current_entry != &RelativeTimerListHead);
- assert(current_entry->Flink != current_entry);
+ ASSERT(current);
+ ASSERT(current_entry != &RelativeTimerListHead);
+ ASSERT(current_entry->Flink != current_entry);
if ((ULONGLONG)InterruptTime.QuadPart < current->DueTime.QuadPart)
{
break;
}
current_entry = AbsoluteTimerListHead.Flink;
- assert(current_entry);
+ ASSERT(current_entry);
while (current_entry != &AbsoluteTimerListHead)
{
current = CONTAINING_RECORD(current_entry, KTIMER, TimerListEntry);
- assert(current);
- assert(current_entry != &AbsoluteTimerListHead);
- assert(current_entry->Flink != current_entry);
+ ASSERT(current);
+ ASSERT(current_entry != &AbsoluteTimerListHead);
+ ASSERT(current_entry->Flink != current_entry);
if ((ULONGLONG)SystemTime.QuadPart < current->DueTime.QuadPart)
{
break;
{
LARGE_INTEGER Time;
- assert(KeGetCurrentIrql() == PROFILE_LEVEL);
+ ASSERT(KeGetCurrentIrql() == PROFILE_LEVEL);
KiRawTicks++;
#ifdef MP
InterlockedIncrement((PLONG)&ThreadsProcess->Pcb.KernelTime);
#else
- ThreadsProcess->Pcb.KernelTime++;
+ ThreadsProcess->Pcb.KernelTime++;
#endif
CurrentThread->KernelTime++;
Pcr->PrcbData.KernelTime++;
- }
+ }
}
-}
+}
/*
* @unimplemented
VOID
STDCALL
KeUpdateRunTime(
- IN PKTRAP_FRAME TrapFrame
-)
+ IN PKTRAP_FRAME TrapFrame
+ )
{
KIRQL OldIrql = PASSIVE_LEVEL;
-
+
/* These are equivalent... we should just remove the Ki and stick it here... */
KiUpdateProcessThreadTime(OldIrql, (PKIRQ_TRAPFRAME)TrapFrame);
}
VOID
STDCALL
KeUpdateSystemTime(
- IN PKTRAP_FRAME TrapFrame,
- IN ULONG Increment
-)
+ IN PKTRAP_FRAME TrapFrame,
+ IN ULONG Increment
+ )
{
KIRQL OldIrql = PASSIVE_LEVEL;
-
+
/* These are equivalent... we should just remove the Ki and stick it here... */
KiUpdateSystemTime(OldIrql, (PKIRQ_TRAPFRAME)TrapFrame);
}
Mutex = CONTAINING_RECORD(hdr, KMUTEX, Header);
hdr->SignalState--;
- assert(hdr->SignalState <= 1);
+ ASSERT(hdr->SignalState <= 1);
if (hdr->SignalState == 0)
{
if (Thread == NULL)
Mutex = CONTAINING_RECORD(hdr, KMUTEX, Header);
- assert(hdr->SignalState <= 1);
+ ASSERT(hdr->SignalState <= 1);
if ((hdr->SignalState < 1 && Mutex->OwnerThread == Thread) || hdr->SignalState == 1)
{
WaiterHead = CONTAINING_RECORD(EnumEntry, KWAIT_BLOCK, WaitListEntry);
DPRINT("current_entry %x current %x\n", EnumEntry, WaiterHead);
EnumEntry = EnumEntry->Flink;
- assert(WaiterHead->Thread != NULL);
- assert(WaiterHead->Thread->WaitBlockList != NULL);
+ ASSERT(WaiterHead->Thread != NULL);
+ ASSERT(WaiterHead->Thread->WaitBlockList != NULL);
Abandoned = FALSE;
}
//no WaitAny objects can possibly be signaled since we are here
- assert(!(Waiter->WaitType == WaitAny
+ ASSERT(!(Waiter->WaitType == WaitAny
&& KiIsObjectSignalled(Waiter->Object, Waiter->Thread)));
}
DPRINT("Entering KeWaitForMultipleObjects(Count %lu Object[] %p) "
"PsGetCurrentThread() %x\n", Count, Object, PsGetCurrentThread());
- assert(0 < Count && Count <= EX_MAXIMUM_WAIT_OBJECTS);
+ ASSERT(0 < Count && Count <= EX_MAXIMUM_WAIT_OBJECTS);
CurrentThread = KeGetCurrentThread();
WaitIrql = KeGetCurrentIrql();
-/* $Id: loader.c,v 1.148 2004/10/09 12:17:53 gvg Exp $
+/* $Id: loader.c,v 1.149 2004/10/22 20:33:53 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
ModuleTextSection = ExAllocatePool(NonPagedPool,
sizeof(MODULE_TEXT_SECTION));
- assert(ModuleTextSection);
+ ASSERT(ModuleTextSection);
RtlZeroMemory(ModuleTextSection, sizeof(MODULE_TEXT_SECTION));
ModuleTextSection->Base = (ULONG)DriverBase;
ModuleTextSection->Length = DriverSize;
-/* $Id: cont.c,v 1.34 2004/08/15 16:39:06 chorns Exp $
+/* $Id: cont.c,v 1.35 2004/10/22 20:38:22 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
PFN_TYPE Page, SWAPENTRY SwapEntry,
BOOLEAN Dirty)
{
- assert(SwapEntry == 0);
+ ASSERT(SwapEntry == 0);
if (Page != 0)
{
MmReleasePageMemoryConsumer(MC_NPPOOL, Page);
{
KIRQL oldIrql;
- assert (Pfn < MmPageArraySize);
+ ASSERT(Pfn < MmPageArraySize);
KeAcquireSpinLock(&PageListLock, &oldIrql);
if (MmPageArray[Pfn].Flags.Type == MM_PHYSICAL_PAGE_USED &&
MmPageArray[Pfn].Flags.Consumer == MC_USER)
{
KIRQL oldIrql;
- assert (Pfn < MmPageArraySize);
+ ASSERT(Pfn < MmPageArraySize);
KeAcquireSpinLock(&PageListLock, &oldIrql);
MmPageArray[Pfn].AllFlags = Flags;
KeReleaseSpinLock(&PageListLock, oldIrql);
KIRQL oldIrql;
ULONG Flags;
- assert (Pfn < MmPageArraySize);
+ ASSERT(Pfn < MmPageArraySize);
KeAcquireSpinLock(&PageListLock, &oldIrql);
Flags = MmPageArray[Pfn].AllFlags;
KeReleaseSpinLock(&PageListLock, oldIrql);
{
KIRQL oldIrql;
- assert (Pfn < MmPageArraySize);
+ ASSERT(Pfn < MmPageArraySize);
KeAcquireSpinLock(&PageListLock, &oldIrql);
MmPageArray[Pfn].SavedSwapEntry = SavedSwapEntry;
KeReleaseSpinLock(&PageListLock, oldIrql);
SWAPENTRY SavedSwapEntry;
KIRQL oldIrql;
- assert (Pfn < MmPageArraySize);
+ ASSERT(Pfn < MmPageArraySize);
KeAcquireSpinLock(&PageListLock, &oldIrql);
SavedSwapEntry = MmPageArray[Pfn].SavedSwapEntry;
KeReleaseSpinLock(&PageListLock, oldIrql);
current = CONTAINING_RECORD(current_entry,
MEMORY_AREA,
Entry);
- assert(current_entry->Blink->Flink == current_entry);
- assert(current_entry->Flink->Blink == current_entry);
- assert(previous_entry->Flink == current_entry);
+ ASSERT(current_entry->Blink->Flink == current_entry);
+ ASSERT(current_entry->Flink->Blink == current_entry);
+ ASSERT(previous_entry->Flink == current_entry);
if (current->BaseAddress <= Address &&
(PVOID)((char*)current->BaseAddress + current->Length) > Address)
{
if (BoundaryAddressMultiple.QuadPart != 0)
{
EndAddress = ((char*)(*BaseAddress)) + tmpLength-1;
- assert(((DWORD_PTR)*BaseAddress/BoundaryAddressMultiple.QuadPart) == ((DWORD_PTR)EndAddress/BoundaryAddressMultiple.QuadPart));
+ ASSERT(((DWORD_PTR)*BaseAddress/BoundaryAddressMultiple.QuadPart) == ((DWORD_PTR)EndAddress/BoundaryAddressMultiple.QuadPart));
}
if (MmOpenMemoryAreaByRegion(AddressSpace,
-/* $Id: mdl.c,v 1.68 2004/08/15 16:39:07 chorns Exp $
+/* $Id: mdl.c,v 1.69 2004/10/22 20:38:22 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
NTSTATUS Status;
/* pretty sure you can't map partial mdl's to user space */
- assert(!(Mdl->MdlFlags & MDL_PARTIAL));
+ ASSERT(!(Mdl->MdlFlags & MDL_PARTIAL));
BoundaryAddressMultiple.QuadPart = 0;
Base = NULL;
else /* if (AccessMode == KernelMode) */
{
/* can't map mdl twice */
- assert(!(Mdl->MdlFlags & (MDL_MAPPED_TO_SYSTEM_VA|MDL_PARTIAL_HAS_BEEN_MAPPED)));
+ ASSERT(!(Mdl->MdlFlags & (MDL_MAPPED_TO_SYSTEM_VA|MDL_PARTIAL_HAS_BEEN_MAPPED)));
/* can't map mdl buildt from non paged pool into kernel space */
- assert(!(Mdl->MdlFlags & (MDL_SOURCE_IS_NONPAGED_POOL)));
+ ASSERT(!(Mdl->MdlFlags & (MDL_SOURCE_IS_NONPAGED_POOL)));
CurrentProcess = NULL;
if ((DWORD)BaseAddress >= KERNEL_BASE)
{
- assert(Mdl->MdlFlags & MDL_MAPPED_TO_SYSTEM_VA);
+ ASSERT(Mdl->MdlFlags & MDL_MAPPED_TO_SYSTEM_VA);
KeAcquireSpinLock(&MiMdlMappingRegionLock, &oldIrql);
/* Deallocate all the pages used. */
{
MEMORY_AREA *Marea;
- assert(Mdl->Process == PsGetCurrentProcess());
+ ASSERT(Mdl->Process == PsGetCurrentProcess());
Marea = MmOpenMemoryAreaByAddress( &Mdl->Process->AddressSpace, BaseAddress );
if (Marea == NULL)
DPRINT("MmProbeAndLockPages(Mdl %x)\n", Mdl);
- assert(!(Mdl->MdlFlags & (MDL_PAGES_LOCKED|MDL_MAPPED_TO_SYSTEM_VA|MDL_PARTIAL|
+ ASSERT(!(Mdl->MdlFlags & (MDL_PAGES_LOCKED|MDL_MAPPED_TO_SYSTEM_VA|MDL_PARTIAL|
MDL_IO_SPACE|MDL_SOURCE_IS_NONPAGED_POOL)));
MdlPages = (PPFN_TYPE)(Mdl + 1);
NrPages = PAGE_ROUND_UP(Mdl->ByteOffset + Mdl->ByteCount) / PAGE_SIZE;
/* mdl must have enough page entries */
- assert(NrPages <= (Mdl->Size - sizeof(MDL))/sizeof(PFN_TYPE));
+ ASSERT(NrPages <= (Mdl->Size - sizeof(MDL))/sizeof(PFN_TYPE));
if (Mdl->StartVa >= (PVOID)KERNEL_BASE &&
* mdl buffer must (at least) be in kernel space, thou this doesn't
* necesarely mean that the buffer in within _nonpaged_ kernel space...
*/
- assert((ULONG)Mdl->StartVa >= KERNEL_BASE);
+ ASSERT((ULONG)Mdl->StartVa >= KERNEL_BASE);
PageCount = PAGE_ROUND_UP(Mdl->ByteOffset + Mdl->ByteCount) / PAGE_SIZE;
MdlPages = (PPFN_TYPE)(Mdl + 1);
/* mdl must have enough page entries */
- assert(PageCount <= (Mdl->Size - sizeof(MDL))/sizeof(PFN_TYPE));
+ ASSERT(PageCount <= (Mdl->Size - sizeof(MDL))/sizeof(PFN_TYPE));
for (i=0; i < PageCount; i++)
{
*/
/* SkipBytes must be a multiple of the page size */
- assert((SkipBytes.QuadPart % PAGE_SIZE) == 0);
+ ASSERT((SkipBytes.QuadPart % PAGE_SIZE) == 0);
UNIMPLEMENTED;
return(NULL);
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
-/* $Id: mm.c,v 1.78 2004/08/21 19:04:47 tamlin Exp $
+/* $Id: mm.c,v 1.79 2004/10/22 20:38:22 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top directory
* PROJECT: ReactOS kernel
{
case MEMORY_AREA_SECTION_VIEW:
Status = MmUnmapViewOfSection(Process, Marea->BaseAddress);
- assert(Status == STATUS_SUCCESS);
+ ASSERT(Status == STATUS_SUCCESS);
return(STATUS_SUCCESS);
case MEMORY_AREA_VIRTUAL_MEMORY:
-/* $Id: mminit.c,v 1.70 2004/10/04 21:38:49 ion Exp $
+/* $Id: mminit.c,v 1.71 2004/10/22 20:38:22 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top directory
* PROJECT: ReactOS kernel
BoundaryAddressMultiple);
BaseAddress = (PVOID)PAGE_ROUND_UP(((ULONG)&_text_end__));
- assert (BaseAddress == (PVOID)&_init_start__);
+ ASSERT(BaseAddress == (PVOID)&_init_start__);
Length = PAGE_ROUND_UP(((ULONG)&_init_end__)) -
PAGE_ROUND_UP(((ULONG)&_text_end__));
ParamLength = ParamLength - Length;
PFN_TYPE Page, SWAPENTRY SwapEntry,
BOOLEAN Dirty)
{
- assert(SwapEntry == 0);
+ ASSERT(SwapEntry == 0);
if (Page != 0)
{
MmReleasePageMemoryConsumer(MC_NPPOOL, Page);
-/* $Id: ncache.c,v 1.30 2004/08/15 16:39:08 chorns Exp $
+/* $Id: ncache.c,v 1.31 2004/10/22 20:38:22 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
PFN_TYPE Page, SWAPENTRY SwapEntry,
BOOLEAN Dirty)
{
- assert(SwapEntry == 0);
+ ASSERT(SwapEntry == 0);
if (Page != 0)
{
MmReleasePageMemoryConsumer(MC_NPPOOL, Page);
-/* $Id: npool.c,v 1.91 2004/10/01 20:51:28 arty Exp $
+/* $Id: npool.c,v 1.92 2004/10/22 20:38:22 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
}
else
{
- assert (x->balance == +1);
+ ASSERT(x->balance == +1);
w = x->link[1];
x->link[1] = w->link[0];
w->link[0] = x;
}
else
{
- assert (x->balance == -1);
+ ASSERT(x->balance == -1);
w = x->link[0];
x->link[0] = w->link[1];
w->link[1] = x;
{
PNODE w;
- assert (x->balance == -1);
+ ASSERT(x->balance == -1);
w = x->link[0];
x->link[0] = w->link[1];
w->link[1] = x;
if (x->balance == +1)
{
PNODE w;
- assert (x->balance == +1);
+ ASSERT(x->balance == +1);
w = x->link[1];
x->link[1] = w->link[0];
w->link[0] = x;
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
-/* $Id: section.c,v 1.165 2004/10/09 12:17:54 gvg Exp $
+/* $Id: section.c,v 1.166 2004/10/22 20:38:23 ekohl Exp $
*
* PROJECT: ReactOS kernel
* FILE: ntoskrnl/mm/section.c
FileOffset = SegOffset + MemoryArea->Data.SectionData.Segment->FileOffset;
IsImageSection = MemoryArea->Data.SectionData.Section->AllocationAttributes & SEC_IMAGE ? TRUE : FALSE;
- assert(Bcb);
+ ASSERT(Bcb);
DPRINT("%S %x\n", FileObject->FileName.Buffer, FileOffset);
*/
if (DirectMapped && !Private)
{
- assert(SwapEntry == 0);
+ ASSERT(SwapEntry == 0);
CcRosMarkDirtyCacheSegment(Bcb, Offset + MemoryArea->Data.SectionData.ViewOffset);
PageOp->Status = STATUS_SUCCESS;
MmspCompleteAndReleasePageOp(PageOp);
FileObject = MemoryArea->Data.SectionData.Section->FileObject;
Bcb = FileObject->SectionObjectPointer->SharedCacheMap;
CcRosMarkDirtyCacheSegment(Bcb, Offset);
- assert(SwapEntry == 0);
+ ASSERT(SwapEntry == 0);
}
}
DPRINT("Opening memory area Process %x BaseAddress %x\n",
Process, BaseAddress);
- assert(Process);
+ ASSERT(Process);
AddressSpace = &Process->AddressSpace;
MemoryArea = MmOpenMemoryAreaByAddress(AddressSpace,
ULONG ViewOffset;
NTSTATUS Status = STATUS_SUCCESS;
- assert(Process);
+ ASSERT(Process);
Section = (PSECTION_OBJECT)SectionObject;
AddressSpace = &Process->AddressSpace;
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
-/* $Id: virtual.c,v 1.80 2004/08/31 20:17:18 hbirr Exp $
+/* $Id: virtual.c,v 1.81 2004/10/22 20:38:23 ekohl Exp $
*
* PROJECT: ReactOS kernel
* FILE: ntoskrnl/mm/virtual.c
IN ULONG Length,
IN ULONG Alignment)
{
- assert (Alignment ==1 || Alignment == 2 || Alignment == 4 || Alignment == 8);
+ ASSERT(Alignment ==1 || Alignment == 2 || Alignment == 4 || Alignment == 8);
if (Length == 0)
return;
ULONG x;
ULONG i;
- assert (Alignment ==1 || Alignment == 2 || Alignment == 4 || Alignment == 8);
+ ASSERT(Alignment ==1 || Alignment == 2 || Alignment == 4 || Alignment == 8);
if (Length == 0)
return;
-/* $Id: nttimer.c,v 1.24 2004/08/15 16:39:09 chorns Exp $
+/* $Id: nttimer.c,v 1.25 2004/10/22 20:41:10 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
VOID INIT_FUNCTION
NtInitializeTimerImplementation(VOID)
{
- assert(!ExTimerType)
+ ASSERT(!ExTimerType)
ExTimerType = ExAllocatePool(NonPagedPool, sizeof(OBJECT_TYPE));
RtlCreateUnicodeString(&ExTimerType->TypeName, L"Timer");
-/* $Id: object.c,v 1.83 2004/08/15 16:39:10 chorns Exp $
+/* $Id: object.c,v 1.84 2004/10/22 20:43:58 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
PSECURITY_DESCRIPTOR NewSecurityDescriptor = NULL;
SECURITY_SUBJECT_CONTEXT SubjectContext;
- assert_irql(APC_LEVEL);
+ ASSERT_IRQL(APC_LEVEL);
DPRINT("ObCreateObject(Type %p ObjectAttributes %p, Object %p)\n",
Type, ObjectAttributes, Object);
static NTSTATUS
ObpDeleteObject(POBJECT_HEADER Header)
{
- DPRINT("ObPerformRetentionChecks(Header %p)\n", Header);
+ DPRINT("ObpDeleteObject(Header %p)\n", Header);
if (KeGetCurrentIrql() != PASSIVE_LEVEL)
{
- DPRINT("ObpPerformRetentionChecks called at an unsupported IRQL. Use ObpPerformRetentionChecksDpcLevel instead.\n");
+ DPRINT("ObpDeleteObject called at an unsupported IRQL. Use ObpDeleteObjectDpcLevel instead.\n");
KEBUGCHECK(0);
}
PRETENTION_CHECK_PARAMS Params = (PRETENTION_CHECK_PARAMS)Parameter;
/* ULONG Tag; */ /* See below */
- assert(Params);
- assert(KeGetCurrentIrql() == PASSIVE_LEVEL); /* We need PAGED_CODE somewhere... */
+ ASSERT(Params);
+ ASSERT(KeGetCurrentIrql() == PASSIVE_LEVEL); /* We need PAGED_CODE somewhere... */
/* Turn this on when we have ExFreePoolWithTag
Tag = Params->ObjectHeader->ObjectType->Tag; */
return STATUS_PENDING;
default:
- DPRINT("ObpPerformRetentionChecksDpcLevel called at unsupported "
+ DPRINT("ObpDeleteObjectDpcLevel called at unsupported "
"IRQL %u!\n", KeGetCurrentIrql());
KEBUGCHECK(0);
return STATUS_UNSUCCESSFUL;
{
POBJECT_HEADER Header;
- assert(Object);
+ ASSERT(Object);
Header = BODY_TO_HEADER(Object);
BOOL Permanent;
ULONG HandleCount;
- assert(Object);
+ ASSERT(Object);
/* Extract the object header. */
Header = BODY_TO_HEADER(Object);
last reference.
*/
NewRefCount = InterlockedDecrement(&Header->RefCount);
- assert(NewRefCount >= 0);
+ ASSERT(NewRefCount >= 0);
/* Check whether the object can now be deleted. */
if (NewRefCount == 0 &&
{
POBJECT_HEADER Header;
- assert(Object);
+ ASSERT(Object);
Header = BODY_TO_HEADER(Object);
- return(Header->RefCount);
+ return Header->RefCount;
}
{
POBJECT_HEADER Header;
- assert(Object);
+ ASSERT(Object);
Header = BODY_TO_HEADER(Object);
- return(Header->HandleCount);
+ return Header->HandleCount;
}
-/* $Id: symlink.c,v 1.9 2004/08/15 16:39:10 chorns Exp $
+/* $Id: symlink.c,v 1.10 2004/10/22 20:43:58 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
PSYMLINK_OBJECT SymbolicLink;
NTSTATUS Status;
- assert_irql(PASSIVE_LEVEL);
+ ASSERT_IRQL(PASSIVE_LEVEL);
DPRINT("NtCreateSymbolicLinkObject(SymbolicLinkHandle %p, DesiredAccess %ul, ObjectAttributes %p, DeviceName %wZ)\n",
SymbolicLinkHandle,
projects / reactos.git / commitdiff