headers.h

Vitual Ring Routing 管你知不知道

}

extern uchar
AddressListCount(AddressList *List);

extern uint
AddressListContains(AddressList *List, VirtualAddress Address);

extern void
AddressListFree(AddressList *List);

extern AddressList *
AddressListAdd(AddressList *List, VirtualAddress Address);

extern AddressList *
AddressListClone(AddressList *Original);

extern uint
AddressListToArray(AddressList *List, VirtualAddress Array[], uint Count);

extern AddressList *
AddressListFromArray(VirtualAddress Array[], uint ArraySize);

extern AddressList *
AddressListTrim(AddressList *List, uint Limit);

extern void
ProbeListInit(ProbeList *PL);

extern ProbeListEntry *
FindAndDeletePLE(
    MiniportAdapter *VA,
    VirtualAddress Address);

extern void
ProbeListCleanup(
    MiniportAdapter *VA);

extern uint
VSetIsComplete(MiniportAdapter *VA);

extern Time
ProbeListTimeout(
    MiniportAdapter *VA,
    Time Now);

extern void
Uint64ToVirtualAddress(unsigned __int64 u64, VirtualAddress Address);

extern unsigned __int64
VirtualAddressToUint64(
    const VirtualAddress VAddr);

extern unsigned __int64
Uint64VirtualAddressDistance(
    unsigned __int64 x,
    unsigned __int64 y);

extern uint
VirtualAddressLessThan(
    const VirtualAddress ax,
    const VirtualAddress ay);

extern uint
VirtualAddressGreaterThan(
    const VirtualAddress ax,
    const VirtualAddress ay);
    
extern uint
VirtualAddressLessThanOrEqualTo(
    const VirtualAddress ax,
    const VirtualAddress ay);
    
extern uint
VirtualAddressGreaterThanOrEqualTo(
    const VirtualAddress ax,
    const VirtualAddress ay);
    
extern boolint
VirtualAddressIsCloser(
    const VirtualAddress ax,
    const VirtualAddress ay,
    const VirtualAddress az);

extern unsigned __int64
Uint64DistanceRight(
    unsigned __int64 x,
    unsigned __int64 y);

extern unsigned __int64
Uint64DistanceLeft(
    unsigned __int64 x,
    unsigned __int64 y);

extern uint
IsCloserRight(
    const VirtualAddress ax,
    const VirtualAddress ay,
    const VirtualAddress az);

__inline NodeTableEntry *
SentinelNTE(NodeTable *NT)
{
    return (NodeTableEntry *) &NT->FirstNTE;
}

extern ProbeListEntry *
FindPLE(
    ProbeList *PL,
    VirtualAddress Address);

extern ProbeListEntry *
FindPLEFromFrameSeqNo(
    ProbeList *PL,
    uint FrameSeqNo);

extern ProbeListEntry *
FindOrCreatePLE(
    MiniportAdapter *VA,
    VirtualAddress Address);

extern void
NodeTableInit(NodeTable *NT);

extern void
AddRefNTE(NodeTableEntry *NTE);

extern void
ReleaseNTE(NodeTableEntry *NTE);

extern NodeTableEntry *
CreateNTE(
    const VirtualAddress Address);

extern void
NodeTableCleanup(MiniportAdapter *VA);

extern NodeTableEntry *
FindNTE(NodeTable *NT,const VirtualAddress Address);

extern NodeTableEntry *
NodeInitSelf(MiniportAdapter *VA);


extern void
FixupsRTEtoNTE(
    MiniportAdapter *VA,
    NodeTableEntry *NTE);

extern boolint
VSetAddNode(
    MiniportAdapter *VA,
    VirtualAddress Address,
    uint CountVSet,
    VirtualAddress RemoteVSet[]);

extern uchar
IsCandidateNeighbor(
    MiniportAdapter *VA,
    VirtualAddress Candidate,
    uint CountVSet,
    VirtualAddress RemoteVSet[]);

extern void
FailAllNeigboursAndChangeState(
    MiniportAdapter *VA,
    uint GoActive);

extern Time
NodeTableTimeout(
    MiniportAdapter *VA,
    Time Now);

extern void
ReceiveVSet(
    MiniportAdapter *VA,
    uint VSetSize,
    VirtualAddress RemoteVSet[]);

//
// Used by e.g. ScheduleVSetRepair and ProcessVSetRepairQueue.
//
typedef struct VSetRepairQueue {
    struct VSetRepairQueue *Next;
    NodeTableEntry *NTE;
} VSetRepairQueue;

extern VSetRepairQueue *
ScheduleVSetRepair(
    MiniportAdapter *VA,
    VSetRepairQueue *Queue,
    RouteTableEntry *RepairRTE);

extern void
ProcessVSetRepairQueue(
    MiniportAdapter *VA,
    VSetRepairQueue *VRQ);

extern uint
ExistsCloserNTEorPLEthanSelf(
    MiniportAdapter *VA,
    const VirtualAddress Address,
    uint CheckProbeList,
    uint CheckProbeListMinusVSet);

extern void SetSelfInitialized(MiniportAdapter *VA);

extern void SetSelfActive(MiniportAdapter *VA,uint Active);

extern uint VSetToFlatBuffer(
    MiniportAdapter *VA,
    VirtualAddress Buffer[]);

//
// Functionality in route.c.
//

//
// The Route Table Entry represents a single VRR route.
//
typedef struct RouteTableEndpoint {
    unsigned __int64 uint64Address;          // Cached to avoid repeated type conversions in FNH.
    VirtualAddress Address;                  // Address (Host-Id) of the endpoint.
    VRRIf LocIF;
    VRRIf RemIF;
    NeighborCacheEntry *Next;                // Next hop (NCE) towards endpoint.
    NodeTableEntry *NTE;                     // NTE corresponding to this endpoint. May be NULL.
} RouteTableEndpoint, *PRouteTableEndpoint;

struct RouteTableEntry {        // RTE:
    RouteTableEntry *Next;
    RouteTableEntry *Prev;
    
    uint RefCnt;                // Reference counting on struct RTE.
    uchar State;                // State of RTE. Ref VRR_RTE_STATE_
    RTEFlags Flags;
    RouteTableEndpoint A;
    RouteTableEndpoint B;
    uint PathId;               // Assigned by endpoint A. Unique only at A.
    uint ETT;                  // Expected Transmission Time for Hops1 and Hops2.
    VirtualAddress NextNextA;  // Used by local path repair. Ref VrrSetup->Prev.
    Time Timeout;              // Time at which State expires.

};


struct RouteTable {
    KSPIN_LOCK Lock;
    RouteTableEntry *FirstRTE;
    RouteTableEntry *LastRTE;
    
    uint Count;                 // Count of RTE in list, excluding RT (SentinelRTE) itself.
    uint NextPathId;
};

__inline RouteTableEntry *
SentinelRTE(RouteTable *RT)
{
    return (RouteTableEntry *) &RT->FirstRTE;
}

extern void
RouteTableInit(RouteTable *RT);

extern void
AddRefRTE(RouteTableEntry *RTE);

extern void
ReleaseRTE(RouteTableEntry *RTE);

extern void
RouteTableCleanup(RouteTable *RT);

extern RouteTableEntry *
FindRTE(
    MiniportAdapter *VA,
    const VirtualAddress EndpointA,
    const VirtualAddress EndpointB,
    uint PathId,
    const VirtualAddress NextA,
    VRRIf LocIFa,
    VRRIf RemIFa,
    const VirtualAddress NextB,
    VRRIf LocIFb,
    VRRIf RemIFb,
    RTEFlags Flags);

extern RouteTableEntry *
FindOrCreateRTE(
    MiniportAdapter *VA,
    const VirtualAddress EndpointA,
    const VirtualAddress EndpointB,
    uint PathId,
    const VirtualAddress NextA,
    VRRIf LocIFa,
    VRRIf RemIFa,
    const VirtualAddress NextB,
    VRRIf LocIFb,
    VRRIf RemIFb,
    VirtualAddress NextNextA,
    RTEFlags Flags);

extern Time
RTERetireTimeout(
    RTEFlags Flags);

extern Time
RouteTableTimeout(
    MiniportAdapter *VA,
    Time Now);

extern void
RouteUpdateNCE(
    MiniportAdapter *VA,
    NeighborCacheEntry *NCE,
    uchar State);

extern void
RouteEvictNTE(
    MiniportAdapter *VA,
    NodeTableEntry *NTE);

typedef enum FindNextHopResult {
    SuccessFwd,
    SuccessRcvSelf,
    SuccessRcvNearest,
    Error
}FindNextHopResult;

extern
void
RouteFailLink(
    MiniportAdapter *VA,
    NeighborCacheEntry *NCE);


extern FindNextHopResult
FindNextHop(
    MiniportAdapter *VA,
    VirtualAddress Dest,
    VRRIf LocIF,
    VRRIf RemIF,
    TxToken *Tok,
    AddressList *SRcAntiRoute,
    uchar SRFlags);

extern RouteTableEntry *
FindVSetRoute(
    MiniportAdapter *VA,
    const VirtualAddress EndpointA,
    const VirtualAddress EndpointB);

extern boolint
IsNullTxToken(TxToken *Tok);

//
// Functionality in setup.c
//
extern void
ReceiveSetup(
    MiniportAdapter *VA,
    ProtocolAdapter *PA,
    InternalVrrSetup *InternalSetup,
    SRPacket *srp);

extern InternalVrrSetup *
CreateSetupOpt(
    MiniportAdapter *VA,
    VirtualAddress Dest,
    VirtualAddress EndpointA,
    VirtualAddress EndpointB,
    uint PathId,
    VirtualAddress Proxy,
    const VirtualAddress Prev,
    VirtualAddress Target);

//
// Functionality in teardown.c
//
struct TearDownCacheEntry {     // TDCE:
    TearDownCacheEntry *Next;
    TearDownCacheEntry *Prev;
    
    VirtualAddress Address;     // Endpoint A.
    uint PathId;
    Time Timeout;
    VirtualAddress ReportedBy;  // Address of node the originated the TearDown message. 
};

struct TearDownCache {
    KSPIN_LOCK Lock;
    TearDownCacheEntry *FirstTDCE;
    TearDownCacheEntry *LastTDCE;
};

__inline TearDownCacheEntry *
SentinelTDCE(TearDownCache *TDC)
{
    return (TearDownCacheEntry *) &TDC->FirstTDCE;
}

extern
void
TearDownCacheInit(TearDownCache *TDC);

extern
TearDownCacheEntry *
FindTDCE(
    TearDownCache *TDC,
    VirtualAddress Address,
    uint PathId,
    VirtualAddress ReportedBy);

extern
void
TearDownCacheCleanup(
    TearDownCache *TDC);

extern
TearDownCacheEntry *
FindOrCreateTDCE(
    TearDownCache *TDC,
    VirtualAddress Address,
    uint PathId,
    VirtualAddress ReportedBy);

extern
Time
TearDownCacheTimeout(
    MiniportAdapter *VA,
    Time Now);

extern void
ReceiveTearDown(
    MiniportAdapter *VA,
    ProtocolAdapter *PA,
    InternalVrrTearDown *InternalTearDown);

extern InternalVrrTearDown *
CreateTearDownOpt(
    MiniportAdapter *VA,
    VirtualAddress Dest,
    uint NumPId,
    uint SizeOfPIdBuff,
    VrrGlobalPathId PidBuf[],
    uint IncludeVSet,
    uint Forwarding);

//
// Functionality in partition.c
//
struct ZeroListEntry {        // ZLE:
    ZeroListEntry *Next;