headers.h

Vitual Ring Routing 管你知不知道

    ZeroListEntry *Prev;
    
    VirtualAddress Address;    // Address of node to which we are sending SetupRequests.
    Time Timeout;              // Remaining lifetime iff ACTIVE, else time it expired.
    uint SeqNo;                // Sequence number assigned at partition representative node.
    uchar State;
};

struct ZeroList {
    KSPIN_LOCK Lock;
    ZeroListEntry *FirstZLE;
    ZeroListEntry *LastZLE;
};

__inline ZeroListEntry *
SentinelZLE(ZeroList *ZL)
{
    return (ZeroListEntry *) &ZL->FirstZLE;
}

extern void
ZeroListInit(ZeroList *ZL);

extern void
ZeroListCleanup(
    MiniportAdapter *VA);

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

extern ZeroListEntry *
UpdateZLE(
    MiniportAdapter *VA,
    VirtualAddress Address,
    uint SeqNo);

extern void
UpdateLocalZeroListEntry(
    MiniportAdapter *VA);

extern void
EmitHelloZeroList(
    MiniportAdapter *VA,
    VrrHello *Hello);

extern void
ReceiveHelloZeroList(
    MiniportAdapter *VA,
    VrrHello *Hello,
    VirtualAddress NextHop,
    VRRIf LocIF,
    Time Now);

//
// Functionality in pktindex.c
//
struct PacketIndex {
    KSPIN_LOCK Lock;
    PacketIndexEntry *FirstPXE;
    PacketIndexEntry *LastPXE;
};

__inline PacketIndexEntry *
SentinelPXE(PacketIndex *PX)
{
    return (PacketIndexEntry *) &PX->FirstPXE;
}

extern void
PacketIndexInit(PacketIndex *PX);

extern PacketIndexEntry *
FindPXE(
    PacketIndex *PX,
    VirtualAddress Origin,
    uint FrameSeqNo,
    uchar Type);

extern uint 
UpdatePacketIndex(
    MiniportAdapter *VA,
    VirtualAddress Origin,
    uint FrameSeqNo,
    uchar HopCount,
    VirtualAddress Source,
    VirtualAddress Dest,
    VRRIf LocIF,
    uchar Type);

extern void
PacketIndexCleanup(
    MiniportAdapter *VA);

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

//
// Functionality in broadcast.c
//
struct BroadcastList {
    KSPIN_LOCK Lock;
    BroadcastListEntry *FirstBLE;
    BroadcastListEntry *LastBLE;
};

__inline BroadcastListEntry *
SentinelBLE(BroadcastList *BL)
{
    return (BroadcastListEntry *) &BL->FirstBLE;
}

extern void
BroadcastListInit(BroadcastList *BL);

extern BroadcastListEntry *
FindBLE(
    BroadcastList *BL,
    VirtualAddress Origin,
    uint FrameSeqNo);

extern uint 
IsBroadcastRelay(
    MiniportAdapter *VA);

extern uint 
UpdateBroadcastList(
    MiniportAdapter *VA,
    VirtualAddress Origin,
    uint FrameSeqNo,
    uchar HopCount,
    VirtualAddress Source,
    VirtualAddress EthDest,
    uint Forward,
    uchar Buffer[],
    uint BufferLen);

extern void
BroadcastListCleanup(
    MiniportAdapter *VA);

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


//
// Functionality in setupreq.c
//
extern void
ReceiveSetupReq(
    MiniportAdapter *VA,
    ProtocolAdapter *PA,
    InternalVrrSetupReq *InternalSetupReq,
    SRPacket *srp);
    
extern InternalVrrSetupReq *
CreateSetupReqOpt(
    MiniportAdapter *VA,
    VirtualAddress Dest,
    uchar Type,
    VirtualAddress Proxy,
    uint FrameSeqNo,
    VirtualAddress Target,
    AddressList *SRcAntiRoute);

extern boolint
JoinSendSetupReq(
    MiniportAdapter *VA,
    VirtualAddress Dest,
    VirtualAddress Proxy,
    uint FrameSeqNo,
    AddressList *SRcAntiRoute);

//
// Functionality in send.c
//
extern void
VrrBroadcastComplete(
    MiniportAdapter *VA,
    NDIS_PACKET *Packet,
    NDIS_STATUS Status);

extern void
VrrBroadcastHello(
    MiniportAdapter *VA,
    SRPacket *srp);

extern void
VrrBroadcastSRPComplete(
    MiniportAdapter *VA,
    SRPacket *srp,
    NDIS_STATUS Status);

extern boolint
GetPhysNeighborTxToken(
    MiniportAdapter *VA,
    VirtualAddress Dest,
    VRRIf LocIF,
    VRRIf RemIF,
    TxToken *Tok,
    uchar State);

extern void
SendTransmitComplete(
    MiniportAdapter *VA,
    NDIS_PACKET *Packet,
    NDIS_STATUS Status);


//
// Functionality on global.c
//
extern VrrGlobalState VrrGlobal;

extern void GlobalInit(MiniportAdapter *VA);
extern Time TimeSinceMidnight();
extern Time TimeoutInterval(Time MinTime, Time MaxTime);

extern InternalOption *
CopyInternalOption(
    MiniportAdapter *VA,
    InternalOption *Original);

//
// Functionality in miniport.c.
//

typedef union MetricParams {
    PktPairParams PktPair;
    WcettParams Wcett;
} MetricParams; 

extern struct MiniportAdapters {
    KSPIN_LOCK Lock;
    MiniportAdapter *VirtualAdapters;
} MiniportAdapters;

struct MiniportAdapter {                // VA:
    MiniportAdapter **Prev, *Next;

    uint Index;
    GUID Guid;

    NDIS_HANDLE MiniportHandle;
    NDIS_HANDLE ProtocolHandle;

    PDEVICE_OBJECT PhysicalDeviceObject;
    PDEVICE_OBJECT DeviceObject;

    KSPIN_LOCK Lock;
    ProtocolAdapter *PhysicalAdapters;
    uint NextPhysicalAdapterIndex;

    Time Timeout;
    KTIMER Timer;
    KDPC TimeoutDpc;
    uint TimeoutMinLoops;
    uint TimeoutMaxLoops;

    NeighborCache NC;
    NodeTable NT;
    RouteTable RT;
    PbackCache PCache;
    TearDownCache TDC;
    ProbeList PL;
    ZeroList ZL;
    PacketIndex PX;
    BroadcastList BL;
    MaintBuf *MaintBuf;

    SRPacket *ForwardList;
    SRPacket **ForwardLast;
    Time ForwardTime;

    VirtualAddress Address;
    VirtualAddress AddressDec;  // Address-1 in virtual address space.
    VirtualAddress AddressInc;  // Address+1 in virtual address space.

    boolint Snooping;           // Learn route info from overhead packets?
    
    boolint Crypto;             // Encrypt the packets? 
    uchar CryptoKeyMAC[CRYPTO_KEY_MAC_LENGTH];
    uchar CryptoKeyAES[AES_KEYSIZE_128];

    boolint ArtificialDrop;     // Simulate lossy links by dropping packets?

    Time LinkTimeout;           // How long do stale links live?

    NDIS_MEDIUM Medium;
    uint PacketFilter;
    uint LookAhead;
    uint MediumLinkSpeed;
    uint MediumMinPacketLen;
    uint MediumMaxPacketLen;
    uint MediumMacHeaderLen;
    uint MediumMaxFrameLen;

    NDIS_HANDLE PacketPool;
    NDIS_HANDLE BufferPool;
    uint CountPacketPoolFailure;

    //
    // Parameters for Metric being used. 
    // 

    MetricType MetricType;
    MetricParams MetricParams;

    boolint (*IsInfinite)(uint LinkMetric);
    uint (*ConvMetric)(uint LinkMetric);
    void (*InitLinkMetric)(MiniportAdapter *VA,
                           int SNode, Link *Link, Time Now);
    uint (*PathMetric)(MiniportAdapter *VA, Link **Hops, uint NumHops);
    uint RateAdmitThreshold;      // Admit link iff bandwidth better than this.
    uint RateEvictThreshold;      // Fail link if bandwidth drops below this.
    uint RssiAdmitThreshold;      // Admit link iff RSSI better than this.
    uint RssiEvictThreshold;      // Fail link if RSSI drops below this.

    uint DriverInitialized;       // We have received at least one Setup from our join attempts.
    uint DriverActive;            // We have (had) paths to (all) neighbours on VSetLeft and VSetRight.
    uint VrrAPIJoined;
    uint JoiningOnHold;           // Delay during reboot giving neighbours time to detect link failure.
    uint PartitionRepairEnabled;
    uint BroadcastRelay;
    uint BroadcastJitterMinMs;
    uint BroadcastJitterMaxMs;
    uint TxDropAllButHello;
    uint TxDropAllHello;
    uint VrrTraceNoiseLevel;
    Time DriverLoadTime;

    VirtualAddress ExpectedVSet[VRR_MAX_VSET_SIZE];  // Testing aid: VSet known in advance in test rig.
    VirtualAddress CurrentVSet[VRR_MAX_VSET_SIZE];   // Testing aid: VSet known in advance in test rig.
    VirtualAddress RoutesVSet[VRR_MAX_VSET_SIZE];    // Testing aid: NULL unless exists VSetRoute.
    uint AddErrorVSet[VRR_MAX_VSET_SIZE];            // Testing aid: count times ExpVSet member rejected.
    uint RejExpBypass[REJ_EXP_BYPASS_COUNT];         // Testing aid: count ExpVSet error bypasses.
    uint TestExpectedVSet;                           // Switch enabling testing against ExpectedVSet;
    uint MsFirstJoinSetupReq;        // Time in ms at which first SetupReq(join) was sent.
    uint MsJoinToHeardExpectedVSet;  // Interval between MsFirstJoinSetupReq and hearing ExpectedVSet.
    uint MsJoinToPathsExpectedVSet;  // Interval between MsFirstJoinSetupReq and all ExpectedVSet paths intact.

    //
    // Counters for monitoring/debugging purposes.
    //
    uint CountSRNackSeqT;
    uint CountExitRing;
    uint CountExitExecCmd;
    uint CountExitNCE;
    uint CountExitNTE;
    uint CountSetActiveT;
    uint CountSetActiveF;
    uint CountMaxPLE;
    uint BootNode;
    uint MaxMsgTimeDelay;
    uint MaxMsgCountDelayed;
    uint CountMsQDropCritical;
    uint CountPnRepairSendSetup;
    uint CountHopCountExceeded;
    uint CountNTECloserThanSelf;
    uint CountXmit;
    uint CountXmitLocally;
    uint CountXmitQueueFull;
    uint CountRexmitQueueFull;
    uint CountXmitNoRoute;
    uint CountXmitMulticast;
    uint CountXmitMaintBuf;
    uint CountXmitForwardUnicast;
    uint CountXmitForwardQueueFull;
    uint CountXmitForwardBroadcast;
    uint CountXmitProbe;
    uint CountXmitProbeReply;
    uint CountSendHello;
    uint CountSendSetup;
    uint CountSendTearDown;
    uint CountSendSetupReq;
    uint CountSendSetupReqNack;
    uint CountFwdSetup;
    uint CountFwdTearDown;
    uint CountFwdSetupReq;
    uint CountMisroutedSetup;
    uint CountMisroutedSetupReq;
    uint CountMisroutedTearDown;
    uint CountSRDropHopCount;
    uint CountSRDropLoop;
    uint MaxPLESRcAntiRoute;
    uint MaxPLESRcAntiRouteRcv;
    uint CountFNHSRcAntiRoute;
    uint CountFNHsendSRleft;
    uint CountFNHsendSRright;
    uint CountRecv;
    uint CountRecvLocally;
    uint CountRecvLocallySalvaged;
    uint CountRecvBadMAC;
    uint CountRecvAckRequest;
    uint CountRecvAck;
    uint CountRecvDupAckReq;
    uint CountRecvProbe;
    uint CountRecvProbeReply;
    uint CountRecvHello;
    uint CountRecvSetup;
    uint CountRecvTearDown;
    uint CountRecvSetupReq;
    uint CountRecvSRleft;
    uint CountRecvSRright;
    uint CountGenSRleft;
    uint CountGenSRright;
    uint CountRecvRecursive;
    uint CountRecvEmpty;
    uint CountRecvSmall;
    uint CountRecvDecryptFailure;

    uint MinVersionSeen;
    uint MaxVersionSeen;

    uint TotalForwardingStall;          // Microseconds.

    uint ForwardNum;
    uint ForwardMax;
    uint CountForwardFast;
    uint CountForwardQueue;
    uint CountForwardDrop;

    VrrHelloParams VrrHelloParams;      // Hello member in MiniportAdapter (VA).
};

extern MiniportAdapter *
FindVirtualAdapterFromIndex(uint Index);

extern MiniportAdapter *
FindVirtualAdapterFromGuid(const GUID *Guid);

extern boolint
MiniportInit(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath);

extern void
MiniportReceivePacket(MiniportAdapter *VA, ProtocolAdapter *PA,
                      NDIS_PACKET *Original,
                      void (*FreePacket)(ProtocolAdapter *PA,
                                         NDIS_PACKET *Packet));

extern void
MiniportIndicateStatusConnected(MiniportAdapter *A);

extern void
MiniportIndicateStatusDisconnected(MiniportAdapter *A);

extern void
MiniportSendComplete(MiniportAdapter *VA, SRPacket *srp, NDIS_STATUS Status);