windows-xp/Source/XPSP1/NT/net/qos/psched/sys/config.c

/*++

Copyright (c) 1998-1999  Microsoft Corporation

Module Name:

    config.c

Abstract:

    This file contains all routines necessary for the support of dynamic
    configuration.

Author:

    Rajesh Sundaram (rajeshsu)

Environment:

    Kernel Mode

Revision History:

--*/

#include "psched.h"
#pragma hdrstop

//
// Forward declaration for using #pragma

NDIS_STATUS
PsReadAdapterRegistryDataInit(PADAPTER     Adapter,
                              PNDIS_STRING AdapterKey
                              );

NDIS_STATUS
PsReadAdapterRegistryData(PADAPTER     Adapter,
                         PNDIS_STRING MachineKey,
                         PNDIS_STRING AdapterKey);


#pragma alloc_text(PAGE, PsReadAdapterRegistryData)
#pragma alloc_text(PAGE, PsReadAdapterRegistryDataInit)


//
// Local functions used to access the registry.
//

NDIS_STATUS 
PsReadRegistryInt(
    IN NDIS_HANDLE  ConfigHandle,
    IN PNDIS_STRING ValueName,
    IN ULONG        ValueDefault,
    IN OUT PULONG   ValuePtr,
    IN ULONG        ValueMin,
    IN ULONG        ValueMax,
    IN BOOLEAN      Subkey,
    IN PNDIS_STRING SubKeyName,
    IN HANDLE       SubKeyHandle,
    IN BOOLEAN      ZAW
)
{
    PNDIS_CONFIGURATION_PARAMETER ConfigParam;
    NDIS_STATUS                   Status;
    NTSTATUS                      NtStatus;
    ULONG                         Value;

    RTL_QUERY_REGISTRY_TABLE ServiceKeys[] = 
    {
        {NULL,
         0,
         NULL,
         NULL,
         0,
         NULL,
         0},

        {NULL,
         0,
         NULL,
         NULL,
         0,
         NULL,
         0},
        
        {NULL,
         0,
         NULL,
         NULL,
         0,
         NULL,
         0}
    };

    if(Subkey)
    {
        PsDbgOut(DBG_INFO, DBG_INIT | DBG_ZAW,
                 ("[PsReadSingleParameter]: Subkey %ws, Key %ws \n", 
                  SubKeyName->Buffer, ValueName->Buffer));

        NdisReadConfiguration(&Status,
                              &ConfigParam,
                              SubKeyHandle,
                              ValueName,
                              NdisParameterInteger);
    }
    else 
    {
        PsDbgOut(DBG_INFO, DBG_INIT | DBG_ZAW,
                 ("[PsReadSingleParameter]: Subkey NULL, Key %ws \n", ValueName->Buffer));

        NdisReadConfiguration(&Status,
                              &ConfigParam,
                              ConfigHandle,
                              ValueName,
                              NdisParameterInteger);

    }

    if(Status == NDIS_STATUS_SUCCESS)
    {
        *ValuePtr = ConfigParam->ParameterData.IntegerData;

        if(*ValuePtr < ValueMin || *ValuePtr > ValueMax)
        {
            PsDbgOut(DBG_FAILURE, DBG_INIT | DBG_ZAW,
                     ("[PsReadSingleParameter]: Per adapter:  %d does not fall in range (%d - %d) \n",
                      *ValuePtr, ValueMin, ValueMax));

            *ValuePtr = ValueDefault;
        }

        PsDbgOut(DBG_INFO, DBG_INIT | DBG_ZAW,
                 ("\t\t Per adapter: 0x%x \n", *ValuePtr));

        return Status;
    }
    else 
    {
        if(ZAW)
        {
            //
            // See if we can read it from the per machine area. We need to use the RtlAPIs for this.
            //
            if(Subkey)
            {
                ServiceKeys[0].QueryRoutine  = NULL;
                ServiceKeys[0].Flags         = RTL_QUERY_REGISTRY_SUBKEY;
                ServiceKeys[0].Name          = SubKeyName->Buffer;
                ServiceKeys[0].EntryContext  = NULL;
                ServiceKeys[0].DefaultType   = REG_NONE;
                ServiceKeys[0].DefaultData   = NULL;
                ServiceKeys[0].DefaultLength = 0;
                
                ServiceKeys[1].QueryRoutine  = NULL;
                ServiceKeys[1].Flags         = RTL_QUERY_REGISTRY_DIRECT | RTL_QUERY_REGISTRY_REQUIRED;
                ServiceKeys[1].Name          = ValueName->Buffer;
                ServiceKeys[1].EntryContext  = &Value;
                ServiceKeys[1].DefaultType   = REG_NONE;
                ServiceKeys[1].DefaultData   = NULL;
                ServiceKeys[1].DefaultLength = 0;
            }
            else 
            {
                ServiceKeys[0].QueryRoutine  = NULL;
                ServiceKeys[0].Flags         = RTL_QUERY_REGISTRY_DIRECT | RTL_QUERY_REGISTRY_REQUIRED;
                ServiceKeys[0].Name          = ValueName->Buffer;
                ServiceKeys[0].EntryContext  = &Value;
                ServiceKeys[0].DefaultType   = REG_NONE;
                ServiceKeys[0].DefaultData   = NULL;
                ServiceKeys[0].DefaultLength = 0;
            }
            
            
            NtStatus = RtlQueryRegistryValues(
                RTL_REGISTRY_ABSOLUTE,
                MachineRegistryKey.Buffer,
                ServiceKeys,
                NULL,
                NULL);
            
            if(NT_SUCCESS(NtStatus))
            {
                *ValuePtr = Value;
                
                if(*ValuePtr < ValueMin || *ValuePtr > ValueMax)
                {
                    PsDbgOut(DBG_FAILURE, DBG_INIT | DBG_ZAW,
                             ("[PsReadSingleParameter]: ZAW %ws %d does not fall in range (%d - %d) \n",
                              ValueName->Buffer, *ValuePtr, ValueMin, ValueMax));

                    *ValuePtr = ValueDefault;
                }
                
                PsDbgOut(DBG_INFO, DBG_INIT | DBG_ZAW, ("\t\tZAW 0x%x \n", *ValuePtr));

                return NDIS_STATUS_SUCCESS;
            }
            else
            {
                *ValuePtr = ValueDefault;
                PsDbgOut(DBG_INFO, DBG_INIT | DBG_ZAW, 
                         ("\t\tNot in ZAW/Adapter, Using default %d \n", *ValuePtr));

                return NtStatus;
            }
        }
        else 
        {
            *ValuePtr = ValueDefault;
            PsDbgOut(DBG_INFO, DBG_INIT | DBG_ZAW, 
                     ("\t\tNot in ZAW/Adapter, Using default %d \n", *ValuePtr));

            return Status;

        }
    }
}


NTSTATUS
PsReadRegistryString(IN NDIS_HANDLE  ConfigHandle,
             IN PNDIS_STRING Key,
             IN PNDIS_STRING Buffer
             )
{
    NDIS_STATUS                   Status;
    PNDIS_CONFIGURATION_PARAMETER ConfigParam;
    
    NdisReadConfiguration(&Status,
                          &ConfigParam,
                          ConfigHandle,
                          Key,
                          NdisParameterMultiString);

    if(Status == NDIS_STATUS_SUCCESS)
    {
        Buffer->Length        = ConfigParam->ParameterData.StringData.Length;
        Buffer->MaximumLength = Buffer->Length + sizeof(WCHAR);

        PsAllocatePool(Buffer->Buffer,
                       Buffer->MaximumLength,
                       PsMiscTag);

        if(Buffer->Buffer)
        {
            RtlCopyUnicodeString(Buffer, &ConfigParam->ParameterData.StringData);
        }

    }

    return Status;
}


STATIC VOID
ReadProfiles(
    NDIS_HANDLE                   ConfigHandle
    )
/*++

Routine Description:
    This routine is used by the driver to read the Profiles key from the
    registry. The profile is a multiple string list of available profiles.
    Each entry on this list identifies another value under Psched\Parameters
    which contains the list of modules that comprise the profile.

Arguments:
    ConfigHandle - Handle to the registry entry

Return Value:
--*/
{
    NDIS_STATUS                   Status;
    PNDIS_CONFIGURATION_PARAMETER pConfigParam;
    PNDIS_CONFIGURATION_PARAMETER pProfileParam;
    PPS_PROFILE                   pProfileInfo;
    PWSTR                         r, p;
    UINT                          i, j, cnt;
    NDIS_STRING                   ProfileKey = NDIS_STRING_CONST("Profiles");
    NDIS_STRING                   StringName;
    BOOLEAN                       StubFlag;
    NDIS_STRING                   StubComponent = NDIS_STRING_CONST("SchedulerStub");

    NdisReadConfiguration( &Status,
                           &pConfigParam,
                           ConfigHandle,
                           &ProfileKey,
                           NdisParameterMultiString);

    if ( NT_SUCCESS( Status ))
    {
        //
        // pConfigParam now contains a list of profiles.
        //
        for (p = pConfigParam->ParameterData.StringData.Buffer, i = 0;
             *p != L'\0';
             i++)
        {

            //
            // Allocate a new PS_PROFILE entry and store it into
            // a global list.
            //

            PsAllocatePool(pProfileInfo, sizeof(PS_PROFILE), ProfileTag);

            if(!pProfileInfo)
            {
                //
                // Don't have to worry about freeing the previous profiles as they will get freed
                // when we clear the PsProfileList.
                //

                PsDbgOut(DBG_CRITICAL_ERROR, DBG_INIT,
                         ("[ReadProfiles]: cannot allocate memory to hold profile \n"));

                break;
            }

            NdisZeroMemory(pProfileInfo, sizeof(PS_PROFILE));
            InsertHeadList( &PsProfileList, &pProfileInfo->Links );

            // Copy the Profile Name
            // 1. Initialize the unicode strings
            // 2. Allocate memory for the string
            // 3. Copy the string over.

            RtlInitUnicodeString(&StringName, p);
            RtlInitUnicodeString(&pProfileInfo->ProfileName, p);
            PsAllocatePool(pProfileInfo->ProfileName.Buffer,
                           pProfileInfo->ProfileName.MaximumLength,
                           ProfileTag);

            if(!pProfileInfo->ProfileName.Buffer)
            {
                //
                // Again, cleanup of the other profils will be done when we clean up the ProfileList
                //

                PsDbgOut(DBG_CRITICAL_ERROR, DBG_INIT,
                         ("[ReadProfiles]: cannot allocate memory to hold profile's name \n"));

                break;
            }

            NdisZeroMemory(pProfileInfo->ProfileName.Buffer,
                           pProfileInfo->ProfileName.MaximumLength);
            RtlCopyUnicodeString(&pProfileInfo->ProfileName, &StringName);


            PsDbgOut(DBG_TRACE,
                     DBG_INIT,
                     ("[ReadProfiles]: Adding profile %ws \n",
                      pProfileInfo->ProfileName.Buffer));

            // The last scheduling component of every profile should
            // be a stub component. If this component is not present
            // in the profile, we have to add it manually.

            StubFlag = FALSE;
            cnt = 0;

            //
            // Each of the name identifies another value under
            // "Psched\Parameters". This value contains the list of
            // components that comprize the profile.
            //

            NdisReadConfiguration( &Status,
                                   &pProfileParam,
                                   ConfigHandle,
                                   &pProfileInfo->ProfileName,
                                   NdisParameterMultiString);
            if(NT_SUCCESS (Status))
            {
                // Read the components and associate with a
                // PSI_INFO.

                NDIS_STRING ComponentName;
                for (r = pProfileParam->ParameterData.StringData.Buffer, j=0;
                     *r != L'\0'; j++)
                {
                    PSI_INFO *PsiComponentInfo = 0;
                    RtlInitUnicodeString(&ComponentName, r);
                    PsDbgOut(DBG_TRACE, DBG_INIT,
                             ("[ReadProfiles]: Adding component %ws to "
                              "Profile %ws \n",
                              ComponentName.Buffer,
                              pProfileInfo->ProfileName.Buffer));

                    if(!StubFlag && (RtlCompareUnicodeString(&ComponentName,
                                                            &StubComponent,
                                                            FALSE)== 0))
                        StubFlag = TRUE;

                    if(cnt == MAX_COMPONENT_PER_PROFILE)
                    {
                        PsDbgOut(DBG_CRITICAL_ERROR,
                                 DBG_INIT,
                                 ("[ReadProfiles]: Profile %ws cannot have "
                                  "more than %d components \n",
                                  pProfileInfo->ProfileName.Buffer,
                                  MAX_COMPONENT_PER_PROFILE));
                    }
                    else
                    {
                        if(FindSchedulingComponent(&ComponentName, &PsiComponentInfo) ==
                           NDIS_STATUS_FAILURE)
                        {
                            //
                            // The component does not exist. Therefore, we
                            // store the unregistered component in the list
                            //

                            PsDbgOut(DBG_TRACE, DBG_INIT,
                                     ("[ReadProfiles]: Adding add-in component"
                                      " %ws to list\n", ComponentName.Buffer));

                            PsAllocatePool(PsiComponentInfo,
                                           sizeof(PSI_INFO),
                                           ComponentTag);

                            if(!PsiComponentInfo)
                            {
                                PsDbgOut(DBG_CRITICAL_ERROR, DBG_INIT,
                                         ("[ReadProfiles]: No memory to store add-in components \n"));

                                break;

                            }

                            pProfileInfo->UnregisteredAddInCnt ++;

                            NdisZeroMemory(PsiComponentInfo, sizeof(PSI_INFO));

                            RtlInitUnicodeString(&PsiComponentInfo->ComponentName, r);

                            PsAllocatePool(
                                PsiComponentInfo->ComponentName.Buffer,
                                ComponentName.MaximumLength,
                                ComponentTag);

                            if(!PsiComponentInfo->ComponentName.Buffer)
                            {
                                PsDbgOut(DBG_CRITICAL_ERROR, DBG_INIT,
                                         ("[ReadProfiles]: No memory to store add-in components \n"));

                                PsFreePool(PsiComponentInfo);

                                break;
                            }

                            RtlCopyUnicodeString(&PsiComponentInfo->ComponentName,
                                                 &ComponentName);

                            PsiComponentInfo->Registered = FALSE;

                            PsiComponentInfo->AddIn = TRUE;

                            InsertHeadList(&PsComponentList, &PsiComponentInfo->Links );
                        }

                        // Add the component to the profile.
                        pProfileInfo->ComponentList[cnt++]=PsiComponentInfo;

                        pProfileInfo->ComponentCnt = cnt;
                    }
                    r = (PWSTR)((PUCHAR)r + ComponentName.Length +
                                sizeof(WCHAR));
                }
            }

            if(!StubFlag)
            {
                PsDbgOut(DBG_INFO, DBG_INIT,
                         ("[ReadProfiles]: Profile %ws should end in a stub "
                          "component. Adding a stub component \n",
                          pProfileInfo->ProfileName.Buffer));

                // Needn't worry about overflow, as we have allocated an
                // extra one for the stub component.

                pProfileInfo->ComponentList[cnt++] = &SchedulerStubInfo;
                pProfileInfo->ComponentCnt = cnt;
            }
            p = (PWSTR)((PUCHAR)p + pProfileInfo->ProfileName.Length
                        + sizeof(WCHAR));
        }
    }
}


NDIS_STATUS
PsReadDriverRegistryDataInit (
    )
/*++

Routine Description:

    This routine is called by the driver to get information from the configuration
    management routines. We read the registry, starting at RegistryPath,
    to get the parameters. If they don't exist, we use the defaults in this module.

Arguments:

    RegistryPath - The name of the driver's node in the registry.

    ConfigurationInfo - A pointer to the configuration information structure.

Return Value:

    Status - STATUS_SUCCESS if everything OK, STATUS_INSUFFICIENT_RESOURCES
            otherwise.

--*/
{
    NDIS_HANDLE  ConfigHandle;
    NDIS_STATUS  Status;
    NDIS_STRING  PSParamsKey        = NDIS_STRING_CONST("PSched\\Parameters");
#if DBG
    ULONG        Size;
    NTSTATUS     NtStatus;

    NDIS_STRING DebugLevelKey       = NDIS_STRING_CONST("DebugLevel");
    NDIS_STRING DebugMaskKey        = NDIS_STRING_CONST("DebugMask");
    NDIS_STRING TraceLogLevelKey    = NDIS_STRING_CONST("TraceLogLevel");
    NDIS_STRING TraceLogMaskKey     = NDIS_STRING_CONST("TraceLogMask");
    NDIS_STRING TraceBufferSizeKey  = NDIS_STRING_CONST("TraceBufferSize");
#endif

    NdisOpenProtocolConfiguration(&Status, &ConfigHandle, &PSParamsKey);

    if(!NT_SUCCESS(Status))
    {
        PsDbgOut(DBG_CRITICAL_ERROR, DBG_INIT,
                 ("[PsReadDriverRegistryDataInit]: cannot read registry \n"));

        return Status;
    }

#if DBG

    PsReadRegistryInt(
        ConfigHandle,
        &DebugLevelKey,
        0,
        &DbgTraceLevel,
        0,
        0xffffffff,
        FALSE,
        NULL,
        NULL,
        FALSE);

    PsReadRegistryInt(
        ConfigHandle,
        &DebugMaskKey,
        0,
        &DbgTraceMask,
        0,
        0xffffffff,
        FALSE,
        NULL,
        NULL,
        FALSE);

    PsReadRegistryInt(
        ConfigHandle,
        &TraceLogLevelKey,
        DBG_VERBOSE,
        &LogTraceLevel,
        0,
        0xffffffff,
        FALSE,
        NULL,
        NULL,
        FALSE);

    PsReadRegistryInt(
        ConfigHandle,
        &TraceLogMaskKey,
        (DBG_INIT  |  DBG_IO  |  DBG_GPC_QOS  | DBG_MINIPORT | DBG_PROTOCOL | 
         DBG_VC    |  DBG_WMI |  DBG_STATE    | DBG_WAN),
        &LogTraceMask,
        0,
        0xffffffff,
        FALSE,
        NULL,
        NULL,
        FALSE);

    PsReadRegistryInt(
        ConfigHandle,
        &TraceBufferSizeKey,
        TRACE_BUFFER_SIZE,
        &Size,
        0,
        0xffffffff,
        FALSE,
        NULL,
        NULL,
        FALSE);

    SchedInitialize(Size);
#endif

    ReadProfiles(ConfigHandle);

    NdisCloseConfiguration( ConfigHandle );

    return STATUS_SUCCESS;
}


NDIS_STATUS
PsReadDriverRegistryData(
    )
{
    ULONG                  TimerResolution;
    ULONG                  desiredResolution;
    NDIS_STRING            PSParamsKey        = NDIS_STRING_CONST("PSched\\Parameters");
    NDIS_STRING            TimerResolutionKey = NDIS_STRING_CONST("TimerResolution");
    NTSTATUS               NtStatus;
    NDIS_HANDLE            ConfigHandle;
    NDIS_STATUS            Status;

    NdisOpenProtocolConfiguration(&Status, &ConfigHandle, &PSParamsKey);

    if(!NT_SUCCESS(Status))
    {
        PsDbgOut(DBG_CRITICAL_ERROR, DBG_INIT,
                 ("[PsReadDriverRegistryData]: cannot read registry \n"));

        return Status;
    }

    NtStatus = PsReadRegistryInt(
        ConfigHandle,
        &TimerResolutionKey,
        TIMER_GRANULARITY,
        &TimerResolution,
        0,
        0xffffffff,
        FALSE,
        NULL,
        NULL,
        TRUE);

    NdisCloseConfiguration(ConfigHandle);

    if(NT_SUCCESS(NtStatus))
    {
        //
        // convert from usecs to 100 nsecs
        //
        TimerResolution *= 10;
       
        if(gTimerSet)
        {
            //
            // We might have to cancel the old timer.
            //

            if(gTimerResolutionActualTime < TimerResolution)
            {
                // 
                // We are moving from a low timer to a high timer. We should always set the high 
                // timer before resetting the low one.
                //
                gTimerResolutionActualTime = ExSetTimerResolution(TimerResolution, TRUE);

                ExSetTimerResolution(0, FALSE);
            }
            else 
            {
                // 
                // Moving from a high timer to a low timer. Let's cancel the high timer first
                //
                ExSetTimerResolution(0, FALSE);

                gTimerResolutionActualTime = ExSetTimerResolution(TimerResolution, TRUE);
            }
        }
        else
        {
            // The Timer has never been set before.

            gTimerResolutionActualTime = ExSetTimerResolution(TimerResolution, TRUE);
            
            gTimerSet = 1;

        }
                
    }
    else 
    {
        // No value was specified in the registry. Let's just keep it at the system's default.
        // But, we need to query this value so that we can respond correctly to OID_QOS_TIMER_RESOLUTION
        //
        if(gTimerSet)
        {
            //
            // Timer was set initially, but now it has been blown away. So, let's get back to the 
            // system default.
            //
            gTimerSet = 0;

            gTimerResolutionActualTime = ExSetTimerResolution(0, FALSE);
        }
        else 
        {
            //
            // Timer has never been set. Let's remember the system defaults.
            //

            gTimerResolutionActualTime = KeQueryTimeIncrement();
        }

    }

    return STATUS_SUCCESS;
}


NDIS_STATUS
PsReadAdapterRegistryDataInit(PADAPTER     Adapter,
                              PNDIS_STRING AdapterKey
                              )
{
    ULONG       DisableDRR, IntermediateSystem;
    NTSTATUS    NtStatus;
    NDIS_HANDLE ConfigHandle, ServiceKeyHandle;
    NDIS_STRING DisableDRRKey          = NDIS_STRING_CONST("DisableDRR");
    NDIS_STRING IntermediateSystemKey  = NDIS_STRING_CONST("IntermediateSystem");
    NDIS_STRING BestEffortLimitKey     = NDIS_STRING_CONST("BestEffortLimit");
    NDIS_STRING ISSLOWTokenRateKey     = NDIS_STRING_CONST("ISSLOWTokenRate");
    NDIS_STRING ISSLOWPacketSizeKey    = NDIS_STRING_CONST("ISSLOWPacketSize");
    NDIS_STRING ISSLOWLinkSpeedKey     = NDIS_STRING_CONST("ISSLOWLinkSpeed");
    NDIS_STRING ISSLOWFragmentSizeKey  = NDIS_STRING_CONST("ISSLOWFragmentSize");
    NDIS_STRING BestEffortKey          = NDIS_STRING_CONST("ServiceTypeBestEffort");
    NDIS_STRING NonConformingKey       = NDIS_STRING_CONST("ServiceTypeNonConforming");
    NDIS_STRING ControlledLoadKey      = NDIS_STRING_CONST("ServiceTypeControlledLoad");
    NDIS_STRING GuaranteedKey          = NDIS_STRING_CONST("ServiceTypeGuaranteed");
    NDIS_STRING QualitativeKey         = NDIS_STRING_CONST("ServiceTypeQualitative");
    NDIS_STRING NetworkControlKey      = NDIS_STRING_CONST("ServiceTypeNetworkControl");
    NDIS_STRING ShapeDiscardModeKey    = NDIS_STRING_CONST("ShapeDiscardMode");
    NDIS_STRING UpperBindingsKey       = NDIS_STRING_CONST("UpperBindings");
    NDIS_STRING ProfileKey             = NDIS_STRING_CONST("Profile");
    NDIS_STATUS Status;

    PAGED_CODE();

    NdisOpenProtocolConfiguration(&Status, &ConfigHandle, AdapterKey);

    if(Status != NDIS_STATUS_SUCCESS)
    {
        PsDbgOut(DBG_FAILURE, DBG_INIT ,
                 ("[PsReadAdapterRegistryDataInit]: Adapter %08X, Could not open config handle \n", 
                  Adapter));

        return Status;
    }


    PsReadRegistryString(
        ConfigHandle,
        &UpperBindingsKey,
        &Adapter->UpperBinding);

    if(!Adapter->UpperBinding.Buffer)
    {
        PsAdapterWriteEventLog(
            (ULONG)EVENT_PS_MISSING_ADAPTER_REGISTRY_DATA,
            0,
            &Adapter->MpDeviceName,
            0,
            NULL);
        
        PsDbgOut(DBG_FAILURE, DBG_PROTOCOL | DBG_INIT,
                 ("[PsReadAdapterRegistryDataInit]: Adapter %08X: Missing UpperBindings key ", Adapter));

        NdisCloseConfiguration(ConfigHandle);
        
        return  NDIS_STATUS_FAILURE;
    }

    PsReadRegistryString(
        ConfigHandle,
        &ProfileKey,
        &Adapter->ProfileName);


    PsReadRegistryInt(
        ConfigHandle,
        &DisableDRRKey,
        0,
        &DisableDRR,
        0,
        0xffffffff,
        FALSE,
        NULL, 
        NULL,
        FALSE);

    PsReadRegistryInt(
        ConfigHandle,
        &IntermediateSystemKey,
        0,
        &IntermediateSystem,
        0,
        0xffffffff,
        FALSE,
        NULL, 
        NULL,
        FALSE);

    PsReadRegistryInt(
        ConfigHandle,
        &BestEffortLimitKey,
        UNSPECIFIED_RATE,
        &Adapter->BestEffortLimit,
        0,
        0xffffffff,
        FALSE,
        NULL, 
        NULL,
        FALSE);

    //
    // Read the ISSLOW related parameters.
    //

    PsReadRegistryInt(
        ConfigHandle,
        &ISSLOWFragmentSizeKey,
        DEFAULT_ISSLOW_FRAGMENT_SIZE,
        &Adapter->ISSLOWFragmentSize,
        0,
        0xffffffff,
        FALSE,
        NULL, 
        NULL,
        FALSE);

    PsReadRegistryInt(
        ConfigHandle,
        &ISSLOWTokenRateKey,
        DEFAULT_ISSLOW_TOKENRATE,
        &Adapter->ISSLOWTokenRate,
        0,
        0xffffffff,
        FALSE,
        NULL, 
        NULL,
        FALSE);

    PsReadRegistryInt(
        ConfigHandle,
        &ISSLOWPacketSizeKey,
        DEFAULT_ISSLOW_PACKETSIZE,
        &Adapter->ISSLOWPacketSize,
        0,
        0xffffffff,
        FALSE,
        NULL, 
        NULL,
        FALSE);

    PsReadRegistryInt(
        ConfigHandle,
        &ISSLOWLinkSpeedKey,
        DEFAULT_ISSLOW_LINKSPEED,
        &Adapter->ISSLOWLinkSpeed,
        0,
        0xffffffff,
        FALSE,
        NULL, 
        NULL,
        FALSE);

    //
    // Read the ShapeDiscardMode for the service types.
    //

    NdisOpenConfigurationKeyByName(&Status,
                                   ConfigHandle,
                                   &ShapeDiscardModeKey,
                                   &ServiceKeyHandle);

    if(!NT_SUCCESS(Status))
    {
        PsDbgOut(DBG_FAILURE, DBG_PROTOCOL | DBG_INIT,
                 ("[PsReadAdapterRegistryDataInit]: Adapter %08X, Using defaults for ShapeDiscardMode"
                  "since key cannot be opened \n", Adapter));

        Adapter->SDModeGuaranteed      = TC_NONCONF_SHAPE;
        Adapter->SDModeControlledLoad  = TC_NONCONF_BORROW;
        Adapter->SDModeQualitative     = TC_NONCONF_BORROW;
        Adapter->SDModeNetworkControl  = TC_NONCONF_BORROW;

    }
    else 
    {

        PsReadRegistryInt(
            ConfigHandle,
            &GuaranteedKey,
            TC_NONCONF_SHAPE,
            &Adapter->SDModeGuaranteed,
            TC_NONCONF_BORROW,
            TC_NONCONF_BORROW_PLUS,
            TRUE,
            &ShapeDiscardModeKey, 
            ServiceKeyHandle,
            FALSE);
    
        PsReadRegistryInt(
            ConfigHandle,
            &ControlledLoadKey,
            TC_NONCONF_BORROW,
            &Adapter->SDModeControlledLoad,
            TC_NONCONF_BORROW,
            TC_NONCONF_BORROW_PLUS,
            TRUE,
            &ShapeDiscardModeKey, 
            ServiceKeyHandle,
            FALSE);
    
        PsReadRegistryInt(
            ConfigHandle,
            &QualitativeKey,
            TC_NONCONF_BORROW,
            &Adapter->SDModeQualitative,
            TC_NONCONF_BORROW,
            TC_NONCONF_BORROW_PLUS,
            TRUE,
            &ShapeDiscardModeKey, 
            ServiceKeyHandle,
            FALSE);

        PsReadRegistryInt(
            ConfigHandle,
            &NetworkControlKey,
            TC_NONCONF_BORROW,
            &Adapter->SDModeNetworkControl,
            TC_NONCONF_BORROW,
            TC_NONCONF_BORROW_PLUS,
            TRUE,
            &ShapeDiscardModeKey, 
            ServiceKeyHandle,
            FALSE);

        NdisCloseConfiguration(ServiceKeyHandle);
    }

    NdisCloseConfiguration(ConfigHandle);
        
    if(DisableDRR)
    {
        Adapter->PipeFlags |= PS_DISABLE_DRR;
    }

    if(IntermediateSystem)
    {
        Adapter->PipeFlags |= PS_INTERMEDIATE_SYS;
    }

    return NDIS_STATUS_SUCCESS;
}


NDIS_STATUS
PsReadAdapterRegistryData(PADAPTER     Adapter,
                         PNDIS_STRING MachineKey,
                         PNDIS_STRING AdapterKey)

/*++

Routine Description:

    Obtain the PSched specific info associated with the underlying MP.

Arguments:

    AdapterKey   - location of the per adapter key in the registry
    MachineKey   - location of the per Machine key in the registry
    Adapter      - pointer to the adapter structure

Return Value:

    NDIS_STATUS_SUCCESS if everything worked ok

--*/

{
    NDIS_STRING BestEffortKey          = NDIS_STRING_CONST("ServiceTypeBestEffort");
    NDIS_STRING NonConformingKey       = NDIS_STRING_CONST("ServiceTypeNonConforming");
    NDIS_STRING ControlledLoadKey      = NDIS_STRING_CONST("ServiceTypeControlledLoad");
    NDIS_STRING GuaranteedKey          = NDIS_STRING_CONST("ServiceTypeGuaranteed");
    NDIS_STRING QualitativeKey         = NDIS_STRING_CONST("ServiceTypeQualitative");
    NDIS_STRING NetworkControlKey      = NDIS_STRING_CONST("ServiceTypeNetworkControl");
    NDIS_STRING TcpTrafficKey          = NDIS_STRING_CONST("ServiceTypeTcpTraffic");
    NDIS_STRING MaxOutstandingSendsKey = NDIS_STRING_CONST("MaxOutstandingSends");
    NDIS_STRING NonBestEffortLimitKey  = NDIS_STRING_CONST("NonBestEffortLimit");
    NDIS_STRING DiffservKeyC           = NDIS_STRING_CONST("DiffservByteMappingConforming");
    NDIS_STRING DiffservKeyNC          = NDIS_STRING_CONST("DiffservByteMappingNonConforming");
    NDIS_STRING UserKey                = NDIS_STRING_CONST("UserPriorityMapping");
    NDIS_STATUS Status;
    NDIS_HANDLE SubKeyHandle, ConfigHandle;
    ULONG       Value;

    PAGED_CODE();

    PsDbgOut(DBG_INFO, DBG_INIT | DBG_ZAW,
             ("\n [PsReadAdapterRegistryData]: Adapter %08X (%ws): Reading Registry Data \n", 
              Adapter, Adapter->RegistryPath.Buffer));

    NdisOpenProtocolConfiguration(&Status, &ConfigHandle, &Adapter->RegistryPath);

    if(Status != NDIS_STATUS_SUCCESS)
    {
        PsDbgOut(DBG_FAILURE, DBG_INIT | DBG_ZAW,
                 ("[PsReadAdapterRegistryData]: Adapter %08X, Could not open config handle \n", 
                  Adapter));

        return Status;
    }
    
    PsReadRegistryInt(ConfigHandle,
                        &MaxOutstandingSendsKey,
                        DEFAULT_MAX_OUTSTANDING_SENDS,
                        &Adapter->MaxOutstandingSends,
                        1,
                        0xffffffff,
                        FALSE,
                        NULL,
                        NULL,
                        TRUE);

    PsReadRegistryInt(ConfigHandle,
                        &NonBestEffortLimitKey,
                        RESERVABLE_FRACTION,
                        &Adapter->ReservationLimitValue,
                        0,
                        200,
                        FALSE,
                        NULL,
                        NULL,
                        TRUE);

    //
    // Read the conforming values of DiffservByteMapping.
    //

    NdisOpenConfigurationKeyByName(&Status,
                                   ConfigHandle,
                                   &DiffservKeyC,
                                   &SubKeyHandle);

    if(!NT_SUCCESS(Status))
    {
        PsDbgOut(DBG_FAILURE, DBG_PROTOCOL | DBG_INIT,
                 ("[PsReadAdapterRegistryData]: Adapter %08X, Using defaults for "
                  "DiffservByteMappingConforming since key cannot be opened \n", Adapter));

        Adapter->IPServiceTypeBestEffort       = PS_IP_SERVICETYPE_CONFORMING_BESTEFFORT_DEFAULT;
        Adapter->IPServiceTypeControlledLoad   = PS_IP_SERVICETYPE_CONFORMING_CONTROLLEDLOAD_DEFAULT;
        Adapter->IPServiceTypeGuaranteed       = PS_IP_SERVICETYPE_CONFORMING_GUARANTEED_DEFAULT;
        Adapter->IPServiceTypeQualitative      = PS_IP_SERVICETYPE_CONFORMING_QUALITATIVE_DEFAULT;
        Adapter->IPServiceTypeNetworkControl   = PS_IP_SERVICETYPE_CONFORMING_NETWORK_CONTROL_DEFAULT;
        Adapter->IPServiceTypeTcpTraffic       = PS_IP_SERVICETYPE_CONFORMING_TCPTRAFFIC_DEFAULT;
    }
    else 
    {
        PsReadRegistryInt(ConfigHandle,
                          &TcpTrafficKey,
                          PS_IP_SERVICETYPE_CONFORMING_TCPTRAFFIC_DEFAULT,
                          &Value,
                          0,
                          PREC_MAX_VALUE,
                          TRUE,
                          &DiffservKeyC,
                          SubKeyHandle,
                          TRUE);

        Adapter->IPServiceTypeTcpTraffic = (UCHAR)Value;

        PsReadRegistryInt(ConfigHandle,
                          &BestEffortKey,
                          PS_IP_SERVICETYPE_CONFORMING_BESTEFFORT_DEFAULT,
                          &Value,
                          0,
                          PREC_MAX_VALUE,
                          TRUE,
                          &DiffservKeyC,
                          SubKeyHandle,
                          TRUE);
        
        Adapter->IPServiceTypeBestEffort = (UCHAR)Value;
        
        PsReadRegistryInt(ConfigHandle,
                          &ControlledLoadKey,
                          PS_IP_SERVICETYPE_CONFORMING_CONTROLLEDLOAD_DEFAULT,
                          &Value,
                          0,
                          PREC_MAX_VALUE,
                          TRUE,
                          &DiffservKeyC,
                          SubKeyHandle,
                          TRUE);
        
        Adapter->IPServiceTypeControlledLoad = (UCHAR)Value;
        
        PsReadRegistryInt(ConfigHandle,
                          &GuaranteedKey,
                          PS_IP_SERVICETYPE_CONFORMING_GUARANTEED_DEFAULT,
                          &Value,
                          0,
                          PREC_MAX_VALUE,
                          TRUE,
                          &DiffservKeyC,
                          SubKeyHandle,
                          TRUE);
        
        Adapter->IPServiceTypeGuaranteed = (UCHAR)Value;
        
        PsReadRegistryInt(ConfigHandle,
                          &QualitativeKey,
                          PS_IP_SERVICETYPE_CONFORMING_QUALITATIVE_DEFAULT,
                          &Value,
                          0,
                          PREC_MAX_VALUE,
                          TRUE,
                          &DiffservKeyC,
                          SubKeyHandle,
                          TRUE);
        
        Adapter->IPServiceTypeQualitative    = (UCHAR)Value;
        
        PsReadRegistryInt(ConfigHandle,
                          &NetworkControlKey,
                          PS_IP_SERVICETYPE_CONFORMING_NETWORK_CONTROL_DEFAULT,
                          &Value,
                          0,
                          PREC_MAX_VALUE,
                          TRUE,
                          &DiffservKeyC,
                          SubKeyHandle,
                          TRUE);
        
        Adapter->IPServiceTypeNetworkControl = (UCHAR)Value;
        
        NdisCloseConfiguration(SubKeyHandle);
    }
        
    //
    // Read the non-conforming values of DiffservByteMapping.
    //

    NdisOpenConfigurationKeyByName(&Status,
                                   ConfigHandle,
                                   &DiffservKeyNC,
                                   &SubKeyHandle);

    if(!NT_SUCCESS(Status))
    {
        PsDbgOut(DBG_FAILURE, DBG_PROTOCOL | DBG_INIT,
                 ("[PsReadAdapterRegistryData]: Adapter %08X, Using defaults for "
                  "DiffservByteMappingNonConforming since key cannot be opened \n", Adapter));

        Adapter->IPServiceTypeBestEffortNC     = PS_IP_SERVICETYPE_NONCONFORMING_BESTEFFORT_DEFAULT;
        Adapter->IPServiceTypeControlledLoadNC = PS_IP_SERVICETYPE_NONCONFORMING_CONTROLLEDLOAD_DEFAULT;
        Adapter->IPServiceTypeGuaranteedNC     = PS_IP_SERVICETYPE_NONCONFORMING_GUARANTEED_DEFAULT;
        Adapter->IPServiceTypeQualitativeNC    = PS_IP_SERVICETYPE_NONCONFORMING_QUALITATIVE_DEFAULT;
        Adapter->IPServiceTypeNetworkControlNC = PS_IP_SERVICETYPE_NONCONFORMING_BESTEFFORT_DEFAULT;
        Adapter->IPServiceTypeTcpTrafficNC     = PS_IP_SERVICETYPE_NONCONFORMING_TCPTRAFFIC_DEFAULT;
    }
    else
    {
        PsReadRegistryInt(ConfigHandle,
                          &TcpTrafficKey,
                          PS_IP_SERVICETYPE_NONCONFORMING_TCPTRAFFIC_DEFAULT,
                          &Value,
                          0,
                          PREC_MAX_VALUE,
                          TRUE,
                          &DiffservKeyNC,
                          SubKeyHandle,
                          TRUE);

        Adapter->IPServiceTypeTcpTrafficNC = (UCHAR)Value;

        PsReadRegistryInt(ConfigHandle,
                          &BestEffortKey,
                          PS_IP_SERVICETYPE_NONCONFORMING_BESTEFFORT_DEFAULT,
                          &Value,
                          0,
                          PREC_MAX_VALUE,
                          TRUE,
                          &DiffservKeyNC,
                          SubKeyHandle,
                          TRUE);

        Adapter->IPServiceTypeBestEffortNC = (UCHAR)Value;

        PsReadRegistryInt(ConfigHandle,
                          &ControlledLoadKey,
                          PS_IP_SERVICETYPE_NONCONFORMING_CONTROLLEDLOAD_DEFAULT,
                          &Value,
                          0,
                          PREC_MAX_VALUE,
                          TRUE,
                          &DiffservKeyNC,
                          SubKeyHandle,
                          TRUE);
        
        Adapter->IPServiceTypeControlledLoadNC = (UCHAR)Value;
        
        PsReadRegistryInt(ConfigHandle,
                          &GuaranteedKey,
                          PS_IP_SERVICETYPE_NONCONFORMING_GUARANTEED_DEFAULT,
                          &Value,
                          0,
                          PREC_MAX_VALUE,
                          TRUE,
                          &DiffservKeyNC,
                          SubKeyHandle,
                          TRUE);

        Adapter->IPServiceTypeGuaranteedNC = (UCHAR)Value;

        PsReadRegistryInt(ConfigHandle,
                          &QualitativeKey,
                          PS_IP_SERVICETYPE_NONCONFORMING_QUALITATIVE_DEFAULT,
                          &Value,
                          0,
                          PREC_MAX_VALUE,
                          TRUE,
                          &DiffservKeyNC,
                          SubKeyHandle,
                          TRUE);
        
        Adapter->IPServiceTypeQualitativeNC    = (UCHAR)Value;
                        
        PsReadRegistryInt(ConfigHandle,
                          &NetworkControlKey,
                          PS_IP_SERVICETYPE_NONCONFORMING_NETWORK_CONTROL_DEFAULT,
                          &Value,
                          0,
                          PREC_MAX_VALUE,
                          TRUE,
                          &DiffservKeyNC,
                          SubKeyHandle,
                          TRUE);
        
        Adapter->IPServiceTypeNetworkControlNC = (UCHAR)Value;
        
        NdisCloseConfiguration(SubKeyHandle);
    }

    //
    // Read the 802.1p values. The nonconforming in 802.1p does not depend on the 
    // service type. 
    //

    NdisOpenConfigurationKeyByName(&Status,
                                   ConfigHandle,
                                   &UserKey,
                                   &SubKeyHandle);

    if(!NT_SUCCESS(Status))
    {
        PsDbgOut(DBG_FAILURE, DBG_PROTOCOL | DBG_INIT,
                 ("[PsReadAdapterRegistryData]: Adapter %08X, Using defaults for "
                  "UserPriorityMapping since key cannot be opened \n", Adapter));
        Adapter->UserServiceTypeBestEffort       = PS_USER_SERVICETYPE_BESTEFFORT_DEFAULT;
        Adapter->UserServiceTypeControlledLoad   = PS_USER_SERVICETYPE_CONTROLLEDLOAD_DEFAULT;
        Adapter->UserServiceTypeGuaranteed       = PS_USER_SERVICETYPE_GUARANTEED_DEFAULT;
        Adapter->UserServiceTypeQualitative      = PS_USER_SERVICETYPE_QUALITATIVE_DEFAULT;
        Adapter->UserServiceTypeNetworkControl   = PS_USER_SERVICETYPE_NETWORK_CONTROL_DEFAULT;
        Adapter->UserServiceTypeNonConforming    = PS_USER_SERVICETYPE_NONCONFORMING_DEFAULT;
        Adapter->UserServiceTypeTcpTraffic       = PS_USER_SERVICETYPE_TCPTRAFFIC_DEFAULT;
    }
    else 
    {
        PsReadRegistryInt(ConfigHandle,
                            &TcpTrafficKey,
                            PS_USER_SERVICETYPE_TCPTRAFFIC_DEFAULT,
                            &Value,
                            0,
                            USER_PRIORITY_MAX_VALUE,
                            TRUE,
                            &UserKey,
                            SubKeyHandle,
                            TRUE);

        Adapter->UserServiceTypeTcpTraffic = (UCHAR)Value;

        PsReadRegistryInt(ConfigHandle,
                            &BestEffortKey,
                            PS_USER_SERVICETYPE_BESTEFFORT_DEFAULT,
                            &Value,
                            0,
                            USER_PRIORITY_MAX_VALUE,
                            TRUE,
                            &UserKey,
                            SubKeyHandle,
                            TRUE);

        Adapter->UserServiceTypeBestEffort = (UCHAR)Value;

        PsReadRegistryInt(ConfigHandle,
                            &ControlledLoadKey,
                            PS_USER_SERVICETYPE_CONTROLLEDLOAD_DEFAULT,
                            &Value,
                            0,
                            USER_PRIORITY_MAX_VALUE,
                            TRUE,
                            &UserKey,
                            SubKeyHandle,
                            TRUE);

        Adapter->UserServiceTypeControlledLoad = (UCHAR)Value;
                        
        PsReadRegistryInt(ConfigHandle,
                            &GuaranteedKey,
                            PS_USER_SERVICETYPE_GUARANTEED_DEFAULT,
                            &Value,
                            0,
                            USER_PRIORITY_MAX_VALUE,
                            TRUE,
                            &UserKey,
                            SubKeyHandle,
                            TRUE);

        Adapter->UserServiceTypeGuaranteed = (UCHAR)Value;
                        
        PsReadRegistryInt(ConfigHandle,
                            &QualitativeKey,
                            PS_USER_SERVICETYPE_QUALITATIVE_DEFAULT,
                            &Value,
                            0,
                            USER_PRIORITY_MAX_VALUE,
                            TRUE,
                            &UserKey,
                            SubKeyHandle,
                            TRUE);

        Adapter->UserServiceTypeQualitative    = (UCHAR)Value;
                        
        PsReadRegistryInt(ConfigHandle,
                            &NonConformingKey,
                            PS_USER_SERVICETYPE_NONCONFORMING_DEFAULT,
                            &Value,
                            0,
                            USER_PRIORITY_MAX_VALUE,
                            TRUE,
                            &UserKey,
                            SubKeyHandle,
                            TRUE);

        Adapter->UserServiceTypeNonConforming  = (UCHAR)Value;
                        
        PsReadRegistryInt(ConfigHandle,
                            &NetworkControlKey,
                            PS_USER_SERVICETYPE_NETWORK_CONTROL_DEFAULT,
                            &Value,
                            0,
                            USER_PRIORITY_MAX_VALUE,
                            TRUE,
                            &UserKey,
                            SubKeyHandle,
                            TRUE);

        Adapter->UserServiceTypeNetworkControl = (UCHAR)Value;

        NdisCloseConfiguration(SubKeyHandle);
    }
                        
    //
    // Now, we need to take this number, swap the bits around and put it in the higher order bits.
    // The DSCP codepoint is as follows:
    //
    //      --------------------------------
    // Bits | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
    //      --------------------------------
    //      |           DSCP        |  CU   |
    //      --------------------------------
    //
    // Where DSCP - Differentiated services code point
    //         CU - Currently unused.
    //
    Adapter->IPServiceTypeBestEffort       = Adapter->IPServiceTypeBestEffort       << 2;
    Adapter->IPServiceTypeControlledLoad   = Adapter->IPServiceTypeControlledLoad   << 2;
    Adapter->IPServiceTypeGuaranteed       = Adapter->IPServiceTypeGuaranteed       << 2; 
    Adapter->IPServiceTypeQualitative      = Adapter->IPServiceTypeQualitative      << 2;
    Adapter->IPServiceTypeNetworkControl   = Adapter->IPServiceTypeNetworkControl   << 2;
    Adapter->IPServiceTypeBestEffortNC     = Adapter->IPServiceTypeBestEffortNC     << 2;
    Adapter->IPServiceTypeControlledLoadNC = Adapter->IPServiceTypeControlledLoadNC << 2;
    Adapter->IPServiceTypeGuaranteedNC     = Adapter->IPServiceTypeGuaranteedNC     << 2; 
    Adapter->IPServiceTypeQualitativeNC    = Adapter->IPServiceTypeQualitativeNC    << 2;
    Adapter->IPServiceTypeNetworkControlNC = Adapter->IPServiceTypeNetworkControlNC << 2;
    Adapter->IPServiceTypeTcpTraffic       = Adapter->IPServiceTypeTcpTraffic       << 2;
    Adapter->IPServiceTypeTcpTrafficNC     = Adapter->IPServiceTypeTcpTrafficNC     << 2;

    NdisCloseConfiguration(ConfigHandle);

    return NDIS_STATUS_SUCCESS;
}