clocks.c

Go to the documentation of this file.

/*
 * COPYRIGHT:       See COPYING in the top level directory
 * PROJECT:         ReactOS Kernel Streaming
 * FILE:            drivers/ksfilter/ks/clocks.c
 * PURPOSE:         KS Clocks functions
 * PROGRAMMER:      Johannes Anderwald
 */
 
#include "precomp.h"
 
#define NDEBUG
#include <debug.h>
 
typedef struct
{
    LONGLONG Time;
    KSPIN_LOCK TimeLock;
    KSSTATE State;
    KTIMER Timer;
    LONG ReferenceCount;
 
    PVOID Context;
    PFNKSSETTIMER SetTimer;
    PFNKSCANCELTIMER CancelTimer;
    PFNKSCORRELATEDTIME CorrelatedTime;
    LONGLONG Granularity;
    LONGLONG Error;
    ULONG Flags;
 
}KSIDEFAULTCLOCK, *PKSIDEFAULTCLOCK;
 
typedef struct
{
    LONG ref;
    PKSCLOCK_CREATE ClockCreate;
    PKSIDEFAULTCLOCK DefaultClock;
    PKSIOBJECT_HEADER ObjectHeader;
}KSICLOCK, *PKSICLOCK;
 
NTSTATUS NTAPI ClockPropertyTime(IN PIRP Irp, IN PKSIDENTIFIER Request, IN OUT PVOID Data);
NTSTATUS NTAPI ClockPropertyPhysicalTime(IN PIRP Irp, IN PKSIDENTIFIER Request, IN OUT PVOID Data);
NTSTATUS NTAPI ClockPropertyCorrelatedTime(IN PIRP Irp, IN PKSIDENTIFIER Request, IN OUT PVOID Data);
NTSTATUS NTAPI ClockPropertyCorrelatedPhysicalTime(IN PIRP Irp, IN PKSIDENTIFIER Request, IN OUT PVOID Data);
NTSTATUS NTAPI ClockPropertyResolution(IN PIRP Irp, IN PKSIDENTIFIER Request, IN OUT PVOID Data);
NTSTATUS NTAPI ClockPropertyState(IN PIRP Irp, IN PKSIDENTIFIER Request, IN OUT PVOID Data);
NTSTATUS NTAPI ClockPropertyFunctionTable(IN PIRP Irp, IN PKSIDENTIFIER Request, IN OUT PVOID Data);
 
DEFINE_KSPROPERTY_CLOCKSET(ClockPropertyTable, ClockPropertyTime, ClockPropertyPhysicalTime, ClockPropertyCorrelatedTime, ClockPropertyCorrelatedPhysicalTime, ClockPropertyResolution, ClockPropertyState, ClockPropertyFunctionTable);
 
KSPROPERTY_SET ClockPropertySet[] =
{
    {
        &KSPROPSETID_Clock,
        sizeof(ClockPropertyTable) / sizeof(KSPROPERTY_ITEM),
        (const KSPROPERTY_ITEM*)&ClockPropertyTable,
        0,
        NULL
    }
};
 
LONGLONG
FASTCALL
ClockGetPhysicalTime(
    IN PFILE_OBJECT FileObject)
{
    UNIMPLEMENTED;
    return 0;
}
 
LONGLONG
FASTCALL
ClockGetCorrelatedTime(
    IN PFILE_OBJECT FileObject,
    OUT PLONGLONG SystemTime)
{
    UNIMPLEMENTED;
    return 0;
}
 
LONGLONG
FASTCALL
ClockGetTime(
    IN PFILE_OBJECT FileObject)
{
    UNIMPLEMENTED;
    return 0;
}
 
LONGLONG
FASTCALL
ClockGetCorrelatedPhysicalTime(
    IN PFILE_OBJECT FileObject,
    OUT PLONGLONG SystemTime)
{
    UNIMPLEMENTED;
    return 0;
}
 
NTSTATUS
NTAPI
ClockPropertyTime(
    IN PIRP Irp,
    IN PKSIDENTIFIER Request,
    IN OUT PVOID Data)
{
    PLONGLONG Time = (PLONGLONG)Data;
    PIO_STACK_LOCATION IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    DPRINT("ClockPropertyTime\n");
 
    *Time = ClockGetTime(IoStack->FileObject);
 
    Irp->IoStatus.Information = sizeof(LONGLONG);
    return STATUS_SUCCESS;
}
 
NTSTATUS
NTAPI
ClockPropertyPhysicalTime(
    IN PIRP Irp,
    IN PKSIDENTIFIER Request,
    IN OUT PVOID Data)
{
    PLONGLONG Time = (PLONGLONG)Data;
    PIO_STACK_LOCATION IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    DPRINT("ClockPropertyPhysicalTime\n");
 
    *Time = ClockGetPhysicalTime(IoStack->FileObject);
 
    Irp->IoStatus.Information = sizeof(LONGLONG);
    return STATUS_SUCCESS;
}
 
NTSTATUS
NTAPI
ClockPropertyCorrelatedTime(
    IN PIRP Irp,
    IN PKSIDENTIFIER Request,
    IN OUT PVOID Data)
{
    PKSCORRELATED_TIME Time = (PKSCORRELATED_TIME)Data;
    PIO_STACK_LOCATION IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    DPRINT("ClockPropertyCorrelatedTime\n");
 
    Time->Time = ClockGetCorrelatedTime(IoStack->FileObject, &Time->SystemTime);
 
    Irp->IoStatus.Information = sizeof(KSCORRELATED_TIME);
    return STATUS_SUCCESS;
}
 
NTSTATUS
NTAPI
ClockPropertyCorrelatedPhysicalTime(
    IN PIRP Irp,
    IN PKSIDENTIFIER Request,
    IN OUT PVOID Data)
{
    PKSCORRELATED_TIME Time = (PKSCORRELATED_TIME)Data;
    PIO_STACK_LOCATION IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    DPRINT("ClockPropertyCorrelatedPhysicalTime\n");
 
    Time->Time = ClockGetCorrelatedPhysicalTime(IoStack->FileObject, &Time->SystemTime);
 
    Irp->IoStatus.Information = sizeof(KSCORRELATED_TIME);
    return STATUS_SUCCESS;
}
 
NTSTATUS
NTAPI
ClockPropertyResolution(
    IN PIRP Irp,
    IN PKSIDENTIFIER Request,
    IN OUT PVOID Data)
{
    PKSICLOCK Clock;
    PKSIOBJECT_HEADER ObjectHeader;
    PIO_STACK_LOCATION IoStack;
    PKSRESOLUTION Resolution = (PKSRESOLUTION)Data;
 
    DPRINT("ClockPropertyResolution\n");
 
    /* get stack location */
    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    /* get the object header */
    ObjectHeader = (PKSIOBJECT_HEADER)IoStack->FileObject->FsContext2;
 
    /* sanity check */
    ASSERT(ObjectHeader);
 
    /* locate ks pin implementation from KSPIN offset */
    Clock = (PKSICLOCK)ObjectHeader->ObjectType;
 
    Resolution->Error = Clock->DefaultClock->Error;
    Resolution->Granularity = Clock->DefaultClock->Granularity;
 
    Irp->IoStatus.Information = sizeof(KSRESOLUTION);
    return STATUS_SUCCESS;
}
 
NTSTATUS
NTAPI
ClockPropertyState(
    IN PIRP Irp,
    IN PKSIDENTIFIER Request,
    IN OUT PVOID Data)
{
    PKSICLOCK Clock;
    PKSIOBJECT_HEADER ObjectHeader;
    PKSSTATE State = (PKSSTATE)Data;
    PIO_STACK_LOCATION IoStack;
 
    DPRINT("ClockPropertyState\n");
 
    /* get stack location */
    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    /* get the object header */
    ObjectHeader = (PKSIOBJECT_HEADER)IoStack->FileObject->FsContext2;
 
    /* sanity check */
    ASSERT(ObjectHeader);
 
    /* locate ks pin implementation from KSPIN offset */
    Clock = (PKSICLOCK)ObjectHeader->ObjectType;
 
    *State = Clock->DefaultClock->State;
    Irp->IoStatus.Information = sizeof(KSSTATE);
 
    return STATUS_SUCCESS;
}
 
NTSTATUS
NTAPI
ClockPropertyFunctionTable(
    IN PIRP Irp,
    IN PKSIDENTIFIER Request,
    IN OUT PVOID Data)
{
    PKSCLOCK_FUNCTIONTABLE Table = (PKSCLOCK_FUNCTIONTABLE)Data;
 
    DPRINT("ClockPropertyFunctionTable\n");
 
    Table->GetCorrelatedPhysicalTime = ClockGetCorrelatedPhysicalTime;
    Table->GetCorrelatedTime = ClockGetCorrelatedTime;
    Table->GetPhysicalTime = ClockGetPhysicalTime;
    Table->GetTime = ClockGetTime;
 
    return STATUS_SUCCESS;
}
 
 
/*
    @implemented
*/
KSDDKAPI NTSTATUS NTAPI
KsCreateClock(
    IN  HANDLE ConnectionHandle,
    IN  PKSCLOCK_CREATE ClockCreate,
    OUT PHANDLE ClockHandle)
{
    return KspCreateObjectType(ConnectionHandle,
                               KSSTRING_Clock,
                               ClockCreate,
                               sizeof(KSCLOCK_CREATE),
                               GENERIC_READ,
                               ClockHandle);
}
 
/*
    @implemented
*/
KSDDKAPI
NTSTATUS
NTAPI
KsValidateClockCreateRequest(
    IN  PIRP Irp,
    OUT PKSCLOCK_CREATE* OutClockCreate)
{
    PKSCLOCK_CREATE ClockCreate;
    NTSTATUS Status;
    ULONG Size;
 
    /* minimum request size */
    Size = sizeof(KSCLOCK_CREATE);
 
    /* copy create request */
    Status = KspCopyCreateRequest(Irp,
                                  KSSTRING_Clock,
                                  &Size,
                                  (PVOID*)&ClockCreate);
 
    if (!NT_SUCCESS(Status))
        return Status;
 
    if (ClockCreate->CreateFlags != 0)
    {
        /* flags must be zero */
        FreeItem(ClockCreate);
        return STATUS_INVALID_PARAMETER;
    }
 
    *OutClockCreate = ClockCreate;
    return STATUS_SUCCESS;
}
 
NTSTATUS
NTAPI
IKsClock_DispatchDeviceIoControl(
    IN PDEVICE_OBJECT DeviceObject,
    IN  PIRP Irp)
{
    PIO_STACK_LOCATION IoStack;
    UNICODE_STRING GuidString;
    PKSPROPERTY Property;
    NTSTATUS Status;
 
    DPRINT("IKsClock_DispatchDeviceIoControl\n");
 
    /* get current io stack */
    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    /* FIXME support events */
    ASSERT(IoStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_KS_PROPERTY);
 
    /* sanity check */
    ASSERT(IoStack->Parameters.DeviceIoControl.InputBufferLength >= sizeof(KSPROPERTY));
 
    /* call property handler */
    Status = KsPropertyHandler(Irp, 1, ClockPropertySet);
 
    /* get property from input buffer */
    Property = (PKSPROPERTY)IoStack->Parameters.DeviceIoControl.Type3InputBuffer;
 
    RtlStringFromGUID(&Property->Set, &GuidString);
    DPRINT("IKsClock_DispatchDeviceIoControl property Set |%S| Id %u Flags %x Status %lx ResultLength %lu\n", GuidString.Buffer, Property->Id, Property->Flags, Status, Irp->IoStatus.Information);
    RtlFreeUnicodeString(&GuidString);
 
 
    Irp->IoStatus.Status = STATUS_SUCCESS;
    CompleteRequest(Irp, IO_NO_INCREMENT);
 
    return STATUS_SUCCESS;
}
 
NTSTATUS
NTAPI
IKsClock_DispatchClose(
    IN PDEVICE_OBJECT DeviceObject,
    IN  PIRP Irp)
{
    UNIMPLEMENTED;
 
    Irp->IoStatus.Status = STATUS_SUCCESS;
    CompleteRequest(Irp, IO_NO_INCREMENT);
 
    return STATUS_SUCCESS;
}
 
static KSDISPATCH_TABLE DispatchTable =
{
    IKsClock_DispatchDeviceIoControl,
    KsDispatchInvalidDeviceRequest,
    KsDispatchInvalidDeviceRequest,
    KsDispatchInvalidDeviceRequest,
    IKsClock_DispatchClose,
    KsDispatchQuerySecurity,
    KsDispatchSetSecurity,
    KsDispatchFastIoDeviceControlFailure,
    KsDispatchFastReadFailure,
    KsDispatchFastReadFailure,
};
 
/*
    @implemented
*/
KSDDKAPI
NTSTATUS
NTAPI
KsCreateDefaultClock(
    IN  PIRP Irp,
    IN  PKSDEFAULTCLOCK DefaultClock)
{
    NTSTATUS Status;
    PKSCLOCK_CREATE ClockCreate;
    PKSICLOCK Clock;
 
    Status = KsValidateClockCreateRequest(Irp, &ClockCreate);
    if (!NT_SUCCESS(Status))
        return Status;
 
    /* let's allocate the clock struct */
    Clock = AllocateItem(NonPagedPool, sizeof(KSICLOCK));
    if (!Clock)
    {
        FreeItem(ClockCreate);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* now allocate the object header */
    Status = KsAllocateObjectHeader((PVOID*)&Clock->ObjectHeader, 0, NULL, Irp, &DispatchTable);
 
    /* did it work */
    if (!NT_SUCCESS(Status))
    {
        /* failed */
        FreeItem(ClockCreate);
        FreeItem(Clock);
        return Status;
    }
 
    /* initialize clock */
    /* FIXME IKsClock */
    Clock->ObjectHeader->ObjectType = (PVOID)Clock;
    Clock->ref = 1;
    Clock->ClockCreate = ClockCreate;
    Clock->DefaultClock = (PKSIDEFAULTCLOCK)DefaultClock;
 
    /* increment reference count */
    InterlockedIncrement(&Clock->DefaultClock->ReferenceCount);
 
    return Status;
}
 
/*
    @implemented
*/
KSDDKAPI
NTSTATUS
NTAPI
KsAllocateDefaultClock(
    OUT PKSDEFAULTCLOCK* DefaultClock)
{
    return KsAllocateDefaultClockEx(DefaultClock, NULL, NULL, NULL, NULL, NULL, 0);
}
 
/*
    @unimplemented
*/
KSDDKAPI
NTSTATUS
NTAPI
KsAllocateDefaultClockEx(
    OUT PKSDEFAULTCLOCK* DefaultClock,
    IN  PVOID Context OPTIONAL,
    IN  PFNKSSETTIMER SetTimer OPTIONAL,
    IN  PFNKSCANCELTIMER CancelTimer OPTIONAL,
    IN  PFNKSCORRELATEDTIME CorrelatedTime OPTIONAL,
    IN  const KSRESOLUTION* Resolution OPTIONAL,
    IN  ULONG Flags)
{
    PKSIDEFAULTCLOCK Clock;
 
    if (!DefaultClock)
       return STATUS_INVALID_PARAMETER_1;
 
    /* allocate default clock */
    Clock = AllocateItem(NonPagedPool, sizeof(KSIDEFAULTCLOCK));
    if (!Clock)
        return STATUS_INSUFFICIENT_RESOURCES;
 
    /* initialize default clock */
    KeInitializeSpinLock(&Clock->TimeLock);
    KeInitializeTimer(&Clock->Timer);
    Clock->ReferenceCount = 1;
    Clock->Context = Context;
    Clock->SetTimer = SetTimer;
    Clock->CancelTimer = CancelTimer;
    Clock->CorrelatedTime = CorrelatedTime;
    Clock->Flags = Flags;
 
    if (Resolution)
    {
        if (SetTimer)
        {
            Clock->Error = Resolution->Error;
        }
 
        if (CorrelatedTime)
        {
            Clock->Granularity = Resolution->Granularity;
        }
    }
 
    *DefaultClock = (PKSDEFAULTCLOCK)Clock;
    return STATUS_SUCCESS;
}
 
/*
    @implemented
*/
KSDDKAPI
VOID
NTAPI
KsFreeDefaultClock(
    IN  PKSDEFAULTCLOCK DefaultClock)
{
    PKSIDEFAULTCLOCK Clock = (PKSIDEFAULTCLOCK)DefaultClock;
 
    InterlockedDecrement(&Clock->ReferenceCount);
 
    if (Clock->ReferenceCount == 0)
    {
        /* free default clock */
        FreeItem(Clock);
    }
}
 
/*
    @implemented
*/
KSDDKAPI
KSSTATE
NTAPI
KsGetDefaultClockState(
    IN  PKSDEFAULTCLOCK DefaultClock)
{
    PKSIDEFAULTCLOCK Clock = (PKSIDEFAULTCLOCK)DefaultClock;
    return Clock->State;
}
 
/*
    @unimplemented
*/
KSDDKAPI
VOID
NTAPI
KsSetDefaultClockState(
    IN  PKSDEFAULTCLOCK DefaultClock,
    IN  KSSTATE State)
{
    PKSIDEFAULTCLOCK Clock = (PKSIDEFAULTCLOCK)DefaultClock;
 
    if (State != Clock->State)
    {
         /* FIXME set time etc */
         Clock->State = State;
    }
 
}
 
/*
    @implemented
*/
KSDDKAPI
LONGLONG
NTAPI
KsGetDefaultClockTime(
    IN  PKSDEFAULTCLOCK DefaultClock)
{
    LONGLONG Time = 0LL;
    PKSIDEFAULTCLOCK Clock = (PKSIDEFAULTCLOCK)DefaultClock;
 
    Time = ExInterlockedCompareExchange64(&Clock->Time, &Time, &Time, &Clock->TimeLock);
 
    return Time;
}
 
/*
    @implemented
*/
KSDDKAPI
VOID
NTAPI
KsSetDefaultClockTime(
    IN  PKSDEFAULTCLOCK DefaultClock,
    IN  LONGLONG Time)
{
    PKSIDEFAULTCLOCK Clock = (PKSIDEFAULTCLOCK)DefaultClock;
 
    /* set the time safely */
    ExInterlockedCompareExchange64(&Clock->Time, &Time, &Clock->Time, &Clock->TimeLock);
}