Ros-diffs January 2006

ros-diffs@reactos.org

23 participants
586 discussions

[gvg] 20563: Fix (so far harmless) typo

by gvg＠svn.reactos.org

Fix (so far harmless) typo Modified: trunk/reactos/ntoskrnl/ex/work.c _____ Modified: trunk/reactos/ntoskrnl/ex/work.c --- trunk/reactos/ntoskrnl/ex/work.c 2006-01-04 22:40:48 UTC (rev 20562) +++ trunk/reactos/ntoskrnl/ex/work.c 2006-01-04 22:46:45 UTC (rev 20563) @@ -523,7 +523,7 @@ /* Protect against greedy registry modifications */ ExpAdditionalDelayedWorkerThreads = - min(ExpAdditionalCriticalWorkerThreads, 16); + min(ExpAdditionalDelayedWorkerThreads, 16); ExpAdditionalCriticalWorkerThreads = min(ExpAdditionalCriticalWorkerThreads, 16);

18 years, 10 months

[gvg] 20562: Let oskit tell us when sending should be blocked 'cause its stuffed upto its

by gvg＠svn.reactos.org

Let oskit tell us when sending should be blocked 'cause its stuffed upto its nose with data waiting to be sent. Bug 1232. Modified: trunk/reactos/drivers/lib/ip/transport/tcp/event.c Modified: trunk/reactos/drivers/lib/ip/transport/tcp/tcp.c Modified: trunk/reactos/drivers/lib/oskittcp/oskittcp/interface.c Modified: trunk/reactos/drivers/lib/oskittcp/oskittcp/sleep.c Modified: trunk/reactos/drivers/net/afd/afd/write.c Modified: trunk/reactos/drivers/net/tcpip/include/tcp.h Modified: trunk/reactos/drivers/net/tcpip/include/titypes.h Modified: trunk/reactos/drivers/net/tcpip/tcpip/dispatch.c _____ Modified: trunk/reactos/drivers/lib/ip/transport/tcp/event.c --- trunk/reactos/drivers/lib/ip/transport/tcp/event.c 2006-01-04 20:45:58 UTC (rev 20561) +++ trunk/reactos/drivers/lib/ip/transport/tcp/event.c 2006-01-04 22:40:48 UTC (rev 20562) @@ -121,6 +121,11 @@ KeInitializeEvent( &SleepingThread->Event, NotificationEvent, FALSE ); SleepingThread->SleepToken = token; + /* We're going to sleep and need to release the lock, otherwise + it's impossible to re-enter oskittcp to deliver the event that's + going to wake us */ + TcpipRecursiveMutexLeave( &TCPLock ); + TcpipAcquireFastMutex( &SleepingThreadsLock ); InsertTailList( &SleepingThreadsList, &SleepingThread->Entry ); TcpipReleaseFastMutex( &SleepingThreadsLock ); @@ -136,6 +141,8 @@ RemoveEntryList( &SleepingThread->Entry ); TcpipReleaseFastMutex( &SleepingThreadsLock ); + TcpipRecursiveMutexEnter( &TCPLock, TRUE ); + PoolFreeBuffer( SleepingThread ); } TI_DbgPrint(DEBUG_TCP,("Waiting finished: %x\n", token)); _____ Modified: trunk/reactos/drivers/lib/ip/transport/tcp/tcp.c --- trunk/reactos/drivers/lib/ip/transport/tcp/tcp.c 2006-01-04 20:45:58 UTC (rev 20561) +++ trunk/reactos/drivers/lib/ip/transport/tcp/tcp.c 2006-01-04 22:40:48 UTC (rev 20562) @@ -153,7 +153,64 @@ } } } + if( NewState & SEL_WRITE ) { + TI_DbgPrint(DEBUG_TCP,("Writeable: irp list %s\n", + IsListEmpty(&Connection->ReceiveRequest) ? + "empty" : "nonempty")); + while( !IsListEmpty( &Connection->SendRequest ) ) { + OSK_UINT SendLen = 0, Sent = 0; + OSK_PCHAR SendBuffer = 0; + + Entry = RemoveHeadList( &Connection->SendRequest ); + Bucket = CONTAINING_RECORD( Entry, TDI_BUCKET, Entry ); + Complete = Bucket->Request.RequestNotifyObject; + + Irp = Bucket->Request.RequestContext; + Mdl = Irp->MdlAddress; + + TI_DbgPrint(DEBUG_TCP, + ("Getting the user buffer from %x\n", Mdl)); + + NdisQueryBuffer( Mdl, &SendBuffer, &SendLen ); + + TI_DbgPrint(DEBUG_TCP, + ("Writing %d bytes to %x\n", SendLen, SendBuffer)); + + TI_DbgPrint(DEBUG_TCP, ("Connection: %x\n", Connection)); + TI_DbgPrint + (DEBUG_TCP, + ("Connection->SocketContext: %x\n", + Connection->SocketContext)); + + Status = TCPTranslateError + ( OskitTCPSend( Connection->SocketContext, + SendBuffer, + SendLen, + &Sent, + 0 ) ); + + TI_DbgPrint(DEBUG_TCP,("TCP Bytes: %d\n", Sent)); + + if( Status == STATUS_SUCCESS ) { + TI_DbgPrint(DEBUG_TCP,("Sent %d bytes with status %x\n", + Sent, Status)); + + Complete( Bucket->Request.RequestContext, + STATUS_SUCCESS, Sent ); + } else if( Status == STATUS_PENDING ) { + InsertHeadList + ( &Connection->SendRequest, &Bucket->Entry ); + break; + } else { + TI_DbgPrint(DEBUG_TCP, + ("Completing Send request: %x %x\n", + Bucket->Request, Status)); + Complete( Bucket->Request.RequestContext, Status, 0 ); + } + } + } + if( NewState & SEL_FIN ) { PLIST_ENTRY ListsToErase[4]; NTSTATUS IrpStatus[4]; @@ -209,6 +266,7 @@ InitializeListHead(&Connection->ConnectRequest); InitializeListHead(&Connection->ListenRequest); InitializeListHead(&Connection->ReceiveRequest); + InitializeListHead(&Connection->SendRequest); /* Save client context pointer */ Connection->ClientContext = ClientContext; @@ -656,11 +714,18 @@ NTSTATUS TCPSendData ( PCONNECTION_ENDPOINT Connection, PCHAR BufferData, - ULONG PacketSize, - PULONG DataUsed, - ULONG Flags) { + ULONG SendLength, + PULONG BytesSent, + ULONG Flags, + PTCP_COMPLETION_ROUTINE Complete, + PVOID Context ) { + UINT Sent = 0; NTSTATUS Status; + PTDI_BUCKET Bucket; + TI_DbgPrint(DEBUG_TCP,("Called for %d bytes (on socket %x)\n", + SendLength, Connection->SocketContext)); + ASSERT_KM_POINTER(Connection->SocketContext); TcpipRecursiveMutexEnter( &TCPLock, TRUE ); @@ -669,12 +734,38 @@ TI_DbgPrint(DEBUG_TCP,("Connection->SocketContext = %x\n", Connection->SocketContext)); - Status = OskitTCPSend( Connection->SocketContext, - (OSK_PCHAR)BufferData, PacketSize, - (PUINT)DataUsed, 0 ); + Status = TCPTranslateError + ( OskitTCPSend( Connection->SocketContext, + (OSK_PCHAR)BufferData, SendLength, + &Sent, 0 ) ); + TI_DbgPrint(DEBUG_TCP,("OskitTCPSend: %x, %d\n", Status, Sent)); + + /* Keep this request around ... there was no data yet */ + if( Status == STATUS_PENDING ) { + /* Freed in TCPSocketState */ + Bucket = ExAllocatePool( NonPagedPool, sizeof(*Bucket) ); + if( !Bucket ) { + TI_DbgPrint(DEBUG_TCP,("Failed to allocate bucket\n")); + TcpipRecursiveMutexLeave( &TCPLock ); + return STATUS_NO_MEMORY; + } + + Bucket->Request.RequestNotifyObject = Complete; + Bucket->Request.RequestContext = Context; + *BytesSent = 0; + + InsertHeadList( &Connection->SendRequest, &Bucket->Entry ); + TI_DbgPrint(DEBUG_TCP,("Queued write irp\n")); + } else { + TI_DbgPrint(DEBUG_TCP,("Got status %x, bytes %d\n", Status, Sent)); + *BytesSent = Sent; + } + TcpipRecursiveMutexLeave( &TCPLock ); + TI_DbgPrint(DEBUG_TCP,("Status %x\n", Status)); + return Status; } @@ -729,14 +820,14 @@ PTDI_BUCKET Bucket; UINT i = 0; - ListHead[0] = &Endpoint->ReceiveRequest; - ListHead[1] = &Endpoint->ConnectRequest; - ListHead[2] = &Endpoint->ListenRequest; - ListHead[3] = 0; + ListHead[0] = &Endpoint->SendRequest; + ListHead[1] = &Endpoint->ReceiveRequest; + ListHead[2] = &Endpoint->ConnectRequest; + ListHead[3] = &Endpoint->ListenRequest; TcpipAcquireSpinLock( &Endpoint->Lock, &OldIrql ); - for( i = 0; ListHead[i]; i++ ) { + for( i = 0; i < sizeof( ListHead ) / sizeof( ListHead[0] ); i++ ) { for( Entry = ListHead[i]->Flink; Entry != ListHead[i]; Entry = Entry->Flink ) { _____ Modified: trunk/reactos/drivers/lib/oskittcp/oskittcp/interface.c --- trunk/reactos/drivers/lib/oskittcp/oskittcp/interface.c 2006-01-04 20:45:58 UTC (rev 20561) +++ trunk/reactos/drivers/lib/oskittcp/oskittcp/interface.c 2006-01-04 22:40:48 UTC (rev 20562) @@ -256,12 +256,26 @@ int OskitTCPSend( void *socket, OSK_PCHAR Data, OSK_UINT Len, OSK_UINT *OutLen, OSK_UINT flags ) { - struct mbuf* m = m_devget( Data, Len, 0, NULL, NULL ); - int error = 0; - if ( !m ) - return ENOBUFS; - error = sosend( socket, NULL, NULL, m, NULL, 0 ); - *OutLen = Len; + int error; + struct uio uio; + struct iovec iov; + + iov.iov_len = Len; + iov.iov_base = Data; + uio.uio_iov = &iov; + uio.uio_iovcnt = 1; + uio.uio_offset = 0; + uio.uio_resid = Len; + uio.uio_segflg = UIO_SYSSPACE; + uio.uio_rw = UIO_WRITE; + uio.uio_procp = NULL; + + error = sosend( socket, NULL, &uio, NULL, NULL, 0 ); + if (OSK_EWOULDBLOCK == error) { + ((struct socket *) socket)->so_snd.sb_flags |= SB_WAIT; + } + *OutLen = uio.uio_offset; + return error; } _____ Modified: trunk/reactos/drivers/lib/oskittcp/oskittcp/sleep.c --- trunk/reactos/drivers/lib/oskittcp/oskittcp/sleep.c 2006-01-04 20:45:58 UTC (rev 20561) +++ trunk/reactos/drivers/lib/oskittcp/oskittcp/sleep.c 2006-01-04 22:40:48 UTC (rev 20562) @@ -35,6 +35,10 @@ OS_DbgPrint(OSK_MID_TRACE,("Socket readable\n")); flags |= SEL_READ; } + if( 0 < sbspace(&so->so_snd) ) { + OS_DbgPrint(OSK_MID_TRACE,("Socket writeable\n")); + flags |= SEL_WRITE; + } if( so->so_state & SS_CANTRCVMORE ) { OS_DbgPrint(OSK_MID_TRACE,("Socket can't be read any longer\n")); flags |= SEL_FIN; _____ Modified: trunk/reactos/drivers/net/afd/afd/write.c --- trunk/reactos/drivers/net/afd/afd/write.c 2006-01-04 20:45:58 UTC (rev 20561) +++ trunk/reactos/drivers/net/afd/afd/write.c 2006-01-04 22:40:48 UTC (rev 20562) @@ -1,4 +1,4 @@ -/* $Id$ +/* * COPYRIGHT: See COPYING in the top level directory * PROJECT: ReactOS kernel * FILE: drivers/net/afd/afd/write.c @@ -17,7 +17,6 @@ PIRP Irp, PVOID Context ) { NTSTATUS Status = Irp->IoStatus.Status; - PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp); PAFD_FCB FCB = (PAFD_FCB)Context; PLIST_ENTRY NextIrpEntry; PIRP NextIrp = NULL; @@ -26,6 +25,15 @@ PAFD_MAPBUF Map; UINT TotalBytesCopied = 0, SpaceAvail, i, CopySize = 0; + /* + * The Irp parameter passed in is the IRP of the stream between AFD and + * TDI driver. It's not very usefull to us. We need the IRPs of the stream + * between usermode and AFD. Those are chained from + * FCB->PendingIrpList[FUNCTION_SEND] and you'll see them in the code + * below as "NextIrp" ('cause they are the next usermode IRP to be + * processed). + */ + AFD_DbgPrint(MID_TRACE,("Called, status %x, %d bytes used\n", Irp->IoStatus.Status, Irp->IoStatus.Information)); @@ -78,7 +86,7 @@ !IsListEmpty( &FCB->PendingIrpList[FUNCTION_SEND] ) && NT_SUCCESS(Status) ) { NextIrpEntry = - RemoveHeadList(&FCB->PendingIrpList[FUNCTION_RECV]); + RemoveHeadList(&FCB->PendingIrpList[FUNCTION_SEND]); NextIrp = CONTAINING_RECORD(NextIrpEntry, IRP, Tail.Overlay.ListEntry); NextIrpSp = IoGetCurrentIrpStackLocation( NextIrp ); @@ -89,8 +97,7 @@ SpaceAvail = FCB->Send.Size - FCB->Send.BytesUsed; - for( i = 0; FCB->Send.BytesUsed < FCB->Send.Content && - i < SendReq->BufferCount; i++ ) { + for( i = 0; i < SendReq->BufferCount; i++ ) { Map[i].BufferAddress = MmMapLockedPages( Map[i].Mdl, KernelMode ); @@ -101,7 +108,7 @@ Map[i].BufferAddress, CopySize ); - MmUnmapLockedPages( Map[i].Mdl, KernelMode ); + MmUnmapLockedPages( Map[i].BufferAddress, Map[i].Mdl ); FCB->Send.BytesUsed += CopySize; TotalBytesCopied += CopySize; @@ -116,7 +123,7 @@ SocketCalloutEnter( FCB ); Status = TdiSend( &FCB->SendIrp.InFlightRequest, - IrpSp->FileObject, + FCB->Connection.Object, 0, FCB->Send.Window, FCB->Send.BytesUsed, @@ -138,13 +145,13 @@ AFD_DbgPrint(MID_TRACE,("Dismissing request: %x\n", Status)); - return UnlockAndMaybeComplete( FCB, Status, Irp, TotalBytesCopied, + return UnlockAndMaybeComplete( FCB, Status, NextIrp, TotalBytesCopied, NULL, TRUE ); } else if( NextIrp ) { AFD_DbgPrint(MID_TRACE,("Could not do any more with Irp %x\n", NextIrp)); InsertHeadList( &FCB->PendingIrpList[FUNCTION_SEND], - &Irp->Tail.Overlay.ListEntry ); + &NextIrp->Tail.Overlay.ListEntry ); } SocketStateUnlock( FCB ); _____ Modified: trunk/reactos/drivers/net/tcpip/include/tcp.h --- trunk/reactos/drivers/net/tcpip/include/tcp.h 2006-01-04 20:45:58 UTC (rev 20561) +++ trunk/reactos/drivers/net/tcpip/include/tcp.h 2006-01-04 22:40:48 UTC (rev 20562) @@ -150,7 +150,9 @@ PCHAR Buffer, ULONG DataSize, PULONG DataUsed, - ULONG Flags); + ULONG Flags, + PTCP_COMPLETION_ROUTINE Complete, + PVOID Context); NTSTATUS TCPClose( PCONNECTION_ENDPOINT Connection ); _____ Modified: trunk/reactos/drivers/net/tcpip/include/titypes.h --- trunk/reactos/drivers/net/tcpip/include/titypes.h 2006-01-04 20:45:58 UTC (rev 20561) +++ trunk/reactos/drivers/net/tcpip/include/titypes.h 2006-01-04 22:40:48 UTC (rev 20562) @@ -302,6 +302,7 @@ LIST_ENTRY ConnectRequest; /* Queued connect rqueusts */ LIST_ENTRY ListenRequest; /* Queued listen requests */ LIST_ENTRY ReceiveRequest; /* Queued receive requests */ + LIST_ENTRY SendRequest; /* Queued send requests */ /* Signals */ LIST_ENTRY SignalList; /* Entry in the list of sockets waiting for _____ Modified: trunk/reactos/drivers/net/tcpip/tcpip/dispatch.c --- trunk/reactos/drivers/net/tcpip/tcpip/dispatch.c 2006-01-04 20:45:58 UTC (rev 20561) +++ trunk/reactos/drivers/net/tcpip/tcpip/dispatch.c 2006-01-04 22:40:48 UTC (rev 20562) @@ -898,15 +898,15 @@ */ { PIO_STACK_LOCATION IrpSp; - PTDI_REQUEST_KERNEL_RECEIVE ReceiveInfo; + PTDI_REQUEST_KERNEL_SEND SendInfo; PTRANSPORT_CONTEXT TranContext; NTSTATUS Status; - ULONG BytesReceived; + ULONG BytesSent; TI_DbgPrint(DEBUG_IRP, ("Called.\n")); IrpSp = IoGetCurrentIrpStackLocation(Irp); - ReceiveInfo = (PTDI_REQUEST_KERNEL_RECEIVE)&(IrpSp->Parameters); + SendInfo = (PTDI_REQUEST_KERNEL_SEND)&(IrpSp->Parameters); TranContext = IrpSp->FileObject->FsContext; if (TranContext == NULL) @@ -938,12 +938,14 @@ Status = TCPSendData( TranContext->Handle.ConnectionContext, Data, - ReceiveInfo->ReceiveLength, - &BytesReceived, - ReceiveInfo->ReceiveFlags); + SendInfo->SendLength, + &BytesSent, + SendInfo->SendFlags, + DispDataRequestComplete, + Irp); if (Status != STATUS_PENDING) { - DispDataRequestComplete(Irp, Status, BytesReceived); + DispDataRequestComplete(Irp, Status, BytesSent); } else IoMarkIrpPending( Irp ); }

18 years, 10 months

[ion] 20561: - Fix worker thread priorities. A quick check of the DDK and ProcesXP confirmed that there was a bug (thanks GvG!). Turns out I had forgotten to use the -base- priority kernel call. Renamed some variables to make it clearer and fixed the bug. The correct priorities are 12, 13, 15.

by ion＠svn.reactos.org

- Fix worker thread priorities. A quick check of the DDK and ProcesXP confirmed that there was a bug (thanks GvG!). Turns out I had forgotten to use the -base- priority kernel call. Renamed some variables to make it clearer and fixed the bug. The correct priorities are 12, 13, 15. Modified: trunk/reactos/ntoskrnl/ex/work.c Modified: trunk/reactos/ntoskrnl/ke/kthread.c _____ Modified: trunk/reactos/ntoskrnl/ex/work.c --- trunk/reactos/ntoskrnl/ex/work.c 2006-01-04 14:26:06 UTC (rev 20560) +++ trunk/reactos/ntoskrnl/ex/work.c 2006-01-04 20:45:58 UTC (rev 20561) @@ -19,17 +19,17 @@ /* DATA **********************************************************************/ /* Number of worker threads for each Queue */ -#define EX_HYPERCRITICAL_WORK_THREADS 1 -#define EX_DELAYED_WORK_THREADS 3 -#define EX_CRITICAL_WORK_THREADS 5 +#define EX_HYPERCRITICAL_WORK_THREADS 1 +#define EX_DELAYED_WORK_THREADS 3 +#define EX_CRITICAL_WORK_THREADS 5 /* Magic flag for dynamic worker threads */ -#define EX_DYNAMIC_WORK_THREAD 0x80000000 +#define EX_DYNAMIC_WORK_THREAD 0x80000000 -/* Worker thread priorities */ -#define EX_HYPERCRITICAL_QUEUE_PRIORITY 7 -#define EX_CRITICAL_QUEUE_PRIORITY 5 -#define EX_DELAYED_QUEUE_PRIORITY 4 +/* Worker thread priority increments (added to base priority) */ +#define EX_HYPERCRITICAL_QUEUE_PRIORITY_INCREMENT 7 +#define EX_CRITICAL_QUEUE_PRIORITY_INCREMENT 5 +#define EX_DELAYED_QUEUE_PRIORITY_INCREMENT 4 /* The actual worker queue array */ EX_WORK_QUEUE ExWorkerQueue[MaximumWorkQueue]; @@ -284,17 +284,17 @@ if (WorkQueueType == DelayedWorkQueue) { /* Priority == 4 */ - Priority = EX_DELAYED_QUEUE_PRIORITY; + Priority = EX_DELAYED_QUEUE_PRIORITY_INCREMENT; } else if (WorkQueueType == CriticalWorkQueue) { /* Priority == 5 */ - Priority = EX_CRITICAL_QUEUE_PRIORITY; + Priority = EX_CRITICAL_QUEUE_PRIORITY_INCREMENT; } else { /* Priority == 7 */ - Priority = EX_HYPERCRITICAL_QUEUE_PRIORITY; + Priority = EX_HYPERCRITICAL_QUEUE_PRIORITY_INCREMENT; } /* Get the Thread */ @@ -306,7 +306,7 @@ NULL); /* Set the Priority */ - KeSetPriorityThread(&Thread->Tcb, Priority); + KeSetBasePriorityThread(&Thread->Tcb, Priority); /* Dereference and close handle */ ObDereferenceObject(Thread); @@ -431,7 +431,7 @@ /* Raise our priority above all other worker threads */ KeSetBasePriorityThread(KeGetCurrentThread(), - EX_CRITICAL_QUEUE_PRIORITY + 1); + EX_CRITICAL_QUEUE_PRIORITY_INCREMENT + 1); /* Setup the timer */ KeInitializeTimer(&Timer); _____ Modified: trunk/reactos/ntoskrnl/ke/kthread.c --- trunk/reactos/ntoskrnl/ke/kthread.c 2006-01-04 14:26:06 UTC (rev 20560) +++ trunk/reactos/ntoskrnl/ke/kthread.c 2006-01-04 20:45:58 UTC (rev 20561) @@ -1177,15 +1177,12 @@ } /* - * Sets thread's base priority relative to the process' base priority - * Should only be passed in THREAD_PRIORITY_ constants in pstypes.h - * * @implemented */ LONG STDCALL -KeSetBasePriorityThread (PKTHREAD Thread, - LONG Increment) +KeSetBasePriorityThread(PKTHREAD Thread, + LONG Increment) { KIRQL OldIrql; PKPROCESS Process;

18 years, 10 months

[weiden] 20560: fixed gcc4 warnings

by weiden＠svn.reactos.org

fixed gcc4 warnings Modified: trunk/rosapps/demos/ddraw/ddraw.xml Modified: trunk/rosapps/sysutils/regexpl/ShellCommandValue.cpp Modified: trunk/rosapps/tests/combotst/combotst.c Modified: trunk/rosapps/tests/hivetest/hivetest.c _____ Modified: trunk/rosapps/demos/ddraw/ddraw.xml --- trunk/rosapps/demos/ddraw/ddraw.xml 2006-01-04 06:44:52 UTC (rev 20559) +++ trunk/rosapps/demos/ddraw/ddraw.xml 2006-01-04 14:26:06 UTC (rev 20560) @@ -1,4 +1,4 @@ -<module name="ddraw_demo" type="win32gui" installbase="system32" installname="ddraw_demo.exe"> +<module name="ddraw_demo" type="win32gui" installbase="system32" installname="ddraw_demo.exe" allowwarnings="true"> <define name="_WIN32_IE">0x0501</define> <define name="_WIN32_WINNT">0x0501</define> <define name="__USE_W32API" /> _____ Modified: trunk/rosapps/sysutils/regexpl/ShellCommandValue.cpp --- trunk/rosapps/sysutils/regexpl/ShellCommandValue.cpp 2006-01-04 06:44:52 UTC (rev 20559) +++ trunk/rosapps/sysutils/regexpl/ShellCommandValue.cpp 2006-01-04 14:26:06 UTC (rev 20560) @@ -243,7 +243,7 @@ default: { TCHAR Buffer[256]; - DWORD i; + DWORD i, j; for (i = 0 ; i < dwValueSize ; i++) { if (i%16 == 0) @@ -266,7 +266,7 @@ if (i && (i%16 == 15)) { // if this is the last byte in line // Dump text representation - for (DWORD j = i-15; j <= i; j += blnUnicodeDump?2:1)\ + for (j = i-15; j <= i; j += blnUnicodeDump?2:1)\ { if ((j%8 == 0)&&(j%16 != 0)) { // this is the additional space between 7th and 8th byte in current line @@ -321,7 +321,7 @@ if (k && (k%16 == 15)) { // if this is the last byte in line ASSERT((k-15)%16 == 0); // k-15 must point at begin of last line - for (DWORD j = k-15; j < i; j += j += blnUnicodeDump?2:1) + for (j = k-15; j < i; j += blnUnicodeDump?2:1) { if (blnUnicodeDump&&(j+1 >= i)) { // ok, buffer size is odd number, so we don't display last byte. _____ Modified: trunk/rosapps/tests/combotst/combotst.c --- trunk/rosapps/tests/combotst/combotst.c 2006-01-04 06:44:52 UTC (rev 20559) +++ trunk/rosapps/tests/combotst/combotst.c 2006-01-04 14:26:06 UTC (rev 20560) @@ -545,7 +545,7 @@ PrintTextXY("CBN_EDITCHANGE notification",NOTIFYX,NOTIFYY,27,srect); break; - case CBN_ERRSPACE: + case (WORD)CBN_ERRSPACE: ScrollWindow (hwnd, 0, SCROLLAMOUNT, &srect, &srect); PrintTextXY("CBN_ERRSPACE notification",NOTIFYX,NOTIFYY,25,srect); break; _____ Modified: trunk/rosapps/tests/hivetest/hivetest.c --- trunk/rosapps/tests/hivetest/hivetest.c 2006-01-04 06:44:52 UTC (rev 20559) +++ trunk/rosapps/tests/hivetest/hivetest.c 2006-01-04 14:26:06 UTC (rev 20560) @@ -804,7 +804,7 @@ LONG dwError; TOKEN_PRIVILEGES NewPrivileges; HANDLE Token,hKey; - LUID Luid; + LUID Luid = {0}; BOOLEAN bRes; Status=NtOpenProcessToken(GetCurrentProcess() ,TOKEN_ADJUST_PRIVILEGES,&Token);

18 years, 10 months

[jimtabor] 20559: Clean up and fixed NtUserGetMenuItemRect. Needs more testing. I watch mplayerc swip all the menu items with crashing.

by jimtabor＠svn.reactos.org

Clean up and fixed NtUserGetMenuItemRect. Needs more testing. I watch mplayerc swip all the menu items with crashing. Modified: trunk/reactos/subsys/win32k/ntuser/menu.c _____ Modified: trunk/reactos/subsys/win32k/ntuser/menu.c --- trunk/reactos/subsys/win32k/ntuser/menu.c 2006-01-03 23:41:57 UTC (rev 20558) +++ trunk/reactos/subsys/win32k/ntuser/menu.c 2006-01-04 06:44:52 UTC (rev 20559) @@ -1696,16 +1696,11 @@ LPRECT lprcItem) { ROSMENUINFO mi; - ROSMENUITEMINFO mii; HWND referenceHwnd; - LPPOINT lpPoints; - LPRECT lpRect = NULL; - POINT FromOffset; - LONG XMove, YMove; - ULONG i; + RECT Rect; NTSTATUS Status; PMENU_OBJECT Menu; - PWINDOW_OBJECT ReferenceWnd; + PMENU_ITEM MenuItem; DECLARE_RETURN(BOOL); DPRINT("Enter NtUserGetMenuItemRect\n"); @@ -1716,41 +1711,26 @@ RETURN(FALSE); } - if(!UserMenuItemInfo(Menu, uItem, MF_BYPOSITION, &mii, FALSE)) - RETURN( FALSE); - + if (IntGetMenuItemByFlag(Menu, uItem, MF_BYPOSITION, &MenuItem, NULL) > -1) + Rect = MenuItem->Rect; + else + RETURN(FALSE); + referenceHwnd = hWnd; - + if(!hWnd) { if(!UserMenuInfo(Menu, &mi, FALSE)) RETURN( FALSE); if(mi.Wnd == 0) RETURN( FALSE); - referenceHwnd = mi.Wnd; + referenceHwnd = mi.Wnd; /* Okay we found it, so now what do we do? */ } if (lprcItem == NULL) RETURN( FALSE); - *lpRect = mii.Rect; - lpPoints = (LPPOINT)lpRect; - ReferenceWnd = UserGetWindowObject(referenceHwnd); - if (!ReferenceWnd || !UserGetClientOrigin(ReferenceWnd, &FromOffset)) - { - RETURN( FALSE); - } - - XMove = FromOffset.x; - YMove = FromOffset.y; - - for (i = 0; i < 2; i++) - { - lpPoints[i].x += XMove; - lpPoints[i].y += YMove; - } - - Status = MmCopyToCaller(lprcItem, lpPoints, sizeof(RECT)); + Status = MmCopyToCaller(lprcItem, &Rect, sizeof(RECT)); if (! NT_SUCCESS(Status)) { SetLastNtError(Status);

18 years, 10 months

[gedmurphy] 20558: - Display a temporary note in ipconfig to avoid user confusion.

by gedmurphy＠svn.reactos.org

- Display a temporary note in ipconfig to avoid user confusion. - Requires fixing of GetAdaptersInfo Modified: trunk/reactos/apps/utils/net/ipconfig/ipconfig.c _____ Modified: trunk/reactos/apps/utils/net/ipconfig/ipconfig.c --- trunk/reactos/apps/utils/net/ipconfig/ipconfig.c 2006-01-03 23:36:05 UTC (rev 20557) +++ trunk/reactos/apps/utils/net/ipconfig/ipconfig.c 2006-01-03 23:41:57 UTC (rev 20558) @@ -144,12 +144,14 @@ } pAdapter = pAdapterInfo; - //HKEY hKey; - //LPCTSTR lpSubKey = _T("SYSTEM\\ControlSet\\Control\\Network"); + /* temp note until GetAdatersInfo is fixed */ + _tprintf(_T("Note - ipconfig is currently returning incorrect information\n")); + _tprintf(_T("If your adapter is configured correctly, it will usually \n")); + _tprintf(_T("display the loopback, otherwise an error will be displayed\n\n")); + _tprintf(_T("\nReactOS IP Configuration\n\n")); - if (bAll) { _tprintf(_T("\tHost Name . . . . . . . . . . . . : %s\n"), pFixedInfo->HostName);

18 years, 10 months

[ion] 20557: - Implement Pushlocks. Only Waking, and Exclusive Acquire/Release + Waits have been tested. The shared paths and block/unblock are still untested and may probably contain bugs. Pushlocks are not yet used in the kernel and they won't be until all paths are tested and validated.

by ion＠svn.reactos.org

- Implement Pushlocks. Only Waking, and Exclusive Acquire/Release + Waits have been tested. The shared paths and block/unblock are still untested and may probably contain bugs. Pushlocks are not yet used in the kernel and they won't be until all paths are tested and validated. - Public DDIs Implemented: ExfAcquirePushLockExclusive, ExfAcquirePushLockShared, ExfTryToWakePushLock, ExfReleasePushLock, ExfReleasePushLockExclusive, ExfReleasePushLockShared, ExfUnblockPushLock. Added: trunk/reactos/ntoskrnl/ex/pushlock.c Modified: trunk/reactos/ntoskrnl/include/internal/ex.h Modified: trunk/reactos/ntoskrnl/include/internal/ntoskrnl.h Modified: trunk/reactos/ntoskrnl/ntoskrnl.xml _____ Copied: trunk/reactos/ntoskrnl/ex/pushlock.c (from rev 20362, trunk/reactos/ntoskrnl/ex/synch.c) --- trunk/reactos/ntoskrnl/ex/synch.c 2005-12-27 01:14:55 UTC (rev 20362) +++ trunk/reactos/ntoskrnl/ex/pushlock.c 2006-01-03 23:36:05 UTC (rev 20557) @@ -0,0 +1,1164 @@ +/* + * COPYRIGHT: See COPYING in the top level directory + * PROJECT: ReactOS Kernel + * FILE: ntoskrnl/ex/pushlock.c + * PURPOSE: Pushlock and Cache-Aware Pushlock Implementation + * PROGRAMMER: Alex Ionescu (alex.ionescu(a)reactos.com) + */ + +/* INCLUDES *****************************************************************/ + +#include <ntoskrnl.h> +#define NDEBUG +#include <internal/debug.h> + +/* DATA **********************************************************************/ + +ULONG ExPushLockSpinCount; + +/* PRIVATE FUNCTIONS *********************************************************/ + +/*++ + * @name ExpInitializePushLocks + * + * The ExpInitializePushLocks routine initialized Pushlock support. + * + * @param None. + * + * @return None. + * + * @remarks The ExpInitializePushLocks routine sets up the spin on SMP machines. + * + *--*/ +VOID +NTAPI +ExpInitializePushLocks(VOID) +{ + /* Initialize an internal 1024-iteration spin for MP CPUs */ + ExPushLockSpinCount = (KeNumberProcessors == 1) ? 0 : 1024; +} + +/*++ + * @name ExfWakePushLock + * + * The ExfWakePushLock routine wakes a Pushlock that is in the waiting + * state. + * + * @param PushLock + * Pointer to a pushlock that is waiting. + * + * @param OldValue + * Last known value of the pushlock before this routine was called. + * + * @return None. + * + * @remarks This is an internal routine; do not call it manually. Only the system + * can properly know if the pushlock is ready to be awakened or not. + * External callers should use ExfTrytoWakePushLock. + * + *--*/ +VOID +FASTCALL +ExfWakePushLock(PEX_PUSH_LOCK PushLock, + EX_PUSH_LOCK OldValue) +{ + EX_PUSH_LOCK NewValue; + PEX_PUSH_LOCK_WAIT_BLOCK PreviousWaitBlock, FirstWaitBlock, NextWaitBlock; + PEX_PUSH_LOCK_WAIT_BLOCK WaitBlock; + KIRQL OldIrql; + + /* Start main wake loop */ + for (;;) + { + /* Sanity checks */ + ASSERT(!OldValue.MultipleShared); + + /* Check if it's locked */ + if (OldValue.Locked) + { + /* If it's locked we must simply un-wake it*/ + for (;;) + { + /* It's not waking anymore */ + NewValue.Value = OldValue.Value &~ EX_PUSH_LOCK_WAKING; + + /* Sanity checks */ + ASSERT(!NewValue.Waking); + ASSERT(NewValue.Locked); + ASSERT(NewValue.Waiting); + + /* Write the New Value */ + NewValue.Ptr = InterlockedCompareExchangePointer(PushLock, + NewValue.Ptr, + OldValue.Ptr); + if (NewValue.Value == OldValue.Value) return; + + /* Someone changed the value behind our back, update it*/ + OldValue = NewValue; + + /* Check if it's still locked */ + if (OldValue.Locked) continue; + } + } + + /* Save the First Block */ + FirstWaitBlock = (PEX_PUSH_LOCK_WAIT_BLOCK)((ULONG_PTR)OldValue.Ptr & + ~EX_PUSH_LOCK_PTR_BITS); + NextWaitBlock = FirstWaitBlock; + WaitBlock = NextWaitBlock->Last; + + /* Try to find a wait block */ + while (!WaitBlock) + { + /* Save the previous block */ + PreviousWaitBlock = NextWaitBlock; + + /* Move to next block */ + NextWaitBlock = NextWaitBlock->Next; + + /* Save the previous block */ + NextWaitBlock->Previous = PreviousWaitBlock; + + /* Move to the next one */ + WaitBlock = NextWaitBlock->Last; + } + + /* Check if the last Wait Block is not Exclusive or if it's the only one */ + PreviousWaitBlock = WaitBlock->Previous; + if (!(WaitBlock->Flags & EX_PUSH_LOCK_FLAGS_EXCLUSIVE) || + !(PreviousWaitBlock)) + { + /* Destroy the pushlock */ + if (InterlockedCompareExchangePointer(PushLock, 0, OldValue.Ptr) == + OldValue.Ptr) break; + } + else + { + /* Link the wait blocks */ + FirstWaitBlock->Last = PreviousWaitBlock; + WaitBlock->Previous = NULL; + + /* Sanity checks */ + ASSERT(FirstWaitBlock != WaitBlock); + ASSERT(PushLock->Waiting); + + /* Remove waking bit from pushlock */ + InterlockedAnd((PLONG)PushLock, ~EX_PUSH_LOCK_WAKING); + } + } + + /* Check if there's a previous block */ + OldIrql = DISPATCH_LEVEL; + if (WaitBlock->Previous) + { + /* Raise to Dispatch */ + KeRaiseIrql(DISPATCH_LEVEL, &OldIrql); + } + + /* Signaling loop */ + for (;;) + { + /* Get the previous Wait block */ + PreviousWaitBlock = WaitBlock->Previous; + + /* Sanity check */ + ASSERT(!WaitBlock->Signaled); + + /* We are about to get signaled */ + WaitBlock->Signaled = TRUE; + + /* Set the Wait Bit in the Wait Block */ + if (!InterlockedBitTestAndReset(&WaitBlock->Flags, 1)) + { + /* Nobody signaled us, so do it */ + KeSignalGateBoostPriority(&WaitBlock->WakeGate); + } + + /* Set the wait block and check if there still is one to loop*/ + WaitBlock = PreviousWaitBlock; + if (!WaitBlock) break; + } + + /* Check if we have to lower back the IRQL */ + if (OldIrql != DISPATCH_LEVEL) KeLowerIrql(OldIrql); +} + +/*++ + * @name ExpOptimizePushLockList + * + * The ExpOptimizePushLockList routine optimizes the list of waiters + * associated to a pushlock's wait block. + * + * @param PushLock + * Pointer to a pushlock whose waiter list needs to be optimized. + * + * @param OldValue + * Last known value of the pushlock before this routine was called. + * + * @return None. + * + * @remarks At the end of the optimization, the pushlock will also be wakened. + * + *--*/ +VOID +FASTCALL +ExpOptimizePushLockList(PEX_PUSH_LOCK PushLock, + EX_PUSH_LOCK OldValue) +{ + PEX_PUSH_LOCK_WAIT_BLOCK WaitBlock, LastWaitBlock, PreviousWaitBlock; + EX_PUSH_LOCK NewValue; + + /* Check if the pushlock is locked */ + if (OldValue.Locked) + { + /* Start main loop */ + for (;;) + { + /* Get the wait block */ + WaitBlock = (PEX_PUSH_LOCK_WAIT_BLOCK)((ULONG_PTR)OldValue.Ptr & + ~EX_PUSH_LOCK_PTR_BITS); + + /* Loop the blocks */ + LastWaitBlock = WaitBlock->Last; + while (LastWaitBlock) + { + /* Save the block */ + PreviousWaitBlock = WaitBlock; + + /* Get the next block */ + WaitBlock = WaitBlock->Next; + + /* Save the previous */ + WaitBlock->Previous = PreviousWaitBlock; + + /* Move to the next */ + LastWaitBlock = WaitBlock->Last; + } + + /* Remove the wake bit */ + NewValue.Value = OldValue.Value &~ EX_PUSH_LOCK_WAKING; + + /* Sanity checks */ + ASSERT(NewValue.Locked); + ASSERT(!NewValue.Waking); + + /* Update the value */ + NewValue.Ptr = InterlockedCompareExchangePointer(PushLock, + NewValue.Ptr, + OldValue.Ptr); + + /* If we updated correctly, leave */ + if (NewValue.Value == OldValue.Value) return; + + /* If the value is now locked, loop again */ + if (NewValue.Locked) continue; + } + } + + /* Wake the push lock */ + ExfWakePushLock(PushLock, OldValue); +} + +/*++ + * @name ExTimedWaitForUnblockPushLock + * + * The ExTimedWaitForUnblockPushLock routine waits for a pushlock + * to be unblocked, for a specified internal. + * + * @param PushLock + * Pointer to a pushlock whose waiter list needs to be optimized. + * + * @param WaitBlock + * Pointer to the pushlock's wait block. + * + * @param Timeout + * Amount of time to wait for this pushlock to be unblocked. + * + * @return STATUS_SUCCESS is the pushlock is now unblocked, otherwise the error + * code returned by KeWaitForSingleObject. + * + * @remarks If the wait fails, then a manual unblock is attempted. + * + *--*/ +NTSTATUS +FASTCALL +ExTimedWaitForUnblockPushLock(IN PEX_PUSH_LOCK PushLock, + IN PVOID WaitBlock, + IN PLARGE_INTEGER Timeout) +{ + ULONG i; + NTSTATUS Status; + + /* Initialize the wait event */ + KeInitializeEvent(&((PEX_PUSH_LOCK_WAIT_BLOCK)WaitBlock)->WakeEvent, + NotificationEvent, + FALSE); + + /* Spin on the push lock if necessary */ + i = ExPushLockSpinCount; + if (i) + { + /* Spin */ + while (--i) + { + /* Check if we got lucky and can leave early */ + if (!(((PEX_PUSH_LOCK_WAIT_BLOCK)WaitBlock)->Flags & + EX_PUSH_LOCK_WAITING)) + { + /* This wait block isn't waiting anymore, we can leave */ + return STATUS_SUCCESS; + } + YieldProcessor(); + } + } + + /* Now try to remove the wait bit */ + if (InterlockedBitTestAndReset(&((PEX_PUSH_LOCK_WAIT_BLOCK)WaitBlock)->Flag s, + 1)) + { + /* Nobody removed it already, let's do a full wait */ + Status = KeWaitForSingleObject(&((PEX_PUSH_LOCK_WAIT_BLOCK)WaitBlock)-> + WakeEvent, + WrPushLock, + KernelMode, + FALSE, + Timeout); + if (!NT_SUCCESS(Status)) + { + /* Try unblocking the pushlock */ + ExfUnblockPushLock(PushLock, WaitBlock); + } + } + else + { + /* Someone beat us to it, no need to wait */ + Status = STATUS_SUCCESS; + } + + /* Return status */ + return Status; +} + +/*++ + * @name ExBlockPushLock + * + * The ExBlockPushLock routine blocks a pushlock. + * + * @param PushLock + * Pointer to a pushlock whose waiter list needs to be optimized. + * + * @param WaitBlock + * Pointer to the pushlock's wait block. + * + * @return None. + * + * @remarks None. + * + *--*/ +VOID +FASTCALL +ExBlockPushLock(PEX_PUSH_LOCK PushLock, + PVOID WaitBlock) +{ + PVOID NewValue, OldValue; + + /* Set the waiting bit */ + ((PEX_PUSH_LOCK_WAIT_BLOCK)WaitBlock)->Flags |= EX_PUSH_LOCK_FLAGS_WAIT; + + /* Link the wait blocks */ + ((PEX_PUSH_LOCK_WAIT_BLOCK)WaitBlock)->Next = PushLock->Ptr; + + /* Try to set this one as the wait block now */ + NewValue = PushLock->Ptr; + for (;;) + { + /* Set the new wait block value */ + OldValue = InterlockedCompareExchangePointer(&PushLock->Ptr, + WaitBlock, + NewValue); + if (OldValue == NewValue) break; + NewValue = OldValue; + } +} + +/* PUBLIC FUNCTIONS **********************************************************/ + +/*++ + * @name ExAcquirePushLockExclusive + * @implemented NT5.1 + * + * The ExAcquirePushLockExclusive macro exclusively acquires a PushLock. + * + * @params PushLock + * Pointer to the pushlock which is to be acquired. + * + * @return None. + * + * @remarks Callers of ExAcquirePushLockShared must be running at IRQL <= APC_LEVEL. + * This macro should usually be paired up with KeAcquireCriticalRegion. + * + *--*/ +VOID +FASTCALL +ExfAcquirePushLockExclusive(PEX_PUSH_LOCK PushLock) +{ + EX_PUSH_LOCK_WAIT_BLOCK WaitBlock; + EX_PUSH_LOCK OldValue = *PushLock, NewValue, TempValue; + BOOLEAN NeedWake; + ULONG i; + + /* Start main loop */ + for (;;) + { + /* Check if it's unlocked */ + if (!OldValue.Locked) + { + /* Lock it */ + NewValue.Value = OldValue.Value | EX_PUSH_LOCK_LOCK; + ASSERT(NewValue.Locked); + + /* Set the new value */ + if (InterlockedCompareExchangePointer(PushLock, + NewValue.Ptr, + OldValue.Ptr) != OldValue.Ptr) + { + /* Retry */ + OldValue = *PushLock; + continue; + } + + /* Break out of the loop */ + break; + } + else + { + /* We'll have to create a Waitblock */ + WaitBlock.Flags = EX_PUSH_LOCK_FLAGS_EXCLUSIVE | + EX_PUSH_LOCK_FLAGS_WAIT; + WaitBlock.Previous = NULL; + NeedWake = FALSE; + + /* Check if there is already a waiter */ + if (OldValue.Waiting) + { + /* Nobody is the last waiter yet */ + WaitBlock.Last = NULL; + + /* We are an exclusive waiter */ + WaitBlock.ShareCount = 0; + + /* Set the current Wait Block pointer */ + WaitBlock.Next = (PEX_PUSH_LOCK_WAIT_BLOCK)((ULONG_PTR) + OldValue.Ptr &~ EX_PUSH_LOCK_PTR_BITS); + + /* Point to ours */ + NewValue.Value = (OldValue.Value & EX_PUSH_LOCK_MULTIPLE_SHARED) | + EX_PUSH_LOCK_LOCK | + EX_PUSH_LOCK_WAKING | + EX_PUSH_LOCK_WAITING | + PtrToUlong(&WaitBlock); + + /* Check if the pushlock was already waking */ + if (OldValue.Waking) NeedWake = TRUE; + } + else + { + /* We are the first waiter, so loop the wait block */ + WaitBlock.Last = &WaitBlock; + + /* Set the share count */ + WaitBlock.ShareCount = OldValue.Shared; + + /* Check if someone is sharing this pushlock */ + if (OldValue.Shared > 1) + { + /* Point to our wait block */ + NewValue.Value = EX_PUSH_LOCK_MULTIPLE_SHARED | + EX_PUSH_LOCK_LOCK | + EX_PUSH_LOCK_WAITING | + PtrToUlong(&WaitBlock); + } + else + { + /* No shared count */ + WaitBlock.ShareCount = 0; + + /* Point to our wait block */ + NewValue.Value = EX_PUSH_LOCK_LOCK | + EX_PUSH_LOCK_WAITING | + PtrToUlong(&WaitBlock); + } + } + +#if DBG + /* Setup the Debug Wait Block */ + WaitBlock.Signaled = 0; + WaitBlock.OldValue = OldValue; + WaitBlock.NewValue = NewValue; + WaitBlock.PushLock = PushLock; +#endif + + /* Sanity check */ + ASSERT(NewValue.Waiting); + ASSERT(NewValue.Locked); + + /* Write the new value */ + TempValue = NewValue; + NewValue.Ptr = InterlockedCompareExchangePointer(PushLock, + NewValue.Ptr, + OldValue.Ptr); + if (NewValue.Value != OldValue.Value) + { + /* Retry */ + OldValue = *PushLock; + continue; + } + + /* Check if the pushlock needed waking */ + if (NeedWake) + { + /* Scan the Waiters and Wake PushLocks */ + ExpOptimizePushLockList(PushLock, TempValue); + } + + /* Set up the Wait Gate */ + KeInitializeGate(&WaitBlock.WakeGate); + + /* Now spin on the push lock if necessary */ + i = ExPushLockSpinCount; + if ((i) && (WaitBlock.Flags & EX_PUSH_LOCK_WAITING)) + { + /* Spin */ + while (--i) YieldProcessor(); + } + + /* Now try to remove the wait bit */ + if (InterlockedBitTestAndReset(&WaitBlock.Flags, 1)) + { + /* Nobody removed it already, let's do a full wait */ + KeWaitForGate(&WaitBlock.WakeGate, WrPushLock, KernelMode); + ASSERT(WaitBlock.Signaled); + } + + /* We shouldn't be shared anymore */ + ASSERT((WaitBlock.ShareCount == 0)); + + /* Loop again */ + OldValue = NewValue; + } + } +} + +/*++ + * @name ExAcquirePushLockExclusive + * @implemented NT5.1 + * + * The ExAcquirePushLockShared macro acquires a shared PushLock. + * + * @params PushLock + * Pointer to the pushlock which is to be acquired. + * + * @return None. + * + * @remarks Callers of ExAcquirePushLockShared must be running at IRQL <= APC_LEVEL. + * This macro should usually be paired up with KeAcquireCriticalRegion. + * + *--*/ +VOID +FASTCALL +ExfAcquirePushLockShared(PEX_PUSH_LOCK PushLock) +{ + EX_PUSH_LOCK_WAIT_BLOCK WaitBlock; + EX_PUSH_LOCK OldValue = *PushLock, NewValue; + BOOLEAN NeedWake; + ULONG i; + + /* Start main loop */ + for (;;) + { + /* Check if it's unlocked or if it's waiting without any sharers */ + if (!(OldValue.Locked) || (OldValue.Waiting && OldValue.Shared == 0)) + { + /* Check if anyone is waiting on it */ + if (!OldValue.Waiting) + { + /* Increase the share count and lock it */ + NewValue.Value = OldValue.Value | EX_PUSH_LOCK_LOCK; + NewValue.Shared++; + } + else + { + /* Simply set the lock bit */ + NewValue.Value = OldValue.Value | EX_PUSH_LOCK_LOCK; + } + + /* Sanity check */ + ASSERT(NewValue.Locked); + + /* Set the new value */ + NewValue.Ptr = InterlockedCompareExchangePointer(PushLock, + NewValue.Ptr, + OldValue.Ptr); + if (NewValue.Value != OldValue.Value) + { + /* Retry */ + OldValue = NewValue; + continue; + } + + /* Break out of the loop */ + break; + } + else + { + /* We'll have to create a Waitblock */ + WaitBlock.Flags = EX_PUSH_LOCK_FLAGS_WAIT; + WaitBlock.ShareCount = 0; + NeedWake = FALSE; + WaitBlock.Previous = NULL; + + /* Check if there is already a waiter */ + if (OldValue.Waiting) + { + /* Set the current Wait Block pointer */ + WaitBlock.Next = (PEX_PUSH_LOCK_WAIT_BLOCK)((ULONG_PTR) + OldValue.Ptr &~ EX_PUSH_LOCK_PTR_BITS); + + /* Nobody is the last waiter yet */ + WaitBlock.Last = NULL; + + /* Point to ours */ + NewValue.Value = (OldValue.Value & (EX_PUSH_LOCK_MULTIPLE_SHARED | + EX_PUSH_LOCK_LOCK)) | + EX_PUSH_LOCK_WAKING | + EX_PUSH_LOCK_WAITING | + PtrToUlong(&WaitBlock); + + /* Check if the pushlock was already waking */ + if (OldValue.Waking) NeedWake = TRUE; + } + else + { + /* We are the first waiter, so loop the wait block */ + WaitBlock.Last = &WaitBlock; + + /* Point to our wait block */ + NewValue.Value = (OldValue.Value & (EX_PUSH_LOCK_MULTIPLE_SHARED | + EX_PUSH_LOCK_WAKING)) | + EX_PUSH_LOCK_WAITING | + PtrToUlong(&WaitBlock); + } + + /* Sanity check */ + ASSERT(NewValue.Waiting); + +#if DBG + /* Setup the Debug Wait Block */ + WaitBlock.Signaled = 0; + WaitBlock.OldValue = OldValue; + WaitBlock.NewValue = NewValue; + WaitBlock.PushLock = PushLock; +#endif + + /* Write the new value */ + if (InterlockedCompareExchangePointer(PushLock, + NewValue.Ptr, + OldValue.Ptr) != OldValue.Ptr) + { + /* Retry */ + OldValue = NewValue; + continue; + } + + /* Update the value now */ + OldValue = NewValue; + + /* Check if the pushlock needed waking */ + if (NeedWake) + { + /* Scan the Waiters and Wake PushLocks */ + ExpOptimizePushLockList(PushLock, OldValue); + } + + /* Set up the Wait Gate */ + KeInitializeGate(&WaitBlock.WakeGate); + + /* Now spin on the push lock if necessary */ + i = ExPushLockSpinCount; + if ((i) && (WaitBlock.Flags & EX_PUSH_LOCK_WAITING)) + { + /* Spin */ + while (--i) YieldProcessor(); + } + + /* Now try to remove the wait bit */ + if (InterlockedBitTestAndReset(&WaitBlock.Flags, 1)) + { + /* Fast-path did not work, we need to do a full wait */ + KeWaitForGate(&WaitBlock.WakeGate, WrPushLock, KernelMode); + ASSERT(WaitBlock.Signaled); + } + + /* We shouldn't be shared anymore */ + ASSERT((WaitBlock.ShareCount == 0)); + } + } +} + +/*++ + * @name ExfReleasePushLock + * @implemented NT5.1 + * + * The ExReleasePushLockExclusive routine releases a previously + * exclusively acquired PushLock. + * + * @params PushLock + * Pointer to a previously acquired pushlock. + * + * @return None. + * + * @remarks Callers of ExReleasePushLockExclusive must be running at IRQL <= APC_LEVEL. + * This macro should usually be paired up with KeLeaveCriticalRegion. + * + *--*/ +VOID +FASTCALL +ExfReleasePushLock(PEX_PUSH_LOCK PushLock) +{ + EX_PUSH_LOCK OldValue = *PushLock; + EX_PUSH_LOCK NewValue; + PEX_PUSH_LOCK_WAIT_BLOCK WaitBlock; + + /* Sanity check */ + ASSERT(OldValue.Locked); + + /* Check if someone is waiting on the lock */ + if (!OldValue.Waiting) + { + /* Nobody is waiting on it, so we'll try a quick release */ + for (;;) + { + /* Check if it's shared */ + if (OldValue.Shared > 1) + { + /* Write the Old Value but decrease share count */ + NewValue = OldValue; + NewValue.Shared--; + } + else + { + /* Simply clear the lock */ + NewValue.Value = 0; + } + + /* Write the New Value */ + NewValue.Ptr = InterlockedCompareExchangePointer(PushLock, + NewValue.Ptr, + OldValue.Ptr); + if (NewValue.Value == OldValue.Value) + { + /* No waiters left, we're done */ + goto quit; + } + + /* Did it enter a wait state? */ + OldValue = NewValue; + if (NewValue.Waiting) break; + } + } + + /* Ok, we do know someone is waiting on it. Are there more then one? */ + if (OldValue.MultipleShared) + { + /* Find the last Wait Block */ + for (WaitBlock = (PEX_PUSH_LOCK_WAIT_BLOCK)((ULONG_PTR)OldValue.Ptr & + ~EX_PUSH_LOCK_PTR_BITS); + WaitBlock->Last; + WaitBlock = WaitBlock->Next); + + /* Make sure the Share Count is above 0 */ + if (WaitBlock->ShareCount) + { + /* This shouldn't be an exclusive wait block */ + ASSERT(WaitBlock->Flags&EX_PUSH_LOCK_FLAGS_EXCLUSIVE); + + /* Do the decrease and check if the lock isn't shared anymore */ + if (InterlockedExchangeAdd(&WaitBlock->ShareCount, -1)) + { + /* Someone is still holding the lock */ + goto quit; + } + } + } + + /* + * If nobody was waiting on the block, then we possibly reduced the number + * of times the pushlock was shared, and we unlocked it. + * If someone was waiting, and more then one person is waiting, then we + * reduced the number of times the pushlock is shared in the wait block. + * Therefore, at this point, we can now 'satisfy' the wait. + */ + for (;;) + { + /* Now we need to see if it's waking */ + if (OldValue.Waking) + { + /* Remove the lock and multiple shared bits */ + NewValue.Value = OldValue.Value; + NewValue.MultipleShared = FALSE; + NewValue.Locked = FALSE; + + /* Sanity check */ + ASSERT(NewValue.Waking && !NewValue.Locked && !NewValue.MultipleShared); + + /* Write the new value */ + NewValue.Ptr = InterlockedCompareExchangePointer(PushLock, + NewValue.Ptr, + OldValue.Ptr); + if (NewValue.Value == OldValue.Value) break; + + /* The value changed, try the unlock again */ + continue; + } + else + { + /* Remove the lock and multiple shared bits */ + NewValue.Value = OldValue.Value; + NewValue.MultipleShared = FALSE; + NewValue.Locked = FALSE; + + /* It's not already waking, so add the wake bit */ + NewValue.Waking = TRUE; + + /* Sanity check */ + ASSERT(NewValue.Waking && !NewValue.Locked && !NewValue.MultipleShared); + + /* Write the new value */ + NewValue.Ptr = InterlockedCompareExchangePointer(PushLock, + NewValue.Ptr, + OldValue.Ptr); + if (NewValue.Value != OldValue.Value) continue; + + /* The write was successful. The pushlock is Unlocked and Waking */ + ExfWakePushLock(PushLock, NewValue); + break; + } + } +quit: + /* Done! */ + return; +} + +/*++ + * @name ExfReleasePushLockShared + * @implemented NT5.2 + * + * The ExfReleasePushLockShared macro releases a previously acquired PushLock. + * + * @params PushLock + * Pointer to a previously acquired pushlock. + * + * @return None. + * + * @remarks Callers of ExReleasePushLockShared must be running at IRQL <= APC_LEVEL. + * This macro should usually be paired up with KeLeaveCriticalRegion. + * + *--*/ +VOID +FASTCALL +ExfReleasePushLockShared(PEX_PUSH_LOCK PushLock) +{ + EX_PUSH_LOCK OldValue = *PushLock; + EX_PUSH_LOCK NewValue; + PEX_PUSH_LOCK_WAIT_BLOCK WaitBlock; + + /* Check if someone is waiting on the lock */ + if (!OldValue.Waiting) + { + /* Nobody is waiting on it, so we'll try a quick release */ + for (;;) + { + /* Check if it's shared */ + if (OldValue.Shared > 1) + { + /* Write the Old Value but decrease share count */ + NewValue = OldValue; + NewValue.Shared--; + } + else + { + /* Simply clear the lock */ + NewValue.Value = 0; + } + + /* Write the New Value */ + NewValue.Ptr = InterlockedCompareExchangePointer(PushLock, + NewValue.Ptr, + OldValue.Ptr); + if (NewValue.Value == OldValue.Value) + { + /* No waiters left, we're done */ + goto quit; + } + + /* Did it enter a wait state? */ + OldValue = NewValue; + if (NewValue.Waiting) break; + } + } + + /* Ok, we do know someone is waiting on it. Are there more then one? */ + if (OldValue.MultipleShared) + { + /* Find the last Wait Block */ + for (WaitBlock = (PEX_PUSH_LOCK_WAIT_BLOCK)((ULONG_PTR)OldValue.Ptr & + ~EX_PUSH_LOCK_PTR_BITS); + WaitBlock->Last; + WaitBlock = WaitBlock->Next); + + /* Sanity checks */ + ASSERT(WaitBlock->ShareCount > 0); + ASSERT(WaitBlock->Flags&EX_PUSH_LOCK_FLAGS_EXCLUSIVE); + + /* Do the decrease and check if the lock isn't shared anymore */ + if (InterlockedExchangeAdd(&WaitBlock->ShareCount, -1)) goto quit; + } + + /* + * If nobody was waiting on the block, then we possibly reduced the number + * of times the pushlock was shared, and we unlocked it. + * If someone was waiting, and more then one person is waiting, then we + * reduced the number of times the pushlock is shared in the wait block. + * Therefore, at this point, we can now 'satisfy' the wait. + */ + for (;;) + { + /* Now we need to see if it's waking */ + if (OldValue.Waking) + { + /* Remove the lock and multiple shared bits */ + NewValue.Value = OldValue.Value; + NewValue.MultipleShared = FALSE; + NewValue.Locked = FALSE; + + /* Sanity check */ + ASSERT(NewValue.Waking && !NewValue.Locked && !NewValue.MultipleShared); + + /* Write the new value */ + NewValue.Ptr = InterlockedCompareExchangePointer(PushLock, + NewValue.Ptr, + OldValue.Ptr); + if (NewValue.Value == OldValue.Value) break; + + /* The value changed, try the unlock again */ + continue; + } + else + { + /* Remove the lock and multiple shared bits */ + NewValue.Value = OldValue.Value; + NewValue.MultipleShared = FALSE; + NewValue.Locked = FALSE; + + /* It's not already waking, so add the wake bit */ + NewValue.Waking = TRUE; + + /* Sanity check */ + ASSERT(NewValue.Waking && !NewValue.Locked && !NewValue.MultipleShared); + + /* Write the new value */ + NewValue.Ptr = InterlockedCompareExchangePointer(PushLock, + NewValue.Ptr, + OldValue.Ptr); + if (NewValue.Value != OldValue.Value) continue; + + /* The write was successful. The pushlock is Unlocked and Waking */ + ExfWakePushLock(PushLock, NewValue); + break; + } + } +quit: + /* Done! */ + return; +} + +/*++ + * ExfReleasePushLockExclusive + * @implemented NT5.2 + * + * The ExfReleasePushLockExclusive routine releases a previously + * exclusively acquired PushLock. + * + * @params PushLock + * Pointer to a previously acquired pushlock. + * + * @return None. [truncated at 1000 lines; 463 more skipped]

18 years, 10 months

[ion] 20556: - More proper fix for the QEMU/Abiword regression. Remove kernel32 hack. Thanks to Filip and The Munger.

by ion＠svn.reactos.org

- More proper fix for the QEMU/Abiword regression. Remove kernel32 hack. Thanks to Filip and The Munger. Modified: trunk/reactos/lib/kernel32/misc/atom.c Modified: trunk/reactos/lib/ntdll/ldr/startup.c _____ Modified: trunk/reactos/lib/kernel32/misc/atom.c --- trunk/reactos/lib/kernel32/misc/atom.c 2006-01-03 22:25:09 UTC (rev 20555) +++ trunk/reactos/lib/kernel32/misc/atom.c 2006-01-03 22:36:36 UTC (rev 20556) @@ -72,7 +72,6 @@ /* Check if we can abuse the TEB */ if (AnsiString.MaximumLength > 260) { -RosHack: /* We can't, allocate a new string */ AtomNameString = &UnicodeString; Status = RtlAnsiStringToUnicodeString(AtomNameString, @@ -84,14 +83,6 @@ /* We can! Get the TEB String */ AtomNameString = &NtCurrentTeb()->StaticUnicodeString; - /* FIXME: HACK! */ - if (!AtomNameString->MaximumLength) - { - DPRINT1("Hit the ROS TEB Static Unicode String Bug\n", - "Please try to fix the underlying problem!!!\n"); - goto RosHack; - } - /* Convert it into the TEB */ Status = RtlAnsiStringToUnicodeString(AtomNameString, &AnsiString, @@ -182,7 +173,6 @@ /* Check if we can abuse the TEB */ if (AnsiString.MaximumLength > 260) { -RosHack: /* We can't, allocate a new string */ AtomNameString = &UnicodeString; Status = RtlAnsiStringToUnicodeString(AtomNameString, @@ -194,14 +184,6 @@ /* We can! Get the TEB String */ AtomNameString = &NtCurrentTeb()->StaticUnicodeString; - /* FIXME: HACK! */ - if (!AtomNameString->MaximumLength) - { - DPRINT1("Hit the ROS TEB Static Unicode String Bug\n", - "Please try to fix the underlying problem!!!\n"); - goto RosHack; - } - /* Convert it into the TEB */ Status = RtlAnsiStringToUnicodeString(AtomNameString, &AnsiString, _____ Modified: trunk/reactos/lib/ntdll/ldr/startup.c --- trunk/reactos/lib/ntdll/ldr/startup.c 2006-01-03 22:25:09 UTC (rev 20555) +++ trunk/reactos/lib/ntdll/ldr/startup.c 2006-01-03 22:36:36 UTC (rev 20556) @@ -377,6 +377,11 @@ /* Load execution options */ LoadImageFileExecutionOptions(Peb); + /* Initialize the static teb string */ + NtCurrentTeb()->StaticUnicodeString.Length = 0; + NtCurrentTeb()->StaticUnicodeString.MaximumLength = sizeof(NtCurrentTeb()->StaticUnicodeBuffer); + NtCurrentTeb()->StaticUnicodeString.Buffer = NtCurrentTeb()->StaticUnicodeBuffer; + /* build full ntdll path */ wcscpy (FullNtDllPath, SharedUserData->NtSystemRoot); wcscat (FullNtDllPath, L"\\system32\\ntdll.dll");

18 years, 10 months

[ion] 20555: - Dirty temporary fix to unregress abiword/qemu.

by ion＠svn.reactos.org

- Dirty temporary fix to unregress abiword/qemu. Modified: trunk/reactos/lib/kernel32/misc/atom.c _____ Modified: trunk/reactos/lib/kernel32/misc/atom.c --- trunk/reactos/lib/kernel32/misc/atom.c 2006-01-03 21:34:19 UTC (rev 20554) +++ trunk/reactos/lib/kernel32/misc/atom.c 2006-01-03 22:25:09 UTC (rev 20555) @@ -72,6 +72,7 @@ /* Check if we can abuse the TEB */ if (AnsiString.MaximumLength > 260) { +RosHack: /* We can't, allocate a new string */ AtomNameString = &UnicodeString; Status = RtlAnsiStringToUnicodeString(AtomNameString, @@ -80,8 +81,18 @@ } else { - /* We can! Use the TEB */ + /* We can! Get the TEB String */ AtomNameString = &NtCurrentTeb()->StaticUnicodeString; + + /* FIXME: HACK! */ + if (!AtomNameString->MaximumLength) + { + DPRINT1("Hit the ROS TEB Static Unicode String Bug\n", + "Please try to fix the underlying problem!!!\n"); + goto RosHack; + } + + /* Convert it into the TEB */ Status = RtlAnsiStringToUnicodeString(AtomNameString, &AnsiString, FALSE); @@ -171,6 +182,7 @@ /* Check if we can abuse the TEB */ if (AnsiString.MaximumLength > 260) { +RosHack: /* We can't, allocate a new string */ AtomNameString = &UnicodeString; Status = RtlAnsiStringToUnicodeString(AtomNameString, @@ -179,8 +191,18 @@ } else { - /* We can! Use the TEB */ + /* We can! Get the TEB String */ AtomNameString = &NtCurrentTeb()->StaticUnicodeString; + + /* FIXME: HACK! */ + if (!AtomNameString->MaximumLength) + { + DPRINT1("Hit the ROS TEB Static Unicode String Bug\n", + "Please try to fix the underlying problem!!!\n"); + goto RosHack; + } + + /* Convert it into the TEB */ Status = RtlAnsiStringToUnicodeString(AtomNameString, &AnsiString, FALSE);

18 years, 10 months

[ion] 20554: - Fix shamefully dangerously broken Work Thread/Queue/Item implementation:

by ion＠svn.reactos.org

- Fix shamefully dangerously broken Work Thread/Queue/Item implementation: * Do not pollute the kernel with 10 real-time threads and 5 high-priority threads in order to manage work items. Work threads are very-low priority (< 7) and should never pre-empt userthreads like they do now. 1 priority 7, 5 priority 5 and 3 priority 4 threads are now properly created. * Implement a worker thread balance set manager. On SMP systems, it is able to determine when a new thread should be allocate to execute on a free CPU. On both UP and MP, it is also able to detect if a work queue has deadlocked, and will allocate new dynamic threads to unfreeze the queue. * Add check for threads returning with APC disabled, and re-enable APCs if this happend. This hack is used in NT for broken drivers. * Lots of code changes to support dynamic threads, which: - Can terminate. - Use a 10 minute timeout on the kernel queue. * Add skeleton code for swapping worker thread stacks as well as worker thread shutdown (not yet implemented). * Add WORKER_INVALID bugcheck definition. * These changes seem to make ROS a lot more responsive. - NDK: * Make more compatible with MS IFS * Fix EX_WORK_QUEUE definition. * Fix ETHREAD offsets. * Fix RtlIsNameLegalDOS8Dot3 definition. * Move splay tree defines to IFS. Modified: trunk/reactos/include/ndk/exfuncs.h Modified: trunk/reactos/include/ndk/extypes.h Modified: trunk/reactos/include/ndk/ifssupp.h Modified: trunk/reactos/include/ndk/iofuncs.h Modified: trunk/reactos/include/ndk/obfuncs.h Modified: trunk/reactos/include/ndk/pstypes.h Modified: trunk/reactos/include/ndk/rtlfuncs.h Modified: trunk/reactos/include/ndk/rtltypes.h Modified: trunk/reactos/lib/rtl/dos8dot3.c Modified: trunk/reactos/ntoskrnl/ex/work.c Modified: trunk/reactos/ntoskrnl/ntoskrnl.mc Modified: trunk/reactos/w32api/include/ddk/ntifs.h _____ Modified: trunk/reactos/include/ndk/exfuncs.h --- trunk/reactos/include/ndk/exfuncs.h 2006-01-03 21:29:39 UTC (rev 20553) +++ trunk/reactos/include/ndk/exfuncs.h 2006-01-03 21:34:19 UTC (rev 20554) @@ -485,6 +485,7 @@ IN HANDLE EventHandle ); +NTSYSAPI NTSTATUS NTAPI ZwCreateEvent( @@ -741,6 +742,7 @@ IN HANDLE PortHandle ); +NTSYSAPI NTSTATUS NTAPI ZwSetEvent( _____ Modified: trunk/reactos/include/ndk/extypes.h --- trunk/reactos/include/ndk/extypes.h 2006-01-03 21:29:39 UTC (rev 20553) +++ trunk/reactos/include/ndk/extypes.h 2006-01-03 21:34:19 UTC (rev 20554) @@ -273,7 +273,7 @@ typedef struct _EX_WORK_QUEUE { KQUEUE WorkerQueue; - ULONG DynamicThreadCount; + LONG DynamicThreadCount; ULONG WorkItemsProcessed; ULONG WorkItemsProcessedLastPass; ULONG QueueDepthLastPass; @@ -318,6 +318,8 @@ // // Executive Pushlock // +#undef EX_PUSH_LOCK +#undef PEX_PUSH_LOCK typedef struct _EX_PUSH_LOCK { union _____ Modified: trunk/reactos/include/ndk/ifssupp.h --- trunk/reactos/include/ndk/ifssupp.h 2006-01-03 21:29:39 UTC (rev 20553) +++ trunk/reactos/include/ndk/ifssupp.h 2006-01-03 21:34:19 UTC (rev 20554) @@ -117,6 +117,13 @@ LIST_ENTRY ThreadListHead; } KQUEUE, *PKQUEUE, *RESTRICTED_POINTER PRKQUEUE; +typedef struct _ACE_HEADER +{ + UCHAR AceType; + UCHAR AceFlags; + USHORT AceSize; +} ACE_HEADER, *PACE_HEADER; + typedef enum _RTL_GENERIC_COMPARE_RESULTS { GenericLessThan, _____ Modified: trunk/reactos/include/ndk/iofuncs.h --- trunk/reactos/include/ndk/iofuncs.h 2006-01-03 21:29:39 UTC (rev 20553) +++ trunk/reactos/include/ndk/iofuncs.h 2006-01-03 21:34:19 UTC (rev 20554) @@ -562,6 +562,7 @@ IN PUNICODE_STRING EntryValue ); +NTSYSAPI NTSTATUS NTAPI ZwDeleteFile( @@ -591,6 +592,7 @@ IN ULONG Unknown2 ); +NTSYSAPI NTSTATUS NTAPI ZwFlushBuffersFile( _____ Modified: trunk/reactos/include/ndk/obfuncs.h --- trunk/reactos/include/ndk/obfuncs.h 2006-01-03 21:29:39 UTC (rev 20553) +++ trunk/reactos/include/ndk/obfuncs.h 2006-01-03 21:34:19 UTC (rev 20554) @@ -296,6 +296,7 @@ IN BOOLEAN GenerateOnClose ); +NTSYSAPI NTSTATUS NTAPI ZwDuplicateObject( @@ -321,6 +322,7 @@ IN HANDLE Handle ); +NTSYSAPI NTSTATUS NTAPI ZwOpenDirectoryObject( @@ -425,6 +427,7 @@ IN PLARGE_INTEGER Time ); +NTSYSAPI NTSTATUS NTAPI ZwWaitForSingleObject( _____ Modified: trunk/reactos/include/ndk/pstypes.h --- trunk/reactos/include/ndk/pstypes.h 2006-01-03 21:29:39 UTC (rev 20553) +++ trunk/reactos/include/ndk/pstypes.h 2006-01-03 21:34:19 UTC (rev 20554) @@ -600,7 +600,8 @@ #include <pshpack4.h> typedef struct _ETHREAD { - KTHREAD Tcb; /* 1B8 */ + KTHREAD Tcb; /* 000 */ + PVOID Padding; /* 1B4 */ LARGE_INTEGER CreateTime; /* 1B8 */ union { _____ Modified: trunk/reactos/include/ndk/rtlfuncs.h --- trunk/reactos/include/ndk/rtlfuncs.h 2006-01-03 21:29:39 UTC (rev 20553) +++ trunk/reactos/include/ndk/rtlfuncs.h 2006-01-03 21:34:19 UTC (rev 20554) @@ -157,8 +157,6 @@ #define RtlEqualLuid(L1, L2) (((L1)->HighPart == (L2)->HighPart) && \ ((L1)->LowPart == (L2)->LowPart)) -#endif - // // RTL Splay Tree Functions // @@ -246,6 +244,7 @@ _SplayParent->RightChild = _SplayChild; \ _SplayChild->Parent = _SplayParent; \ } +#endif // // Error and Exception Functions @@ -1694,9 +1693,9 @@ BOOLEAN NTAPI RtlIsNameLegalDOS8Dot3( - IN PUNICODE_STRING UnicodeName, - IN PANSI_STRING AnsiName, - PBOOLEAN Unknown + IN PCUNICODE_STRING Name, + IN OUT POEM_STRING OemName OPTIONAL, + IN OUT PBOOLEAN NameContainsSpaces OPTIONAL ); NTSYSAPI _____ Modified: trunk/reactos/include/ndk/rtltypes.h --- trunk/reactos/include/ndk/rtltypes.h 2006-01-03 21:29:39 UTC (rev 20553) +++ trunk/reactos/include/ndk/rtltypes.h 2006-01-03 21:34:19 UTC (rev 20554) @@ -538,16 +538,6 @@ CSHORT Weekday; } TIME_FIELDS, *PTIME_FIELDS; -#else -// -// ACE Definitions -// -typedef struct _ACE_HEADER -{ - UCHAR AceType; - UCHAR AceFlags; - USHORT AceSize; -} ACE_HEADER, *PACE_HEADER; #endif typedef struct _ACE { _____ Modified: trunk/reactos/lib/rtl/dos8dot3.c --- trunk/reactos/lib/rtl/dos8dot3.c 2006-01-03 21:29:39 UTC (rev 20553) +++ trunk/reactos/lib/rtl/dos8dot3.c 2006-01-03 21:34:19 UTC (rev 20554) @@ -232,10 +232,11 @@ /* * @implemented */ -BOOLEAN NTAPI -RtlIsNameLegalDOS8Dot3(IN PUNICODE_STRING UnicodeName, - IN PANSI_STRING AnsiName, - OUT PBOOLEAN SpacesFound) +BOOLEAN +NTAPI +RtlIsNameLegalDOS8Dot3(IN PCUNICODE_STRING UnicodeName, + IN OUT POEM_STRING AnsiName OPTIONAL, + IN OUT PBOOLEAN SpacesFound OPTIONAL) { PANSI_STRING name = AnsiName; ANSI_STRING DummyString; _____ Modified: trunk/reactos/ntoskrnl/ex/work.c --- trunk/reactos/ntoskrnl/ex/work.c 2006-01-03 21:29:39 UTC (rev 20553) +++ trunk/reactos/ntoskrnl/ex/work.c 2006-01-03 21:34:19 UTC (rev 20554) @@ -1,11 +1,9 @@ /* * COPYRIGHT: See COPYING in the top level directory - * PROJECT: ReactOS kernel + * PROJECT: ReactOS Kernel * FILE: ntoskrnl/ex/work.c - * PURPOSE: Manage system work queues - * - * PROGRAMMERS: Alex Ionescu - Used correct work queue array and added some fixes and checks. - * Gunnar Dalsnes - Implemented + * PURPOSE: Manage system work queues and worker threads + * PROGRAMMER: Alex Ionescu (alex(a)relsoft.net) */ /* INCLUDES ******************************************************************/ @@ -18,70 +16,167 @@ #pragma alloc_text(INIT, ExpInitializeWorkerThreads) #endif -/* DEFINES *******************************************************************/ +/* DATA **********************************************************************/ -#define NUMBER_OF_WORKER_THREADS (5) +/* Number of worker threads for each Queue */ +#define EX_HYPERCRITICAL_WORK_THREADS 1 +#define EX_DELAYED_WORK_THREADS 3 +#define EX_CRITICAL_WORK_THREADS 5 -/* TYPES *********************************************************************/ +/* Magic flag for dynamic worker threads */ +#define EX_DYNAMIC_WORK_THREAD 0x80000000 -/* GLOBALS *******************************************************************/ +/* Worker thread priorities */ +#define EX_HYPERCRITICAL_QUEUE_PRIORITY 7 +#define EX_CRITICAL_QUEUE_PRIORITY 5 +#define EX_DELAYED_QUEUE_PRIORITY 4 -/* - * PURPOSE: Queue of items waiting to be processed at normal priority - */ +/* The actual worker queue array */ EX_WORK_QUEUE ExWorkerQueue[MaximumWorkQueue]; -/* FUNCTIONS ****************************************************************/ +/* Accounting of the total threads and registry hacked threads */ +ULONG ExpCriticalWorkerThreads; +ULONG ExpDelayedWorkerThreads; +ULONG ExpAdditionalCriticalWorkerThreads; +ULONG ExpAdditionalDelayedWorkerThreads; -/* - * FUNCTION: Entry point for a worker thread - * ARGUMENTS: - * context = Parameters - * RETURNS: Status - * NOTE: To kill a worker thread you must queue an item whose callback - * calls PsTerminateSystemThread - */ -static +/* Future support for stack swapping worker threads */ +BOOLEAN ExpWorkersCanSwap; +LIST_ENTRY ExpWorkerListHead; +KMUTANT ExpWorkerSwapinMutex; + +/* The worker balance set manager events */ +KEVENT ExpThreadSetManagerEvent; +KEVENT ExpThreadSetManagerShutdownEvent; + +/* Thread pointers for future worker thread shutdown support */ +PETHREAD ExpWorkerThreadBalanceManagerPtr; +PETHREAD ExpLastWorkerThread; + +/* PRIVATE FUNCTIONS *********************************************************/ + +/*++ + * @name ExpWorkerThreadEntryPoint + * + * The ExpWorkerThreadEntryPoint routine is the entrypoint for any new + * worker thread created by teh system. + * + * @param Context + * Contains the work queue type masked with a flag specifing whether the + * thread is dynamic or not. + * + * @return None. + * + * @remarks A dynamic thread can timeout after 10 minutes of waiting on a queue + * while a static thread will never timeout. + * + * Worker threads must return at IRQL == PASSIVE_LEVEL, must not have + * active impersonation info, and must not have disabled APCs. + * + * NB: We will re-enable APCs for broken threads but all other cases + * will generate a bugcheck. + * + *--*/ VOID -STDCALL +NTAPI ExpWorkerThreadEntryPoint(IN PVOID Context) { PWORK_QUEUE_ITEM WorkItem; PLIST_ENTRY QueueEntry; WORK_QUEUE_TYPE WorkQueueType; PEX_WORK_QUEUE WorkQueue; + LARGE_INTEGER Timeout; + PLARGE_INTEGER TimeoutPointer = NULL; + PETHREAD Thread = PsGetCurrentThread(); + KPROCESSOR_MODE WaitMode; + EX_QUEUE_WORKER_INFO OldValue, NewValue; + /* Check if this is a dyamic thread */ + if ((ULONG_PTR)Context & EX_DYNAMIC_WORK_THREAD) + { + /* It is, which means we will eventually time out after 10 minutes */ + Timeout.QuadPart = Int32x32To64(10, -10000000 * 60); + TimeoutPointer = &Timeout; + } + /* Get Queue Type and Worker Queue */ - WorkQueueType = (WORK_QUEUE_TYPE)Context; + WorkQueueType = (WORK_QUEUE_TYPE)((ULONG_PTR)Context & + ~EX_DYNAMIC_WORK_THREAD); WorkQueue = &ExWorkerQueue[WorkQueueType]; + /* Select the wait mode */ + WaitMode = (UCHAR)WorkQueue->Info.WaitMode; + + /* Nobody should have initialized this yet, do it now */ + ASSERT(Thread->ExWorkerCanWaitUser == 0); + if (WaitMode == UserMode) Thread->ExWorkerCanWaitUser = TRUE; + + /* If we shouldn't swap, disable that feature */ + if (!ExpWorkersCanSwap) KeSetKernelStackSwapEnable(FALSE); + + /* Set the worker flags */ + do + { + /* Check if the queue is being disabled */ + if (WorkQueue->Info.QueueDisabled) + { + /* Re-enable stack swapping and kill us */ + KeSetKernelStackSwapEnable(TRUE); + PsTerminateSystemThread(STATUS_SYSTEM_SHUTDOWN); + } + + /* Increase the worker count */ + OldValue = WorkQueue->Info; + NewValue = OldValue; + NewValue.WorkerCount++; + } + while (InterlockedCompareExchange((PLONG)&WorkQueue->Info, + *(PLONG)&NewValue, + *(PLONG)&OldValue) != *(PLONG)&OldValue); + + /* Success, you are now officially a worker thread! */ + Thread->ActiveExWorker = TRUE; + /* Loop forever */ - while (TRUE) { - +ProcessLoop: + for (;;) + { /* Wait for Something to Happen on the Queue */ - QueueEntry = KeRemoveQueue(&WorkQueue->WorkerQueue, KernelMode, NULL); + QueueEntry = KeRemoveQueue(&WorkQueue->WorkerQueue, + WaitMode, + TimeoutPointer); - /* Can't happen since we do a KernelMode wait (and we're a system thread) */ - ASSERT((NTSTATUS)QueueEntry != STATUS_USER_APC); + /* Check if we timed out and quit this loop in that case */ + if ((NTSTATUS)QueueEntry == STATUS_TIMEOUT) break; - /* this should never happen either, since we wait with NULL timeout, - * but there's a slight possibility that STATUS_TIMEOUT is returned - * at queue rundown in NT (unlikely) -Gunnar - */ - ASSERT((NTSTATUS)QueueEntry != STATUS_TIMEOUT); - /* Increment Processed Work Items */ InterlockedIncrement((PLONG)&WorkQueue->WorkItemsProcessed); /* Get the Work Item */ WorkItem = CONTAINING_RECORD(QueueEntry, WORK_QUEUE_ITEM, List); + /* Make sure nobody is trying to play smart with us */ + ASSERT((ULONG_PTR)WorkItem->WorkerRoutine > MmUserProbeAddress); + /* Call the Worker Routine */ WorkItem->WorkerRoutine(WorkItem->Parameter); + /* Make sure APCs are not disabled */ + if (Thread->Tcb.SpecialApcDisable) + { + /* We're nice and do it behind your back */ + DPRINT1("Warning: Broken Worker Thread: %p %lx %p came back " + "with APCs disabled!\n", + WorkItem->WorkerRoutine, + WorkItem->Parameter, + WorkItem); + Thread->Tcb.SpecialApcDisable = 0; + } + /* Make sure it returned at right IRQL */ - if (KeGetCurrentIrql() != PASSIVE_LEVEL) { - + if (KeGetCurrentIrql() != PASSIVE_LEVEL) + { + /* It didn't, bugcheck! */ KEBUGCHECKEX(WORKER_THREAD_RETURNED_AT_BAD_IRQL, (ULONG_PTR)WorkItem->WorkerRoutine, KeGetCurrentIrql(), @@ -90,8 +185,9 @@ } /* Make sure it returned with Impersionation Disabled */ - if (PsGetCurrentThread()->ActiveImpersonationInfo) { - + if (Thread->ActiveImpersonationInfo) + { + /* It didn't, bugcheck! */ KEBUGCHECKEX(IMPERSONATING_WORKER_THREAD, (ULONG_PTR)WorkItem->WorkerRoutine, (ULONG_PTR)WorkItem->Parameter, @@ -99,87 +195,470 @@ 0); } } + + /* This is a dynamic thread. Terminate it unless IRPs are pending */ + if (!IsListEmpty(&Thread->IrpList)) goto ProcessLoop; + + /* Don't terminate it if the queue is disabled either */ + if (WorkQueue->Info.QueueDisabled) goto ProcessLoop; + + /* Set the worker flags */ + do + { + /* Decrease the worker count */ + OldValue = WorkQueue->Info; + NewValue = OldValue; + NewValue.WorkerCount--; + } + while (InterlockedCompareExchange((PLONG)&WorkQueue->Info, + *(PLONG)&NewValue, + *(PLONG)&OldValue) != *(PLONG)&OldValue); + + /* Decrement dynamic thread count */ + InterlockedDecrement(&WorkQueue->DynamicThreadCount); + + /* We're not a worker thread anymore */ + Thread->ActiveExWorker = FALSE; + + /* Re-enable the stack swap */ + KeSetKernelStackSwapEnable(TRUE); + return; } -static +/*++ + * @name ExpCreateWorkerThread + * + * The ExpCreateWorkerThread routine creates a new worker thread for the + * specified queue. + ** + * @param QueueType + * Type of the queue to use for this thread. Valid values are: + * - DelayedWorkQueue + * - CriticalWorkQueue + * - HyperCriticalWorkQueue + * + * @param Dynamic + * Specifies whether or not this thread is a dynamic thread. + * + * @return None. + * + * @remarks HyperCritical work threads run at priority 7; Critical work threads + * run at priority 5, and delayed work threads run at priority 4. + * + * This, worker threads cannot pre-empty a normal user-mode thread. + * + *--*/ VOID -STDCALL -ExpInitializeWorkQueue(WORK_QUEUE_TYPE WorkQueueType, - KPRIORITY Priority) +NTAPI +ExpCreateWorkerThread(WORK_QUEUE_TYPE WorkQueueType, + IN BOOLEAN Dynamic) { - ULONG i; PETHREAD Thread; HANDLE hThread; + ULONG Context; + KPRIORITY Priority; - /* Loop through how many threads we need to create */ - for (i = 0; i < NUMBER_OF_WORKER_THREADS; i++) { + /* Check if this is going to be a dynamic thread */ + Context = WorkQueueType; - /* Create the System Thread */ - PsCreateSystemThread(&hThread, - THREAD_ALL_ACCESS, - NULL, - NULL, - NULL, - ExpWorkerThreadEntryPoint, - (PVOID)WorkQueueType); + /* Add the dynamic mask */ + if (Dynamic) Context |= EX_DYNAMIC_WORK_THREAD; - /* Get the Thread */ - ObReferenceObjectByHandle(hThread, - THREAD_SET_INFORMATION, - PsThreadType, + /* Create the System Thread */ + PsCreateSystemThread(&hThread, + THREAD_ALL_ACCESS, + NULL, + NULL, + NULL, + ExpWorkerThreadEntryPoint, + (PVOID)Context); + + /* If the thread is dynamic */ + if (Dynamic) + { + /* Increase the count */ + InterlockedIncrement(&ExWorkerQueue[WorkQueueType].DynamicThreadCount); + } + + /* Set the priority */ + if (WorkQueueType == DelayedWorkQueue) + { + /* Priority == 4 */ + Priority = EX_DELAYED_QUEUE_PRIORITY; + } + else if (WorkQueueType == CriticalWorkQueue) + { + /* Priority == 5 */ + Priority = EX_CRITICAL_QUEUE_PRIORITY; + } + else + { + /* Priority == 7 */ + Priority = EX_HYPERCRITICAL_QUEUE_PRIORITY; + } + + /* Get the Thread */ + ObReferenceObjectByHandle(hThread, + THREAD_SET_INFORMATION, + PsThreadType, + KernelMode, + (PVOID*)&Thread, + NULL); + + /* Set the Priority */ + KeSetPriorityThread(&Thread->Tcb, Priority); + + /* Dereference and close handle */ + ObDereferenceObject(Thread); + ZwClose(hThread); +} + +/*++ + * @name ExpCheckDynamicThreadCount + * + * The ExpCheckDynamicThreadCount routine checks every queue and creates a + * dynamic thread if the queue seems to be deadlocked. + * + * @param None + * + * @return None. + * + * @remarks The algorithm for deciding if a new thread must be created is + * based on wether the queue has processed no new items in the last + * second, and new items are still enqueued. + * + *--*/ +VOID +NTAPI +ExpDetectWorkerThreadDeadlock(VOID) +{ + ULONG i; + PEX_WORK_QUEUE Queue; + + /* Loop the 3 queues */ + for (i = 0; i < MaximumWorkQueue; i++) + { + /* Get the queue */ + Queue = &ExWorkerQueue[i]; + ASSERT(Queue->DynamicThreadCount <= 16); + + /* Check if stuff is on the queue that still is unprocessed */ + if ((Queue->QueueDepthLastPass) && + (Queue->WorkItemsProcessed == Queue->WorkItemsProcessedLastPass) && + (Queue->DynamicThreadCount < 16)) + { + /* Stuff is still on the queue and nobody did anything about it */ + DPRINT1("EX: Work Queue Deadlock detected: %d\n", i); + ExpCreateWorkerThread(i, TRUE); + DPRINT1("Dynamic threads queued %d\n", Queue->DynamicThreadCount); + } + + /* Update our data */ + Queue->WorkItemsProcessedLastPass = Queue->WorkItemsProcessed; + Queue->QueueDepthLastPass = KeReadStateQueue(&Queue->WorkerQueue); + } +} + +/*++ + * @name ExpCheckDynamicThreadCount + * + * The ExpCheckDynamicThreadCount routine checks every queue and creates a + * dynamic thread if the queue requires one. + * + * @param None + * + * @return None. + * + * @remarks The algorithm for deciding if a new thread must be created is + * documented in the ExQueueWorkItem routine. + * + *--*/ +VOID +NTAPI +ExpCheckDynamicThreadCount(VOID) +{ + ULONG i; + PEX_WORK_QUEUE Queue; + + /* Loop the 3 queues */ + for (i = 0; i < MaximumWorkQueue; i++) + { + /* Get the queue */ + Queue = &ExWorkerQueue[i]; + + /* Check if still need a new thread. See ExQueueWorkItem */ + if ((Queue->Info.MakeThreadsAsNecessary) && + (!IsListEmpty(&Queue->WorkerQueue.EntryListHead)) && + (Queue->WorkerQueue.CurrentCount < + Queue->WorkerQueue.MaximumCount) && + (Queue->DynamicThreadCount < 16)) + { + /* Create a new thread */ + DPRINT1("EX: Creating new dynamic thread as requested\n"); + ExpCreateWorkerThread(i, TRUE); + } + } +} + +/*++ + * @name ExpWorkerThreadBalanceManager + * + * The ExpWorkerThreadBalanceManager routine is the entrypoint for the + * worker thread balance set manager. + * + * @param Context + * Unused. + * + * @return None. + * + * @remarks The worker thread balance set manager listens every second, but can + * also be woken up by an event when a new thread is needed, or by the + * special shutdown event. This thread runs at priority 7. + * + * This routine must run at IRQL == PASSIVE_LEVEL. + * + *--*/ +VOID +NTAPI +ExpWorkerThreadBalanceManager(IN PVOID Context) +{ + KTIMER Timer; + LARGE_INTEGER Timeout; + NTSTATUS Status; + PVOID WaitEvents[2]; + PAGED_CODE(); + UNREFERENCED_PARAMETER(Context); + + /* Raise our priority above all other worker threads */ + KeSetBasePriorityThread(KeGetCurrentThread(), + EX_CRITICAL_QUEUE_PRIORITY + 1); + + /* Setup the timer */ + KeInitializeTimer(&Timer); + Timeout.QuadPart = Int32x32To64(-1, 10000000); + + /* We'll wait on the periodic timer and also the emergency event */ + WaitEvents[0] = &Timer; + WaitEvents[1] = &ExpThreadSetManagerEvent; + WaitEvents[2] = &ExpThreadSetManagerShutdownEvent; + + /* Start wait loop */ + for (;;) + { + /* Wait for the timer */ + KeSetTimer(&Timer, Timeout, NULL); + Status = KeWaitForMultipleObjects(3, + WaitEvents, + WaitAny, + Executive, + KernelMode, + FALSE, + NULL, + NULL); + if (Status == 0) + { + /* Our timer expired. Check for deadlocks */ + ExpDetectWorkerThreadDeadlock(); + } + else if (Status == 1) + { + /* Someone notified us, verify if we should create a new thread */ + ExpCheckDynamicThreadCount(); + } + else if (Status == 2) + { + /* We are shutting down. Cancel the timer */ + DPRINT1("System shutdown\n"); + KeCancelTimer(&Timer); + + /* Make sure we have a final thread */ + ASSERT(ExpLastWorkerThread); + + /* Wait for it */ + KeWaitForSingleObject(ExpLastWorkerThread, + Executive, KernelMode, - (PVOID*)&Thread, + FALSE, NULL); - /* Set the Priority */ - KeSetPriorityThread(&Thread->Tcb, Priority); - - /* Dereference and close handle */ - ObDereferenceObject(Thread); - ZwClose(hThread); + /* Dereference it and kill us */ + ObDereferenceObject(ExpLastWorkerThread); + PsTerminateSystemThread(STATUS_SYSTEM_SHUTDOWN); + } } } +/*++ + * @name ExpInitializeWorkerThreads + * + * The ExpInitializeWorkerThreads routine initializes worker thread and + * work queue support. + * + * @param None. + * + * @return None. + * + * @remarks This routine is only called once during system initialization. + * + *--*/ VOID INIT_FUNCTION -STDCALL +NTAPI ExpInitializeWorkerThreads(VOID) { ULONG WorkQueueType; + ULONG CriticalThreads, DelayedThreads; + HANDLE ThreadHandle; + PETHREAD Thread; + ULONG i; + /* Setup the stack swap support */ + KeInitializeMutex(&ExpWorkerSwapinMutex, FALSE); + InitializeListHead(&ExpWorkerListHead); + ExpWorkersCanSwap = TRUE; + + /* Set the number of critical and delayed threads. We shouldn't hardcode */ + DelayedThreads = EX_DELAYED_WORK_THREADS; + CriticalThreads = EX_CRITICAL_WORK_THREADS; + + /* Protect against greedy registry modifications */ + ExpAdditionalDelayedWorkerThreads = + min(ExpAdditionalCriticalWorkerThreads, 16); + ExpAdditionalCriticalWorkerThreads = + min(ExpAdditionalCriticalWorkerThreads, 16); + + /* Calculate final count */ + DelayedThreads += ExpAdditionalDelayedWorkerThreads; + CriticalThreads += ExpAdditionalCriticalWorkerThreads; + /* Initialize the Array */ - for (WorkQueueType = 0; WorkQueueType < MaximumWorkQueue; WorkQueueType++) { - + for (WorkQueueType = 0; WorkQueueType < MaximumWorkQueue; WorkQueueType++) + { + /* Clear the structure and initialize the queue */ RtlZeroMemory(&ExWorkerQueue[WorkQueueType], sizeof(EX_WORK_QUEUE)); KeInitializeQueue(&ExWorkerQueue[WorkQueueType].WorkerQueue, 0); } - /* Create the built-in worker threads for each work queue */ - ExpInitializeWorkQueue(CriticalWorkQueue, LOW_REALTIME_PRIORITY); - ExpInitializeWorkQueue(DelayedWorkQueue, LOW_PRIORITY); - ExpInitializeWorkQueue(HyperCriticalWorkQueue, HIGH_PRIORITY); + /* Dynamic threads are only used for the critical queue */ + ExWorkerQueue[CriticalWorkQueue].Info.MakeThreadsAsNecessary = TRUE; + + /* Initialize the balance set manager events */ + KeInitializeEvent(&ExpThreadSetManagerEvent, SynchronizationEvent, FALSE); + KeInitializeEvent(&ExpThreadSetManagerShutdownEvent, + NotificationEvent, + FALSE); + + /* Create the built-in worker threads for the critical queue */ + for (i = 0; i < CriticalThreads; i++) + { + /* Create the thread */ + ExpCreateWorkerThread(CriticalWorkQueue, FALSE); + ExpCriticalWorkerThreads++; + } + + /* Create the built-in worker threads for the delayed queue */ + for (i = 0; i < DelayedThreads; i++) + { + /* Create the thread */ + ExpCreateWorkerThread(DelayedWorkQueue, FALSE); + ExpDelayedWorkerThreads++; + } + + /* Create the built-in worker thread for the hypercritical queue */ + ExpCreateWorkerThread(HyperCriticalWorkQueue, FALSE); + + /* Create the balance set manager thread */ + PsCreateSystemThread(&ThreadHandle, + THREAD_ALL_ACCESS, + NULL, + 0, + NULL, + ExpWorkerThreadBalanceManager, + NULL); + + /* Get a pointer to it for the shutdown process */ + ObReferenceObjectByHandle(ThreadHandle, + THREAD_ALL_ACCESS, + NULL, + KernelMode, + (PVOID*)&Thread, + NULL); + ExpWorkerThreadBalanceManagerPtr = Thread; + + /* Close the handle and return */ + ZwClose(ThreadHandle); } -/* - * @implemented +/* PUBLIC FUNCTIONS **********************************************************/ + +/*++ + * @name ExQueueWorkItem + * @implemented NT4 * - * FUNCTION: Inserts a work item in a queue for one of the system worker - * threads to process - * ARGUMENTS: - * WorkItem = Item to insert - * QueueType = Queue to insert it in - */ + * The ExQueueWorkItem routine acquires rundown protection for + * the specified descriptor. + * + * @param WorkItem + * Pointer to an initialized Work Queue Item structure. This structure + * must be located in nonpaged pool memory. + * + * @param QueueType + * Type of the queue to use for this item. Can be one of the following: + * - DelayedWorkQueue + * - CriticalWorkQueue + * - HyperCriticalWorkQueue + * + * @return None. + * + * @remarks This routine is obsolete. Use IoQueueWorkItem instead. + * + * Callers of this routine must be running at IRQL <= DISPATCH_LEVEL. + * + *--*/ VOID -STDCALL +NTAPI ExQueueWorkItem(PWORK_QUEUE_ITEM WorkItem, WORK_QUEUE_TYPE QueueType) { - ASSERT(WorkItem!=NULL); - ASSERT_IRQL(DISPATCH_LEVEL); + PEX_WORK_QUEUE WorkQueue = &ExWorkerQueue[QueueType]; + ASSERT(QueueType < MaximumWorkQueue); ASSERT(WorkItem->List.Flink == NULL); + /* Don't try to trick us */ + if ((ULONG_PTR)WorkItem->WorkerRoutine < MmUserProbeAddress) + { + /* Bugcheck the system */ + KEBUGCHECKEX(WORKER_INVALID, + 1, + (ULONG_PTR)WorkItem, + (ULONG_PTR)WorkItem->WorkerRoutine, + 0); + } + /* Insert the Queue */ - KeInsertQueue(&ExWorkerQueue[QueueType].WorkerQueue, &WorkItem->List); + KeInsertQueue(&WorkQueue->WorkerQueue, &WorkItem->List); + ASSERT(!WorkQueue->Info.QueueDisabled); + + /* + * Check if we need a new thread. Our decision is as follows: + * - This queue type must support Dynamic Threads (duh!) + * - It actually has to have unprocessed items + * - We have CPUs which could be handling another thread + * - We haven't abused our usage of dynamic threads. + */ + if ((WorkQueue->Info.MakeThreadsAsNecessary) && + (!IsListEmpty(&WorkQueue->WorkerQueue.EntryListHead)) && + (WorkQueue->WorkerQueue.CurrentCount < + WorkQueue->WorkerQueue.MaximumCount) && + (WorkQueue->DynamicThreadCount < 16)) + { + /* Let the balance manager know about it */ + DPRINT1("Requesting a new thread. CurrentCount: %d. MaxCount: %d\n", + WorkQueue->WorkerQueue.CurrentCount, + WorkQueue->WorkerQueue.MaximumCount); + KeSetEvent(&ExpThreadSetManagerEvent, 0, FALSE); + } } /* EOF */ + _____ Modified: trunk/reactos/ntoskrnl/ntoskrnl.mc --- trunk/reactos/ntoskrnl/ntoskrnl.mc 2006-01-03 21:29:39 UTC (rev 20553) +++ trunk/reactos/ntoskrnl/ntoskrnl.mc 2006-01-03 21:34:19 UTC (rev 20554) @@ -1003,6 +1003,14 @@ WORKER_THREAD_RETURNED_AT_BAD_IRQL . +MessageId=0xE4 +Severity=Success +Facility=System +SymbolicName=WORKER_INVALID +Language=English +WORKER_INVALID +. + MessageId=0xE2 Severity=Success Facility=System _____ Modified: trunk/reactos/w32api/include/ddk/ntifs.h --- trunk/reactos/w32api/include/ddk/ntifs.h 2006-01-03 21:29:39 UTC (rev 20553) +++ trunk/reactos/w32api/include/ddk/ntifs.h 2006-01-03 21:34:19 UTC (rev 20554) @@ -1551,6 +1551,13 @@ TOKEN_CONTROL ClientTokenControl; } SECURITY_CLIENT_CONTEXT, *PSECURITY_CLIENT_CONTEXT; +typedef struct _ACE_HEADER +{ + UCHAR AceType; + UCHAR AceFlags; + USHORT AceSize; +} ACE_HEADER, *PACE_HEADER; + typedef struct _TUNNEL { FAST_MUTEX Mutex; PRTL_SPLAY_LINKS Cache; @@ -3370,6 +3377,13 @@ NTKERNELAPI BOOLEAN NTAPI +KeSetKernelStackSwapEnable( + IN BOOLEAN Enable +); + +NTKERNELAPI +BOOLEAN +NTAPI MmCanFileBeTruncated ( IN PSECTION_OBJECT_POINTERS SectionObjectPointer, IN PLARGE_INTEGER NewFileSize @@ -3885,10 +3899,10 @@ NTSYSAPI BOOLEAN NTAPI -RtlIsNameLegalDOS8Dot3 ( [truncated at 1000 lines; 104 more skipped]

18 years, 10 months

← Newer
1
...
50
51
52
53
54
55
56
...
59
Older →

Jump to page:

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Ros-diffs January 2006