thredsup.c File Reference

#include <srv.h>
#include <debug.h>

Include dependency graph for thredsup.c:

Go to the source code of this file.

Macros
#define	NDEBUG
#define	CsrHashThread(t)   (HandleToUlong(t) % NUMBER_THREAD_HASH_BUCKETS)

Functions
BOOLEAN NTAPI	ProtectHandle (IN HANDLE ObjectHandle)
BOOLEAN NTAPI	UnProtectHandle (IN HANDLE ObjectHandle)
PCSR_THREAD NTAPI	CsrAllocateThread (IN PCSR_PROCESS CsrProcess)
VOID NTAPI	CsrLockedReferenceThread (IN PCSR_THREAD CsrThread)
PCSR_THREAD NTAPI	CsrLocateThreadByClientId (OUT PCSR_PROCESS *Process OPTIONAL, IN PCLIENT_ID ClientId)
PCSR_THREAD NTAPI	CsrLocateThreadInProcess (IN PCSR_PROCESS CsrProcess OPTIONAL, IN PCLIENT_ID Cid)
NTSTATUS NTAPI	CsrInsertThread (IN PCSR_PROCESS Process, IN PCSR_THREAD Thread)
VOID NTAPI	CsrDeallocateThread (IN PCSR_THREAD CsrThread)
VOID NTAPI	CsrRemoveThread (IN PCSR_THREAD CsrThread)
VOID NTAPI	CsrThreadRefcountZero (IN PCSR_THREAD CsrThread)
VOID NTAPI	CsrLockedDereferenceThread (IN PCSR_THREAD CsrThread)
PCSR_THREAD NTAPI	CsrAddStaticServerThread (IN HANDLE hThread, IN PCLIENT_ID ClientId, IN ULONG ThreadFlags)
NTSTATUS NTAPI	CsrCreateRemoteThread (IN HANDLE hThread, IN PCLIENT_ID ClientId)
NTSTATUS NTAPI	CsrCreateThread (IN PCSR_PROCESS CsrProcess, IN HANDLE hThread, IN PCLIENT_ID ClientId, IN BOOLEAN HaveClient)
VOID NTAPI	CsrDereferenceThread (IN PCSR_THREAD CsrThread)
NTSTATUS NTAPI	CsrDestroyThread (IN PCLIENT_ID Cid)
NTSTATUS NTAPI	CsrExecServerThread (IN PVOID ThreadHandler, IN ULONG Flags)
NTSTATUS NTAPI	CsrLockThreadByClientId (IN HANDLE Tid, OUT PCSR_THREAD *CsrThread)
VOID NTAPI	CsrReferenceThread (IN PCSR_THREAD CsrThread)
NTSTATUS NTAPI	CsrUnlockThread (IN PCSR_THREAD CsrThread)

Variables
LIST_ENTRY	CsrThreadHashTable [NUMBER_THREAD_HASH_BUCKETS]

Macro Definition Documentation

CsrHashThread

#define CsrHashThread

(

t

)

(HandleToUlong(t) % NUMBER_THREAD_HASH_BUCKETS)

Definition at line 17 of file thredsup.c.

NDEBUG

#define NDEBUG

Definition at line 14 of file thredsup.c.

Function Documentation

CsrAddStaticServerThread()

PCSR_THREAD NTAPI CsrAddStaticServerThread	(	IN HANDLE	hThread,
		IN PCLIENT_ID	ClientId,
		IN ULONG	ThreadFlags
	)

Definition at line 512 of file thredsup.c.

{
    PCSR_THREAD CsrThread;
 
    /* Get the Lock */
    CsrAcquireProcessLock();
 
    /* Allocate the Server Thread */
    CsrThread = CsrAllocateThread(CsrRootProcess);
    if (CsrThread)
    {
        /* Setup the Object */
        CsrThread->ThreadHandle = hThread;
        ProtectHandle(hThread);
        CsrThread->ClientId = *ClientId;
        CsrThread->Flags = ThreadFlags;
 
        /* Insert it into the Thread List */
        InsertTailList(&CsrRootProcess->ThreadList, &CsrThread->Link);
 
        /* Increment the thread count */
        CsrRootProcess->ThreadCount++;
    }
    else
    {
        DPRINT1("CsrAddStaticServerThread: alloc failed for thread 0x%x\n", hThread);
    }
 
    /* Release the Process Lock and return */
    CsrReleaseProcessLock();
    return CsrThread;
}

Referenced by CsrApiPortInitialize(), CsrpCheckRequestThreads(), CsrSbApiPortInitialize(), and GuiInit().

CsrAllocateThread()

PCSR_THREAD NTAPI CsrAllocateThread

(

IN PCSR_PROCESS

CsrProcess

)

Definition at line 119 of file thredsup.c.

{
    PCSR_THREAD CsrThread;
 
    /* Allocate the structure */
    CsrThread = RtlAllocateHeap(CsrHeap, HEAP_ZERO_MEMORY, sizeof(CSR_THREAD));
    if (!CsrThread) return NULL;
 
    /* Reference the Thread and Process */
    CsrLockedReferenceThread(CsrThread);
    CsrLockedReferenceProcess(CsrProcess);
 
    /* Set the Parent Process */
    CsrThread->Process = CsrProcess;
 
    /* Return Thread */
    return CsrThread;
}

Referenced by CsrAddStaticServerThread(), CsrCreateProcess(), CsrCreateRemoteThread(), CsrCreateThread(), CsrExecServerThread(), and CsrSbCreateSession().

CsrCreateRemoteThread()

NTSTATUS NTAPI CsrCreateRemoteThread	(	IN HANDLE	hThread,
		IN PCLIENT_ID	ClientId
	)

Definition at line 569 of file thredsup.c.

{
    NTSTATUS Status;
    HANDLE ThreadHandle;
    PCSR_THREAD CsrThread;
    PCSR_PROCESS CsrProcess;
    KERNEL_USER_TIMES KernelTimes;
 
    /* Get the Thread Create Time */
    Status = NtQueryInformationThread(hThread,
                                      ThreadTimes,
                                      &KernelTimes,
                                      sizeof(KernelTimes),
                                      NULL);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Failed to query thread times: %lx\n", Status);
        return Status;
    }
 
    /* Lock the Owner Process */
    Status = CsrLockProcessByClientId(ClientId->UniqueProcess, &CsrProcess);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("No known process for %lx\n", ClientId->UniqueProcess);
        return Status;
    }
 
    /* Make sure the thread didn't terminate */
    if (KernelTimes.ExitTime.QuadPart)
    {
        /* Unlock the process and return */
        CsrUnlockProcess(CsrProcess);
        DPRINT1("Dead thread: %I64x\n", KernelTimes.ExitTime.QuadPart);
        return STATUS_THREAD_IS_TERMINATING;
    }
 
    /* Allocate a CSR Thread Structure */
    CsrThread = CsrAllocateThread(CsrProcess);
    if (!CsrThread)
    {
        DPRINT1("CSRSRV: %s: out of memory!\n", __FUNCTION__);
        CsrUnlockProcess(CsrProcess);
        return STATUS_NO_MEMORY;
    }
 
    /* Duplicate the Thread Handle */
    Status = NtDuplicateObject(NtCurrentProcess(),
                               hThread,
                               NtCurrentProcess(),
                               &ThreadHandle,
                               0,
                               0,
                               DUPLICATE_SAME_ACCESS);
    /* Allow failure */
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Thread duplication failed: %lx\n", Status);
        ThreadHandle = hThread;
    }
 
    /* Save the data we have */
    CsrThread->CreateTime = KernelTimes.CreateTime;
    CsrThread->ClientId = *ClientId;
    CsrThread->ThreadHandle = ThreadHandle;
    ProtectHandle(ThreadHandle);
    CsrThread->Flags = 0;
 
    /* Insert the Thread into the Process */
    Status = CsrInsertThread(CsrProcess, CsrThread);
    if (!NT_SUCCESS(Status))
    {
        /* Bail out */
        if (CsrThread->ThreadHandle != hThread) NtClose(CsrThread->ThreadHandle);
        CsrUnlockProcess(CsrProcess);
        CsrDeallocateThread(CsrThread);
        return Status;
    }
 
    /* Release the lock and return */
    CsrUnlockProcess(CsrProcess);
    return STATUS_SUCCESS;
}

Referenced by CreateRemoteThread().

CsrCreateThread()

NTSTATUS NTAPI CsrCreateThread	(	IN PCSR_PROCESS	CsrProcess,
		IN HANDLE	hThread,
		IN PCLIENT_ID	ClientId,
		IN BOOLEAN	HaveClient
	)

Definition at line 678 of file thredsup.c.

{
    NTSTATUS Status;
    PCSR_THREAD CsrThread, CurrentThread;
    PCSR_PROCESS CurrentProcess;
    CLIENT_ID CurrentCid;
    KERNEL_USER_TIMES KernelTimes;
 
    if (HaveClient)
    {
        /* Get the current thread and CID */
        CurrentThread = CsrGetClientThread();
        CurrentCid = CurrentThread->ClientId;
 
        /* Acquire the Process Lock */
        CsrAcquireProcessLock();
 
        /* Get the current Process and make sure the Thread is valid with this CID */
        CurrentThread = CsrLocateThreadByClientId(&CurrentProcess, &CurrentCid);
 
        /* Something is wrong if we get an empty thread back */
        if (!CurrentThread)
        {
            DPRINT1("CSRSRV: %s: invalid thread!\n", __FUNCTION__);
            CsrReleaseProcessLock();
            return STATUS_THREAD_IS_TERMINATING;
        }
    }
    else
    {
        /* Acquire the Process Lock */
        CsrAcquireProcessLock();
    }
 
    /* Get the Thread Create Time */
    Status = NtQueryInformationThread(hThread,
                                      ThreadTimes,
                                      &KernelTimes,
                                      sizeof(KernelTimes),
                                      NULL);
    if (!NT_SUCCESS(Status))
    {
        CsrReleaseProcessLock();
        return Status;
    }
 
    /* Allocate a CSR Thread Structure */
    CsrThread = CsrAllocateThread(CsrProcess);
    if (!CsrThread)
    {
        DPRINT1("CSRSRV: %s: out of memory!\n", __FUNCTION__);
        CsrReleaseProcessLock();
        return STATUS_NO_MEMORY;
    }
 
    /* Save the data we have */
    CsrThread->CreateTime = KernelTimes.CreateTime;
    CsrThread->ClientId = *ClientId;
    CsrThread->ThreadHandle = hThread;
    ProtectHandle(hThread);
    CsrThread->Flags = 0;
 
    /* Insert the Thread into the Process */
    Status = CsrInsertThread(CsrProcess, CsrThread);
    if (!NT_SUCCESS(Status))
    {
        /* Bail out */
        CsrUnlockProcess(CsrProcess);
        CsrDeallocateThread(CsrThread);
        return Status;
    }
 
    /* Release the lock and return */
    CsrReleaseProcessLock();
 
    return STATUS_SUCCESS;
}

Referenced by CSR_API().

CsrDeallocateThread()

VOID NTAPI CsrDeallocateThread

(

IN PCSR_THREAD

CsrThread

)

Definition at line 345 of file thredsup.c.

{
    /* Free the process object from the heap */
    // ASSERT(CsrThread->WaitBlock == NULL);
    RtlFreeHeap(CsrHeap, 0, CsrThread);
}

Referenced by CsrCreateProcess(), CsrCreateRemoteThread(), CsrCreateThread(), CsrExecServerThread(), CsrSbCreateSession(), and CsrThreadRefcountZero().

CsrDereferenceThread()

VOID NTAPI CsrDereferenceThread

(

IN PCSR_THREAD

CsrThread

)

Definition at line 776 of file thredsup.c.

{
    /* Acquire process lock */
    CsrAcquireProcessLock();
 
    /* Decrease reference count */
    ASSERT(CsrThread->ReferenceCount > 0);
    if ((--CsrThread->ReferenceCount) == 0)
    {
        /* Call the generic cleanup code */
        CsrThreadRefcountZero(CsrThread);
    }
    else
    {
        /* Just release the lock */
        CsrReleaseProcessLock();
    }
}

Referenced by CsrApiRequestThread(), CsrDereferenceWait(), CsrNotifyWaitBlock(), GuiConsoleInputThread(), and NotifyUserProcessForShutdown().

CsrDestroyThread()

NTSTATUS NTAPI CsrDestroyThread

(

IN PCLIENT_ID

Cid

)

Definition at line 814 of file thredsup.c.

{
    CLIENT_ID ClientId = *Cid;
    PCSR_THREAD CsrThread;
    PCSR_PROCESS CsrProcess;
 
    /* Acquire lock */
    CsrAcquireProcessLock();
 
    /* Find the thread */
    CsrThread = CsrLocateThreadByClientId(&CsrProcess,
                                          &ClientId);
 
    /* Make sure we got one back, and that it's not already gone */
    if (!CsrThread || (CsrThread->Flags & CsrThreadTerminated))
    {
        /* Release the lock and return failure */
        CsrReleaseProcessLock();
        return STATUS_THREAD_IS_TERMINATING;
    }
 
    /* Set the terminated flag */
    CsrThread->Flags |= CsrThreadTerminated;
 
    /* Acquire the Wait Lock */
    CsrAcquireWaitLock();
 
    /* Do we have an active wait block? */
    if (CsrThread->WaitBlock)
    {
        /* Notify waiters of termination */
        CsrNotifyWaitBlock(CsrThread->WaitBlock,
                           NULL,
                           NULL,
                           NULL,
                           CsrProcessTerminating,
                           TRUE);
    }
 
    /* Release the Wait Lock */
    CsrReleaseWaitLock();
 
    /* Dereference the thread */
    CsrLockedDereferenceThread(CsrThread);
 
    /* Release the Process Lock and return success */
    CsrReleaseProcessLock();
    return STATUS_SUCCESS;
}

Referenced by CsrApiRequestThread().

CsrExecServerThread()

NTSTATUS NTAPI CsrExecServerThread	(	IN PVOID	ThreadHandler,
		IN ULONG	Flags
	)

Definition at line 886 of file thredsup.c.

{
    PCSR_THREAD CsrThread;
    HANDLE hThread;
    CLIENT_ID ClientId;
    NTSTATUS Status;
 
    /* Acquire process lock */
    CsrAcquireProcessLock();
 
    /* Allocate a CSR Thread in the Root Process */
    ASSERT(CsrRootProcess != NULL);
    CsrThread = CsrAllocateThread(CsrRootProcess);
    if (!CsrThread)
    {
        /* Fail */
        CsrReleaseProcessLock();
        return STATUS_NO_MEMORY;
    }
 
    /* Create the Thread */
    Status = RtlCreateUserThread(NtCurrentProcess(),
                                 NULL,
                                 FALSE,
                                 0,
                                 0,
                                 0,
                                 ThreadHandler,
                                 NULL,
                                 &hThread,
                                 &ClientId);
    if (!NT_SUCCESS(Status))
    {
        /* Fail */
        CsrDeallocateThread(CsrThread);
        CsrReleaseProcessLock();
        return Status;
    }
 
    /* Setup the Thread Object */
    CsrThread->ThreadHandle = hThread;
    ProtectHandle(hThread);
    CsrThread->ClientId = ClientId;
    CsrThread->Flags = Flags;
 
    /* Insert it into the Thread List */
    InsertHeadList(&CsrRootProcess->ThreadList, &CsrThread->Link);
 
    /* Increase the thread count */
    CsrRootProcess->ThreadCount++;
 
    /* Return */
    CsrReleaseProcessLock();
    return Status;
}

Referenced by CSR_API().

CsrInsertThread()

NTSTATUS NTAPI CsrInsertThread	(	IN PCSR_PROCESS	Process,
		IN PCSR_THREAD	Thread
	)

Definition at line 297 of file thredsup.c.

{
    ULONG i;
    NTSTATUS Status;
    ULONG ThreadInfo;
    // ASSERT(ProcessStructureListLocked());
 
    /* Make sure the thread isn't already dead by the time we got this */
    Status = NtQueryInformationThread(Thread->ThreadHandle,
                                      ThreadIsTerminated,
                                      &ThreadInfo,
                                      sizeof(ThreadInfo),
                                      NULL);
    if (!NT_SUCCESS(Status)) return Status;
    if (ThreadInfo) return STATUS_THREAD_IS_TERMINATING;
 
    /* Insert it into the Regular List */
    InsertTailList(&Process->ThreadList, &Thread->Link);
 
    /* Increase Thread Count */
    Process->ThreadCount++;
 
    /* Hash the Thread */
    i = CsrHashThread(Thread->ClientId.UniqueThread);
 
    /* Insert it there too */
    InsertHeadList(&CsrThreadHashTable[i], &Thread->HashLinks);
    return STATUS_SUCCESS;
}

Referenced by CsrCreateProcess(), CsrCreateRemoteThread(), CsrCreateThread(), and CsrSbCreateSession().

CsrLocateThreadByClientId()

PCSR_THREAD NTAPI CsrLocateThreadByClientId	(	OUT PCSR_PROCESS *Process	OPTIONAL,
		IN PCLIENT_ID	ClientId
	)

Definition at line 182 of file thredsup.c.

{
    ULONG i;
    PLIST_ENTRY ListHead, NextEntry;
    PCSR_THREAD FoundThread;
    // ASSERT(ProcessStructureListLocked());
 
    if (Process) *Process = NULL;
 
    /* Hash the Thread */
    i = CsrHashThread(ClientId->UniqueThread);
 
    /* Set the list pointers */
    ListHead = &CsrThreadHashTable[i];
    NextEntry = ListHead->Flink;
 
    /* Star the loop */
    while (NextEntry != ListHead)
    {
        /* Get the thread */
        FoundThread = CONTAINING_RECORD(NextEntry, CSR_THREAD, HashLinks);
 
        /* Move to the next entry */
        NextEntry = NextEntry->Flink;
 
        /* Compare the CID */
        // if (*(PULONGLONG)&FoundThread->ClientId == *(PULONGLONG)ClientId)
        if ( FoundThread->ClientId.UniqueProcess == ClientId->UniqueProcess &&
             FoundThread->ClientId.UniqueThread  == ClientId->UniqueThread )
        {
            /* Match found, return the process */
            if (Process) *Process = FoundThread->Process;
 
            /* Return thread too */
            return FoundThread;
        }
    }
 
    /* Nothing found */
    return NULL;
}

Referenced by CsrApiHandleConnectionRequest(), CsrApiRequestThread(), CsrCreateProcess(), CsrCreateThread(), CsrDestroyProcess(), and CsrDestroyThread().

CsrLocateThreadInProcess()

PCSR_THREAD NTAPI CsrLocateThreadInProcess	(	IN PCSR_PROCESS CsrProcess	OPTIONAL,
		IN PCLIENT_ID	Cid
	)

Definition at line 248 of file thredsup.c.

{
    PLIST_ENTRY ListHead, NextEntry;
    PCSR_THREAD FoundThread = NULL;
 
    /* Use the Root Process if none was specified */
    if (!CsrProcess) CsrProcess = CsrRootProcess;
 
    /* Save the List pointers */
    ListHead = &CsrProcess->ThreadList;
    NextEntry = ListHead->Flink;
 
    /* Start the Loop */
    while (NextEntry != ListHead)
    {
        /* Get Thread Entry */
        FoundThread = CONTAINING_RECORD(NextEntry, CSR_THREAD, Link);
 
        /* Check for TID Match */
        if (FoundThread->ClientId.UniqueThread == Cid->UniqueThread) break;
 
        /* Move to the next entry */
        NextEntry = NextEntry->Flink;
    }
 
    /* Return what we found */
    return FoundThread;
}

Referenced by CsrConnectToUser().

CsrLockedDereferenceThread()

VOID NTAPI CsrLockedDereferenceThread

(

IN PCSR_THREAD

CsrThread

)

Definition at line 467 of file thredsup.c.

{
    LONG LockCount;
 
    /* Decrease reference count */
    LockCount = --CsrThread->ReferenceCount;
    ASSERT(LockCount >= 0);
    if (LockCount == 0)
    {
        /* Call the generic cleanup code */
        CsrThreadRefcountZero(CsrThread);
        /* Acquire the lock again, it was released by CsrThreadRefcountZero */
        CsrAcquireProcessLock();
    }
}

Referenced by CsrApiRequestThread(), CsrDestroyProcess(), CsrDestroyThread(), and CsrUnlockThread().

CsrLockedReferenceThread()

VOID NTAPI CsrLockedReferenceThread

(

IN PCSR_THREAD

CsrThread

)

Definition at line 154 of file thredsup.c.

{
    /* Increment the reference count */
    ++CsrThread->ReferenceCount;
}

Referenced by CsrAllocateThread(), CsrApiRequestThread(), and CsrLockThreadByClientId().

CsrLockThreadByClientId()

NTSTATUS NTAPI CsrLockThreadByClientId	(	IN HANDLE	Tid,
		OUT PCSR_THREAD *	CsrThread
	)

Definition at line 965 of file thredsup.c.

{
    PLIST_ENTRY NextEntry;
    PCSR_THREAD CurrentThread = NULL;
    NTSTATUS Status = STATUS_UNSUCCESSFUL;
    ULONG i;
 
    /* Acquire the lock */
    CsrAcquireProcessLock();
 
    /* Assume failure */
    ASSERT(CsrThread != NULL);
    *CsrThread = NULL;
 
    /* Convert to Hash */
    i = CsrHashThread(Tid);
 
    /* Setup the List Pointers */
    NextEntry = CsrThreadHashTable[i].Flink;
 
    /* Start Loop */
    while (NextEntry != &CsrThreadHashTable[i])
    {
        /* Get the Thread */
        CurrentThread = CONTAINING_RECORD(NextEntry, CSR_THREAD, HashLinks);
 
        /* Check for TID Match */
        if ((CurrentThread->ClientId.UniqueThread == Tid) &&
            (CurrentThread->Flags & CsrThreadTerminated) == 0)
        {
            /* Get out of here */
            break;
        }
 
        /* Move to the next entry */
        NextEntry = NextEntry->Flink;
    }
 
    /* Nothing found if we got back to the list */
    if (NextEntry == &CsrThreadHashTable[i]) CurrentThread = NULL;
 
    /* Did the loop find something? */
    if (CurrentThread)
    {
        /* Reference the found thread */
        Status = STATUS_SUCCESS;
        CsrLockedReferenceThread(CurrentThread);
        *CsrThread = CurrentThread;
    }
    else
    {
        /* Nothing found, release the lock */
        Status = STATUS_UNSUCCESSFUL;
        CsrReleaseProcessLock();
    }
 
    /* Return the status */
    return Status;
}

Referenced by GetThreadConsoleDesktop().

CsrReferenceThread()

VOID NTAPI CsrReferenceThread

(

IN PCSR_THREAD

CsrThread

)

Definition at line 1043 of file thredsup.c.

{
    /* Acquire process lock */
    CsrAcquireProcessLock();
 
    /* Sanity checks */
    ASSERT((CsrThread->Flags & CsrThreadTerminated) == 0);
    ASSERT(CsrThread->ReferenceCount != 0);
 
    /* Increment reference count */
    CsrThread->ReferenceCount++;
 
    /* Release the lock */
    CsrReleaseProcessLock();
}

Referenced by NotifyUserProcessForShutdown().

CsrRemoveThread()

VOID NTAPI CsrRemoveThread

(

IN PCSR_THREAD

CsrThread

)

Definition at line 373 of file thredsup.c.

{
    ASSERT(ProcessStructureListLocked());
 
    /* Remove it from the List */
    RemoveEntryList(&CsrThread->Link);
 
    /* Decreate the thread count of the process */
    CsrThread->Process->ThreadCount--;
 
    /* Remove it from the Hash List as well */
    if (CsrThread->HashLinks.Flink) RemoveEntryList(&CsrThread->HashLinks);
 
    /* Check if this is the last Thread */
    if (CsrThread->Process->ThreadCount == 0)
    {
        /* Check if it's not already been marked for deletion */
        if ((CsrThread->Process->Flags & CsrProcessLastThreadTerminated) == 0)
        {
            /* Let everyone know this process is about to lose the thread */
            CsrThread->Process->Flags |= CsrProcessLastThreadTerminated;
 
            /* Reference the Process */
            CsrLockedDereferenceProcess(CsrThread->Process);
        }
    }
 
    /* Mark the thread for deletion */
    CsrThread->Flags |= CsrThreadInTermination;
}

Referenced by CsrThreadRefcountZero().

CsrThreadRefcountZero()

VOID NTAPI CsrThreadRefcountZero

(

IN PCSR_THREAD

CsrThread

)

Definition at line 424 of file thredsup.c.

{
    PCSR_PROCESS CsrProcess = CsrThread->Process;
    NTSTATUS Status;
    ASSERT(ProcessStructureListLocked());
 
    /* Remove this thread */
    CsrRemoveThread(CsrThread);
 
    /* Release the Process Lock */
    CsrReleaseProcessLock();
 
    /* Close the NT Thread Handle */
    if (CsrThread->ThreadHandle)
    {
        UnProtectHandle(CsrThread->ThreadHandle);
        Status = NtClose(CsrThread->ThreadHandle);
        ASSERT(NT_SUCCESS(Status));
    }
 
    /* De-allocate the CSR Thread Object */
    CsrDeallocateThread(CsrThread);
 
    /* Remove a reference from the process */
    CsrDereferenceProcess(CsrProcess);
}

Referenced by CsrDereferenceThread(), and CsrLockedDereferenceThread().

CsrUnlockThread()

NTSTATUS NTAPI CsrUnlockThread

(

IN PCSR_THREAD

CsrThread

)

Definition at line 1075 of file thredsup.c.

{
    /* Dereference the Thread */
    ASSERT(ProcessStructureListLocked());
    CsrLockedDereferenceThread(CsrThread);
 
    /* Release the lock and return */
    CsrReleaseProcessLock();
    return STATUS_SUCCESS;
}

Referenced by GetThreadConsoleDesktop().

ProtectHandle()

BOOLEAN NTAPI ProtectHandle

(

IN HANDLE

ObjectHandle

)

Definition at line 39 of file thredsup.c.

{
    NTSTATUS Status;
    OBJECT_HANDLE_ATTRIBUTE_INFORMATION HandleInfo;
 
    /* Query current state */
    Status = NtQueryObject(ObjectHandle,
                           ObjectHandleFlagInformation,
                           &HandleInfo,
                           sizeof(HandleInfo),
                           NULL);
    if (NT_SUCCESS(Status))
    {
        /* Enable protect from close */
        HandleInfo.ProtectFromClose = TRUE;
        Status = NtSetInformationObject(ObjectHandle,
                                        ObjectHandleFlagInformation,
                                        &HandleInfo,
                                        sizeof(HandleInfo));
        if (NT_SUCCESS(Status)) return TRUE;
    }
 
    /* We failed to or set the state */
    return FALSE;
}

Referenced by CsrAddStaticServerThread(), CsrCreateProcess(), CsrCreateRemoteThread(), CsrCreateThread(), CsrExecServerThread(), and CsrSbCreateSession().

UnProtectHandle()

BOOLEAN NTAPI UnProtectHandle

(

IN HANDLE

ObjectHandle

)

Definition at line 78 of file thredsup.c.

{
    NTSTATUS Status;
    OBJECT_HANDLE_ATTRIBUTE_INFORMATION HandleInfo;
 
    /* Query current state */
    Status = NtQueryObject(ObjectHandle,
                           ObjectHandleFlagInformation,
                           &HandleInfo,
                           sizeof(HandleInfo),
                           NULL);
    if (NT_SUCCESS(Status))
    {
        /* Disable protect from close */
        HandleInfo.ProtectFromClose = FALSE;
        Status = NtSetInformationObject(ObjectHandle,
                                        ObjectHandleFlagInformation,
                                        &HandleInfo,
                                        sizeof(HandleInfo));
        if (NT_SUCCESS(Status)) return TRUE;
    }
 
    /* We failed to or set the state */
    return FALSE;
}

Referenced by CsrThreadRefcountZero().

Variable Documentation

CsrThreadHashTable

LIST_ENTRY CsrThreadHashTable[NUMBER_THREAD_HASH_BUCKETS]

Definition at line 21 of file thredsup.c.

Referenced by CsrInitializeProcessStructure(), CsrInsertThread(), CsrLocateThreadByClientId(), and CsrLockThreadByClientId().