sys_arch.c File Reference

#include <debug.h>
#include <lwip/sys.h>
#include "lwip_glue.h"

Include dependency graph for sys_arch.c:

Go to the source code of this file.

Classes
struct	_thread_t

Typedefs
typedef struct _thread_t *	thread_t

Functions
u32_t	sys_now (void)
void	sys_arch_protect (sys_prot_t *lev)
void	sys_arch_unprotect (sys_prot_t lev)
err_t	sys_sem_new (sys_sem_t *sem, u8_t count)
int	sys_sem_valid (sys_sem_t *sem)
void	sys_sem_set_invalid (sys_sem_t *sem)
void	sys_sem_free (sys_sem_t *sem)
void	sys_sem_signal (sys_sem_t *sem)
u32_t	sys_arch_sem_wait (sys_sem_t *sem, u32_t timeout)
err_t	sys_mbox_new (sys_mbox_t *mbox, int size)
int	sys_mbox_valid (sys_mbox_t *mbox)
void	sys_mbox_set_invalid (sys_mbox_t *mbox)
void	sys_mbox_free (sys_mbox_t *mbox)
void	sys_mbox_post (sys_mbox_t *mbox, void *msg)
u32_t	sys_arch_mbox_fetch (sys_mbox_t *mbox, void **msg, u32_t timeout)
u32_t	sys_arch_mbox_tryfetch (sys_mbox_t *mbox, void **msg)
err_t	sys_mbox_trypost (sys_mbox_t *mbox, void *msg)
VOID NTAPI	LwipThreadMain (PVOID Context)
sys_thread_t	sys_thread_new (const char *name, lwip_thread_fn thread, void *arg, int stacksize, int prio)
void	sys_init (void)
void	sys_shutdown (void)

Variables
static LIST_ENTRY	ThreadListHead
static KSPIN_LOCK	ThreadListLock
KEVENT	TerminationEvent
NPAGED_LOOKASIDE_LIST	MessageLookasideList
NPAGED_LOOKASIDE_LIST	QueueEntryLookasideList
static LARGE_INTEGER	StartTime

Typedef Documentation

thread_t

typedef struct _thread_t * thread_t

Function Documentation

LwipThreadMain()

VOID NTAPI LwipThreadMain

(

PVOID

Context

)

Definition at line 256 of file sys_arch.c.

{
    thread_t Container = (thread_t)Context;
    KIRQL OldIrql;
 
    ExInterlockedInsertHeadList(&ThreadListHead, &Container->ListEntry, &ThreadListLock);
 
    Container->ThreadFunction(Container->ThreadContext);
 
    KeAcquireSpinLock(&ThreadListLock, &OldIrql);
    RemoveEntryList(&Container->ListEntry);
    KeReleaseSpinLock(&ThreadListLock, OldIrql);
 
    ExFreePool(Container);
 
    PsTerminateSystemThread(STATUS_SUCCESS);
}

Referenced by sys_thread_new().

sys_arch_mbox_fetch()

u32_t sys_arch_mbox_fetch	(	sys_mbox_t *	mbox,
		void **	msg,
		u32_t	timeout
	)

Wait for a new message to arrive in the mbox

Parameters

mbox	mbox to get a message from
msg	pointer where the message is stored
timeout	maximum time (in milliseconds) to wait for a message

Returns

time (in milliseconds) waited for a message, may be 0 if not waited or SYS_ARCH_TIMEOUT on timeout The returned time has to be accurate to prevent timer jitter!

Definition at line 177 of file sys_arch.c.

{
    LARGE_INTEGER LargeTimeout, PreWaitTime, PostWaitTime;
    UINT64 TimeDiff;
    NTSTATUS Status;
    PVOID Message;
    PLWIP_MESSAGE_CONTAINER Container;
    PLIST_ENTRY Entry;
    KIRQL OldIrql;
    PVOID WaitObjects[] = {&mbox->Event, &TerminationEvent};
 
    LargeTimeout.QuadPart = Int32x32To64(timeout, -10000);
 
    KeQuerySystemTime(&PreWaitTime);
 
    Status = KeWaitForMultipleObjects(2,
                                      WaitObjects,
                                      WaitAny,
                                      Executive,
                                      KernelMode,
                                      FALSE,
                                      timeout != 0 ? &LargeTimeout : NULL,
                                      NULL);
 
    if (Status == STATUS_WAIT_0)
    {
        KeAcquireSpinLock(&mbox->Lock, &OldIrql);
        Entry = RemoveHeadList(&mbox->ListHead);
        ASSERT(Entry);
        if (IsListEmpty(&mbox->ListHead))
            KeClearEvent(&mbox->Event);
        KeReleaseSpinLock(&mbox->Lock, OldIrql);
 
        Container = CONTAINING_RECORD(Entry, LWIP_MESSAGE_CONTAINER, ListEntry);
        Message = Container->Message;
        ExFreePool(Container);
 
        if (msg)
            *msg = Message;
 
        KeQuerySystemTime(&PostWaitTime);
        TimeDiff = PostWaitTime.QuadPart - PreWaitTime.QuadPart;
        TimeDiff /= 10000;
 
        return TimeDiff;
    }
    else if (Status == STATUS_WAIT_1)
    {
        /* DON'T remove ourselves from the thread list! */
        PsTerminateSystemThread(STATUS_SUCCESS);
 
        /* We should never get here! */
        ASSERT(FALSE);
 
        return 0;
    }
 
    return SYS_ARCH_TIMEOUT;
}

Referenced by sys_arch_mbox_tryfetch().

sys_arch_mbox_tryfetch()

u32_t sys_arch_mbox_tryfetch	(	sys_mbox_t *	mbox,
		void **	msg
	)

Wait for a new message to arrive in the mbox

Parameters

mbox	mbox to get a message from
msg	pointer where the message is stored
timeout	maximum time (in milliseconds) to wait for a message

Returns

0 (milliseconds) if a message has been received or SYS_MBOX_EMPTY if the mailbox is empty

Definition at line 238 of file sys_arch.c.

{
    if (sys_arch_mbox_fetch(mbox, msg, 1) != SYS_ARCH_TIMEOUT)
        return 0;
    else
        return SYS_MBOX_EMPTY;
}

sys_arch_protect()

void sys_arch_protect

(

sys_prot_t *

lev

)

Definition at line 33 of file sys_arch.c.

{
    /* Preempt the dispatcher */
    KeRaiseIrql(DISPATCH_LEVEL, lev);
}

sys_arch_sem_wait()

u32_t sys_arch_sem_wait	(	sys_sem_t *	sem,
		u32_t	timeout
	)

Wait for a semaphore for the specified timeout

Parameters

sem	the semaphore to wait for
timeout	timeout in milliseconds to wait (0 = wait forever)

Returns

time (in milliseconds) waited for the semaphore or SYS_ARCH_TIMEOUT on timeout

Definition at line 86 of file sys_arch.c.

{
    LARGE_INTEGER LargeTimeout, PreWaitTime, PostWaitTime;
    UINT64 TimeDiff;
    NTSTATUS Status;
    PVOID WaitObjects[] = {&sem->Event, &TerminationEvent};
 
    LargeTimeout.QuadPart = Int32x32To64(timeout, -10000);
 
    KeQuerySystemTime(&PreWaitTime);
 
    Status = KeWaitForMultipleObjects(2,
                                      WaitObjects,
                                      WaitAny,
                                      Executive,
                                      KernelMode,
                                      FALSE,
                                      timeout != 0 ? &LargeTimeout : NULL,
                                      NULL);
    if (Status == STATUS_WAIT_0)
    {
        KeQuerySystemTime(&PostWaitTime);
        TimeDiff = PostWaitTime.QuadPart - PreWaitTime.QuadPart;
        TimeDiff /= 10000;
 
        return TimeDiff;
    }
    else if (Status == STATUS_WAIT_1)
    {
        /* DON'T remove ourselves from the thread list! */
        PsTerminateSystemThread(STATUS_SUCCESS);
 
        /* We should never get here! */
        ASSERT(FALSE);
 
        return 0;
    }
 
    return SYS_ARCH_TIMEOUT;
}

Referenced by sys_msleep().

sys_arch_unprotect()

void sys_arch_unprotect

(

sys_prot_t

lev

)

Definition at line 40 of file sys_arch.c.

{
    KeLowerIrql(lev);
}

sys_init()

void sys_init

(

void

)

Definition at line 305 of file sys_arch.c.

{
    KeInitializeSpinLock(&ThreadListLock);
    InitializeListHead(&ThreadListHead);
 
    KeQuerySystemTime(&StartTime);
 
    KeInitializeEvent(&TerminationEvent, NotificationEvent, FALSE);
 
    ExInitializeNPagedLookasideList(&MessageLookasideList,
                                    NULL,
                                    NULL,
                                    0,
                                    sizeof(struct lwip_callback_msg),
                                    LWIP_MESSAGE_TAG,
                                    0);
 
    ExInitializeNPagedLookasideList(&QueueEntryLookasideList,
                                    NULL,
                                    NULL,
                                    0,
                                    sizeof(QUEUE_ENTRY),
                                    LWIP_QUEUE_TAG,
                                    0);
}

Referenced by lwip_init().

sys_mbox_free()

void sys_mbox_free

(

sys_mbox_t *

mbox

)

Delete an mbox

Parameters

mbox	mbox to delete

Definition at line 152 of file sys_arch.c.

{
    ASSERT(IsListEmpty(&mbox->ListHead));
 
    sys_mbox_set_invalid(mbox);
}

sys_mbox_new()

err_t sys_mbox_new	(	sys_mbox_t *	mbox,
		int	size
	)

Create a new mbox of specified size

Parameters

mbox	pointer to the mbox to create
size	(miminum) number of messages in this mbox

Returns

ERR_OK if successful, another err_t otherwise

Definition at line 128 of file sys_arch.c.

{
    KeInitializeSpinLock(&mbox->Lock);
 
    InitializeListHead(&mbox->ListHead);
 
    KeInitializeEvent(&mbox->Event, NotificationEvent, FALSE);
 
    mbox->Valid = 1;
 
    return ERR_OK;
}

Referenced by tcpip_init().

sys_mbox_post()

void sys_mbox_post	(	sys_mbox_t *	mbox,
		void *	msg
	)

Post a message to an mbox - may not fail -> blocks if full, only used from tasks not from ISR

Parameters

mbox	mbox to posts the message
msg	message to post (ATTENTION: can be NULL)

Definition at line 160 of file sys_arch.c.

{
    PLWIP_MESSAGE_CONTAINER Container;
 
    Container = ExAllocatePool(NonPagedPool, sizeof(*Container));
    ASSERT(Container);
 
    Container->Message = msg;
 
    ExInterlockedInsertTailList(&mbox->ListHead,
                                &Container->ListEntry,
                                &mbox->Lock);
 
    KeSetEvent(&mbox->Event, IO_NO_INCREMENT, FALSE);
}

Referenced by sys_mbox_trypost(), and tcpip_callback_with_block().

sys_mbox_set_invalid()

void sys_mbox_set_invalid

(

sys_mbox_t *

mbox

)

Set an mbox invalid so that sys_mbox_valid returns 0

Definition at line 146 of file sys_arch.c.

{
    mbox->Valid = 0;
}

Referenced by sys_mbox_free().

sys_mbox_trypost()

err_t sys_mbox_trypost	(	sys_mbox_t *	mbox,
		void *	msg
	)

Try to post a message to an mbox - may fail if full or ISR

Parameters

mbox	mbox to posts the message
msg	message to post (ATTENTION: can be NULL)

Definition at line 247 of file sys_arch.c.

{
    sys_mbox_post(mbox, msg);
 
    return ERR_OK;
}

Referenced by tcpip_callback_with_block(), tcpip_input(), and tcpip_trycallback().

sys_mbox_valid()

int sys_mbox_valid

(

sys_mbox_t *

mbox

)

Check if an mbox is valid/allocated: return 1 for valid, 0 for invalid

Definition at line 141 of file sys_arch.c.

{
    return mbox->Valid;
}

Referenced by tcpip_callback_with_block(), tcpip_input(), and tcpip_trycallback().

sys_now()

u32_t sys_now

(

void

)

Returns the current time in milliseconds, may be the same as sys_jiffies or at least based on it.

Definition at line 23 of file sys_arch.c.

{
    LARGE_INTEGER CurrentTime;
 
    KeQuerySystemTime(&CurrentTime);
 
    return (CurrentTime.QuadPart - StartTime.QuadPart) / 10000;
}

sys_sem_free()

void sys_sem_free

(

sys_sem_t *

sem

)

Delete a semaphore

Parameters

sem	semaphore to delete

Definition at line 72 of file sys_arch.c.

{
    /* No op (allocated in stack) */
 
    sys_sem_set_invalid(sem);
}

Referenced by sys_msleep().

sys_sem_new()

err_t sys_sem_new	(	sys_sem_t *	sem,
		u8_t	count
	)

Create a new semaphore

Parameters

sem	pointer to the semaphore to create
count	initial count of the semaphore

Returns

ERR_OK if successful, another err_t otherwise

Definition at line 46 of file sys_arch.c.

{
    ASSERT(count == 0 || count == 1);
 
    /* It seems lwIP uses the semaphore implementation as either a completion event or a lock
     * so I optimize for this case by using a synchronization event and setting its initial state
     * to signalled for a lock and non-signalled for a completion event */
 
    KeInitializeEvent(&sem->Event, SynchronizationEvent, count);
 
    sem->Valid = 1;
 
    return ERR_OK;
}

Referenced by sys_msleep().

sys_sem_set_invalid()

void sys_sem_set_invalid

(

sys_sem_t *

sem

)

Set a semaphore invalid so that sys_sem_valid returns 0

Definition at line 66 of file sys_arch.c.

{
    sem->Valid = 0;
}

Referenced by sys_sem_free().

sys_sem_signal()

void sys_sem_signal

(

sys_sem_t *

sem

)

Signals a semaphore

Parameters

sem	the semaphore to signal

Definition at line 80 of file sys_arch.c.

{
    KeSetEvent(&sem->Event, IO_NO_INCREMENT, FALSE);
}

sys_sem_valid()

int sys_sem_valid

(

sys_sem_t *

sem

)

Check if a sempahore is valid/allocated: return 1 for valid, 0 for invalid

Definition at line 61 of file sys_arch.c.

{
    return sem->Valid;
}

sys_shutdown()

void sys_shutdown

(

void

)

Definition at line 332 of file sys_arch.c.

{
    PLIST_ENTRY CurrentEntry;
    thread_t Container;
 
    /* Set the termination event */
    KeSetEvent(&TerminationEvent, IO_NO_INCREMENT, FALSE);
 
    /* Loop through the thread list and wait for each to die */
    while ((CurrentEntry = ExInterlockedRemoveHeadList(&ThreadListHead, &ThreadListLock)))
    {
        Container = CONTAINING_RECORD(CurrentEntry, struct _thread_t, ListEntry);
 
        if (Container->ThreadFunction)
        {
            KeWaitForSingleObject(Container->Handle,
                                  Executive,
                                  KernelMode,
                                  FALSE,
                                  NULL);
 
            ZwClose(Container->Handle);
        }
    }
 
    ExDeleteNPagedLookasideList(&MessageLookasideList);
    ExDeleteNPagedLookasideList(&QueueEntryLookasideList);
}

Referenced by LibIPShutdown().

sys_thread_new()

sys_thread_t sys_thread_new	(	const char *	name,
		lwip_thread_fn	thread,
		void *	arg,
		int	stacksize,
		int	prio
	)

The only thread function: Creates a new thread

Parameters

name	human-readable name for the thread (used for debugging purposes)
thread	thread-function
arg	parameter passed to 'thread'
stacksize	stack size in bytes for the new thread (may be ignored by ports)
prio	priority of the new thread (may be ignored by ports)

Definition at line 275 of file sys_arch.c.

{
    thread_t Container;
    NTSTATUS Status;
 
    Container = ExAllocatePool(NonPagedPool, sizeof(*Container));
    if (!Container)
        return 0;
 
    Container->ThreadFunction = thread;
    Container->ThreadContext = arg;
 
    Status = PsCreateSystemThread(&Container->Handle,
                                  THREAD_ALL_ACCESS,
                                  NULL,
                                  NULL,
                                  NULL,
                                  LwipThreadMain,
                                  Container);
 
    if (!NT_SUCCESS(Status))
    {
        ExFreePool(Container);
        return 0;
    }
 
    return 0;
}

Referenced by tcpip_init().

Variable Documentation

MessageLookasideList

NPAGED_LOOKASIDE_LIST MessageLookasideList

Definition at line 10 of file sys_arch.c.

Referenced by LibTCPBind(), LibTCPClose(), LibTCPConnect(), LibTCPListen(), LibTCPSend(), LibTCPShutdown(), LibTCPSocket(), sys_init(), and sys_shutdown().

QueueEntryLookasideList

NPAGED_LOOKASIDE_LIST QueueEntryLookasideList

Definition at line 11 of file sys_arch.c.

Referenced by LibTCPEmptyQueue(), LibTCPEnqueuePacket(), LibTCPGetDataFromConnectionQueue(), sys_init(), and sys_shutdown().

StartTime

LARGE_INTEGER StartTime

static

Definition at line 13 of file sys_arch.c.

Referenced by DoStopService(), KeStallExecutionProcessor(), KmtEnsureServiceState(), NtWaitForDebugEvent(), ProgressCountdown(), CWineTest::RunTest(), sys_init(), sys_now(), and USB2_AllocateTimeForEndpoint().

TerminationEvent

KEVENT TerminationEvent

Definition at line 9 of file sys_arch.c.

Referenced by sys_arch_mbox_fetch(), sys_arch_sem_wait(), sys_init(), sys_shutdown(), and WaitForEventSafely().

ThreadListHead

LIST_ENTRY ThreadListHead

static

Definition at line 6 of file sys_arch.c.

Referenced by LwipThreadMain(), NtQueryInformationThread(), sys_init(), and sys_shutdown().

ThreadListLock

KSPIN_LOCK ThreadListLock

static

Definition at line 7 of file sys_arch.c.

Referenced by LwipThreadMain(), sys_init(), and sys_shutdown().