espressif/openthread
1
0
Fork 0
mirror of https://github.com/espressif/openthread.git synced 2026-08-14 14:47:46 +00:00
Code Issues Packages Projects Releases Wiki Activity

[mle] avoid unnecessary method calls on MTD (#4730)

Browse Source
This commit is contained in:
Jonathan Hui
2020-03-25 07:54:57 -07:00
parent 4cb09ec637
commit efa085e43f
3 changed files with 118 additions and 138 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/core/thread/announce_sender.cpp
+2
View File
@@ -138,11 +138,13 @@ void AnnounceSender::CheckState(void)
break;
case OT_DEVICE_ROLE_CHILD:
#if OPENTHREAD_FTD
if (mle.IsRouterEligible() && mle.IsRxOnWhenIdle())
{
interval = kReedTxInterval;
break;
}
#endif
// fall through
src/core/thread/mle.cpp
+116 -68
View File
@@ -273,6 +273,7 @@ otError Mle::Start(bool aAnnounceAttach)
{
BecomeChild(kAttachAny);
}
#if OPENTHREAD_FTD
else if (IsActiveRouter(GetRloc16()))
{
if (Get<MleRouter>().BecomeRouter(ThreadStatusTlv::kTooFewRouters) != OT_ERROR_NONE)
@@ -280,6 +281,7 @@ otError Mle::Start(bool aAnnounceAttach)
BecomeChild(kAttachAny);
}
}
#endif
else
{
mChildUpdateAttempts = 0;
@@ -441,12 +443,14 @@ otError Mle::Restore(void)
mPreviousParentRloc = mParent.GetRloc16();
#endif
}
#if OPENTHREAD_FTD
else
{
Get<MleRouter>().SetRouterId(RouterIdFromRloc16(GetRloc16()));
Get<MleRouter>().SetPreviousPartitionId(networkInfo.GetPreviousPartitionId());
Get<MleRouter>().RestoreChildren();
}
#endif
exit:
return error;
@@ -658,10 +662,12 @@ otError Mle::BecomeChild(AttachMode aMode)
if (aMode != kAttachBetter)
{
#if OPENTHREAD_FTD
if (IsFullThreadDevice())
{
Get<MleRouter>().StopAdvertiseTimer();
}
#endif
}
else
{
@@ -757,7 +763,9 @@ void Mle::SetStateDetached(void)
mDataRequestAttempts = 0;
Get<MeshForwarder>().SetRxOnWhenIdle(true);
Get<Mac::Mac>().SetBeaconEnabled(false);
#if OPENTHREAD_FTD
Get<MleRouter>().HandleDetachStart();
#endif
Get<Ip6::Ip6>().SetForwardingEnabled(false);
#if OPENTHREAD_FTD
Get<Ip6::Mpl>().SetTimerExpirations(0);
@@ -782,10 +790,12 @@ void Mle::SetStateChild(uint16_t aRloc16)
Get<Mac::Mac>().SetBeaconEnabled(false);
ScheduleMessageTransmissionTimer();
#if OPENTHREAD_FTD
if (IsFullThreadDevice())
{
Get<MleRouter>().HandleChildStart(mParentRequestMode);
}
#endif
#if OPENTHREAD_CONFIG_BORDER_ROUTER_ENABLE || OPENTHREAD_CONFIG_TMF_NETDATA_SERVICE_ENABLE
Get<NetworkData::Local>().ClearResubmitDelayTimer();
@@ -813,12 +823,13 @@ void Mle::InformPreviousChannel(void)
VerifyOrExit(mAlternatePanId != Mac::kPanIdBroadcast);
VerifyOrExit(mRole == OT_DEVICE_ROLE_CHILD || mRole == OT_DEVICE_ROLE_ROUTER);
if (!IsFullThreadDevice() || mRole == OT_DEVICE_ROLE_ROUTER ||
Get<MleRouter>().GetRouterSelectionJitterTimeout() == 0)
{
mAlternatePanId = Mac::kPanIdBroadcast;
Get<AnnounceBeginServer>().SendAnnounce(1 << mAlternateChannel);
}
#if OPENTHREAD_FTD
VerifyOrExit(!IsFullThreadDevice() || mRole == OT_DEVICE_ROLE_ROUTER ||
Get<MleRouter>().GetRouterSelectionJitterTimeout() == 0);
#endif
mAlternatePanId = Mac::kPanIdBroadcast;
Get<AnnounceBeginServer>().SendAnnounce(1 << mAlternateChannel);
exit:
return;
@@ -1010,7 +1021,9 @@ void Mle::SetLeaderData(uint32_t aPartitionId, uint8_t aWeighting, uint8_t aLead
{
if (mLeaderData.GetPartitionId() != aPartitionId)
{
#if OPENTHREAD_FTD
Get<MleRouter>().HandlePartitionChange();
#endif
Get<Notifier>().Signal(OT_CHANGED_THREAD_PARTITION_ID);
mCounters.mPartitionIdChanges++;
}
@@ -1521,14 +1534,19 @@ void Mle::HandleStateChanged(otChangedFlags aFlags)
if ((aFlags & OT_CHANGED_THREAD_NETDATA) != 0)
{
#if OPENTHREAD_FTD
if (IsFullThreadDevice())
{
Get<MleRouter>().HandleNetworkDataUpdateRouter();
}
else if ((aFlags & OT_CHANGED_THREAD_ROLE) == 0)
else
#endif
{
mChildUpdateRequestState = kChildUpdateRequestPending;
ScheduleMessageTransmissionTimer();
if ((aFlags & OT_CHANGED_THREAD_ROLE) == 0)
{
mChildUpdateRequestState = kChildUpdateRequestPending;
ScheduleMessageTransmissionTimer();
}
}
#if OPENTHREAD_CONFIG_BORDER_ROUTER_ENABLE || OPENTHREAD_CONFIG_TMF_NETDATA_SERVICE_ENABLE
@@ -1827,11 +1845,13 @@ uint32_t Mle::Reattach(void)
mAlternatePanId = Mac::kPanIdBroadcast;
BecomeDetached();
}
else if (!IsFullThreadDevice())
#if OPENTHREAD_FTD
else if (IsFullThreadDevice() && Get<MleRouter>().BecomeLeader() == OT_ERROR_NONE)
{
BecomeDetached();
// do nothing
}
else if (Get<MleRouter>().BecomeLeader() != OT_ERROR_NONE)
#endif
else
{
BecomeDetached();
}
@@ -2592,9 +2612,11 @@ void Mle::HandleUdpReceive(Message &aMessage, const Ip6::MessageInfo &aMessageIn
switch (header.GetCommand())
{
#if OPENTHREAD_FTD
case Header::kCommandDiscoveryRequest:
Get<MleRouter>().HandleDiscoveryRequest(aMessage, aMessageInfo);
break;
#endif
case Header::kCommandDiscoveryResponse:
HandleDiscoveryResponse(aMessage, aMessageInfo);
@@ -2713,6 +2735,55 @@ void Mle::HandleUdpReceive(Message &aMessage, const Ip6::MessageInfo &aMessageIn
switch (command)
{
case Header::kCommandAdvertisement:
HandleAdvertisement(aMessage, aMessageInfo, neighbor);
break;
case Header::kCommandDataResponse:
HandleDataResponse(aMessage, aMessageInfo, neighbor);
break;
case Header::kCommandParentResponse:
HandleParentResponse(aMessage, aMessageInfo, keySequence);
break;
case Header::kCommandChildIdResponse:
HandleChildIdResponse(aMessage, aMessageInfo, neighbor);
break;
case Header::kCommandAnnounce:
HandleAnnounce(aMessage, aMessageInfo);
break;
case Header::kCommandChildUpdateRequest:
#if OPENTHREAD_FTD
if (mRole == OT_DEVICE_ROLE_LEADER || mRole == OT_DEVICE_ROLE_ROUTER)
{
Get<MleRouter>().HandleChildUpdateRequest(aMessage, aMessageInfo, keySequence);
}
else
#endif
{
HandleChildUpdateRequest(aMessage, aMessageInfo, neighbor);
}
break;
case Header::kCommandChildUpdateResponse:
#if OPENTHREAD_FTD
if (mRole == OT_DEVICE_ROLE_LEADER || mRole == OT_DEVICE_ROLE_ROUTER)
{
Get<MleRouter>().HandleChildUpdateResponse(aMessage, aMessageInfo, keySequence, neighbor);
}
else
#endif
{
HandleChildUpdateResponse(aMessage, aMessageInfo, neighbor);
}
break;
#if OPENTHREAD_FTD
case Header::kCommandLinkRequest:
Get<MleRouter>().HandleLinkRequest(aMessage, aMessageInfo, neighbor);
break;
@@ -2725,67 +2796,27 @@ void Mle::HandleUdpReceive(Message &aMessage, const Ip6::MessageInfo &aMessageIn
Get<MleRouter>().HandleLinkAcceptAndRequest(aMessage, aMessageInfo, keySequence, neighbor);
break;
case Header::kCommandAdvertisement:
HandleAdvertisement(aMessage, aMessageInfo, neighbor);
break;
case Header::kCommandDataRequest:
Get<MleRouter>().HandleDataRequest(aMessage, aMessageInfo, neighbor);
break;
case Header::kCommandDataResponse:
HandleDataResponse(aMessage, aMessageInfo, neighbor);
break;
case Header::kCommandParentRequest:
Get<MleRouter>().HandleParentRequest(aMessage, aMessageInfo);
break;
case Header::kCommandParentResponse:
HandleParentResponse(aMessage, aMessageInfo, keySequence);
break;
case Header::kCommandChildIdRequest:
Get<MleRouter>().HandleChildIdRequest(aMessage, aMessageInfo, keySequence);
break;
case Header::kCommandChildIdResponse:
HandleChildIdResponse(aMessage, aMessageInfo, neighbor);
break;
case Header::kCommandChildUpdateRequest:
if (mRole == OT_DEVICE_ROLE_LEADER || mRole == OT_DEVICE_ROLE_ROUTER)
{
Get<MleRouter>().HandleChildUpdateRequest(aMessage, aMessageInfo, keySequence);
}
else
{
HandleChildUpdateRequest(aMessage, aMessageInfo, neighbor);
}
break;
case Header::kCommandChildUpdateResponse:
if (mRole == OT_DEVICE_ROLE_LEADER || mRole == OT_DEVICE_ROLE_ROUTER)
{
Get<MleRouter>().HandleChildUpdateResponse(aMessage, aMessageInfo, keySequence, neighbor);
}
else
{
HandleChildUpdateResponse(aMessage, aMessageInfo, neighbor);
}
break;
case Header::kCommandAnnounce:
HandleAnnounce(aMessage, aMessageInfo);
break;
#if OPENTHREAD_CONFIG_TIME_SYNC_ENABLE
case Header::kCommandTimeSync:
Get<MleRouter>().HandleTimeSync(aMessage, aMessageInfo, neighbor);
break;
#endif
#endif // OPENTHREAD_FTD
default:
ExitNow(error = OT_ERROR_DROP);
}
exit:
@@ -2803,7 +2834,6 @@ otError Mle::HandleAdvertisement(const Message &aMessage, const Ip6::MessageInfo
otError error = OT_ERROR_NONE;
uint16_t sourceAddress;
LeaderData leaderData;
RouteTlv route;
uint8_t tlvs[] = {Tlv::kNetworkData};
uint16_t delay;
@@ -2817,14 +2847,19 @@ otError Mle::HandleAdvertisement(const Message &aMessage, const Ip6::MessageInfo
if (mRole != OT_DEVICE_ROLE_DETACHED)
{
#if OPENTHREAD_FTD
if (IsFullThreadDevice())
{
SuccessOrExit(error = Get<MleRouter>().HandleAdvertisement(aMessage, aMessageInfo, aNeighbor));
}
else if ((aNeighbor == &mParent) && (mParent.GetRloc16() != sourceAddress))
else
#endif
{
// Remove stale parent.
BecomeDetached();
if ((aNeighbor == &mParent) && (mParent.GetRloc16() != sourceAddress))
{
// Remove stale parent.
BecomeDetached();
}
}
}
@@ -2842,12 +2877,18 @@ otError Mle::HandleAdvertisement(const Message &aMessage, const Ip6::MessageInfo
{
SetLeaderData(leaderData.GetPartitionId(), leaderData.GetWeighting(), leaderData.GetLeaderRouterId());
if (IsFullThreadDevice() && (Tlv::GetTlv(aMessage, Tlv::kRoute, sizeof(route), route) == OT_ERROR_NONE) &&
route.IsValid())
#if OPENTHREAD_FTD
if (IsFullThreadDevice())
{
// Overwrite Route Data
Get<MleRouter>().ProcessRouteTlv(route);
RouteTlv route;
if ((Tlv::GetTlv(aMessage, Tlv::kRoute, sizeof(route), route) == OT_ERROR_NONE) && route.IsValid())
{
// Overwrite Route Data
Get<MleRouter>().ProcessRouteTlv(route);
}
}
#endif
mRetrieveNewNetworkData = true;
}
@@ -3263,6 +3304,7 @@ otError Mle::HandleParentResponse(const Message &aMessage, const Ip6::MessageInf
int compare = 0;
#if OPENTHREAD_FTD
if (IsFullThreadDevice())
{
compare = MleRouter::ComparePartitions(connectivity.GetActiveRouters() <= 1, leaderData, mParentIsSingleton,
@@ -3271,6 +3313,7 @@ otError Mle::HandleParentResponse(const Message &aMessage, const Ip6::MessageInf
// only consider partitions that are the same or better
VerifyOrExit(compare >= 0);
#endif
// only consider better parents if the partitions are the same
VerifyOrExit(compare != 0 || IsBetterParent(sourceAddress, linkQuality, linkMargin, connectivity,
@@ -3361,7 +3404,6 @@ otError Mle::HandleChildIdResponse(const Message & aMessage,
LeaderData leaderData;
uint16_t sourceAddress;
uint16_t shortAddress;
RouteTlv route;
ActiveTimestampTlv activeTimestamp;
PendingTimestampTlv pendingTimestamp;
Tlv tlv;
@@ -3447,11 +3489,17 @@ otError Mle::HandleChildIdResponse(const Message & aMessage,
Get<MeshForwarder>().SetRxOnWhenIdle(true);
}
// Route
if ((Tlv::GetTlv(aMessage, Tlv::kRoute, sizeof(route), route) == OT_ERROR_NONE) && IsFullThreadDevice())
#if OPENTHREAD_FTD
if (IsFullThreadDevice())
{
SuccessOrExit(error = Get<MleRouter>().ProcessRouteTlv(route));
RouteTlv route;
if (Tlv::GetTlv(aMessage, Tlv::kRoute, sizeof(route), route) == OT_ERROR_NONE)
{
SuccessOrExit(error = Get<MleRouter>().ProcessRouteTlv(route));
}
}
#endif
mParent = mParentCandidate;
mParentCandidate.Clear();
src/core/thread/mle_router_mtd.hpp
-70
View File
@@ -38,9 +38,7 @@
#include "thread/child_table.hpp"
#include "thread/mle.hpp"
#include "thread/mle_tlvs.hpp"
#include "thread/router_table.hpp"
#include "thread/thread_tlvs.hpp"
namespace ot {
namespace Mle {
@@ -58,39 +56,16 @@ public:
{
}
bool IsRouterEligible(void) const { return false; }
bool IsSingleton(void) const { return false; }
otError BecomeRouter(ThreadStatusTlv::Status) { return OT_ERROR_NOT_CAPABLE; }
otError BecomeLeader(void) { return OT_ERROR_NOT_CAPABLE; }
uint8_t GetRouterSelectionJitterTimeout(void) const { return 0; }
uint32_t GetPreviousPartitionId(void) const { return 0; }
void SetPreviousPartitionId(uint32_t) {}
void SetRouterId(uint8_t) {}
uint16_t GetNextHop(uint16_t aDestination) const { return Mle::GetNextHop(aDestination); }
uint8_t GetNetworkIdTimeout(void) const { return 0; }
uint8_t GetRouteCost(uint16_t) const { return 0; }
uint8_t GetLinkCost(uint16_t) { return 0; }
uint8_t GetCost(uint16_t) { return 0; }
otError RemoveNeighbor(Neighbor &) { return BecomeDetached(); }
bool IsMinimalChild(uint16_t) const { return false; }
void RestoreChildren(void) {}
otError RemoveStoredChild(uint16_t) { return OT_ERROR_NOT_IMPLEMENTED; }
otError StoreChild(const Child &) { return OT_ERROR_NOT_IMPLEMENTED; }
Neighbor *GetNeighbor(uint16_t aAddress) { return Mle::GetNeighbor(aAddress); }
Neighbor *GetNeighbor(const Mac::ExtAddress &aAddress) { return Mle::GetNeighbor(aAddress); }
Neighbor *GetNeighbor(const Mac::Address &aAddress) { return Mle::GetNeighbor(aAddress); }
Neighbor *GetNeighbor(const Ip6::Address &aAddress) { return Mle::GetNeighbor(aAddress); }
Neighbor *GetRxOnlyNeighborRouter(const Mac::Address &aAddress)
{
OT_UNUSED_VARIABLE(aAddress);
@@ -99,62 +74,17 @@ public:
otError GetNextNeighborInfo(otNeighborInfoIterator &, otNeighborInfo &) { return OT_ERROR_NOT_IMPLEMENTED; }
static int ComparePartitions(bool, const LeaderData &, bool, const LeaderData &) { return 0; }
void ResolveRoutingLoops(uint16_t, uint16_t) {}
otError CheckReachability(uint16_t aMeshSource, uint16_t aMeshDest, Ip6::Header &aIp6Header)
{
return Mle::CheckReachability(aMeshSource, aMeshDest, aIp6Header);
}
static bool IsRouterIdValid(uint8_t aRouterId) { return aRouterId <= kMaxRouterId; }
void FillConnectivityTlv(ConnectivityTlv &) {}
otError SendChildUpdateRequest(void) { return Mle::SendChildUpdateRequest(); }
#if OPENTHREAD_CONFIG_MLE_STEERING_DATA_SET_OOB_ENABLE
otError SetSteeringData(const otExtAddress *) { return OT_ERROR_NOT_IMPLEMENTED; }
#endif // OPENTHREAD_CONFIG_MLE_STEERING_DATA_SET_OOB_ENABLE
otError GetMaxChildTimeout(uint32_t &) { return OT_ERROR_NOT_IMPLEMENTED; }
bool HasSleepyChildrenSubscribed(const Ip6::Address &) { return false; }
bool IsSleepyChildSubscribed(const Ip6::Address &, Child &) { return false; }
private:
void HandleDetachStart(void) {}
otError HandleChildStart(AttachMode) { return OT_ERROR_NONE; }
otError HandleLinkRequest(const Message &, const Ip6::MessageInfo &, Neighbor *) { return OT_ERROR_DROP; }
otError HandleLinkAccept(const Message &, const Ip6::MessageInfo &, uint32_t, Neighbor *) { return OT_ERROR_DROP; }
otError HandleLinkAccept(const Message &, const Ip6::MessageInfo &, uint32_t, Neighbor *, bool)
{
return OT_ERROR_DROP;
}
otError HandleLinkAcceptAndRequest(const Message &, const Ip6::MessageInfo &, uint32_t, Neighbor *)
{
return OT_ERROR_DROP;
}
otError HandleAdvertisement(const Message &, const Ip6::MessageInfo &, Neighbor *) { return OT_ERROR_DROP; }
otError HandleParentRequest(const Message &, const Ip6::MessageInfo &) { return OT_ERROR_DROP; }
otError HandleChildIdRequest(const Message &, const Ip6::MessageInfo &, uint32_t) { return OT_ERROR_DROP; }
otError HandleChildUpdateRequest(const Message &, const Ip6::MessageInfo &, uint32_t) { return OT_ERROR_DROP; }
otError HandleChildUpdateResponse(const Message &, const Ip6::MessageInfo &, uint32_t, Neighbor *)
{
return OT_ERROR_DROP;
}
otError HandleDataRequest(const Message &, const Ip6::MessageInfo &, const Neighbor *) { return OT_ERROR_DROP; }
void HandleNetworkDataUpdateRouter(void) {}
otError HandleDiscoveryRequest(const Message &, const Ip6::MessageInfo &) { return OT_ERROR_DROP; }
void HandlePartitionChange(void) {}
void StopAdvertiseTimer(void) {}
otError ProcessRouteTlv(const RouteTlv &) { return OT_ERROR_NONE; }
#if OPENTHREAD_CONFIG_TIME_SYNC_ENABLE
otError HandleTimeSync(const Message &, const Ip6::MessageInfo &, const Neighbor *) { return OT_ERROR_DROP; }
#endif
ChildTable mChildTable;
RouterTable mRouterTable;
};