tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

wifi: mac80211: remove RX_DROP

Since it's hard to figure out what RX_DROP means when looking
at traces that drop packets in mac80211, add more specific drop
reasons and remove RX_DROP entirely.

Link: https://patch.msgid.link/20260116092025.79d995e87026.I7cde413988f7a382c551cd1c1e2b05a52ec71755@changeid
Signed-off-by: Johannes Berg <johannes.berg@intel.com>

Johannes Berg 58dc87d8 8a42938a

+94 -50
+44 -2
net/mac80211/drop.h
··· 2 2 /* 3 3 * mac80211 drop reason list 4 4 * 5 - * Copyright (C) 2023-2024 Intel Corporation 5 + * Copyright (C) 2023-2024, 2026 Intel Corporation 6 6 */ 7 7 8 8 #ifndef MAC80211_DROP_H ··· 65 65 /* 0x30 */ \ 66 66 R(RX_DROP_U_BAD_MGMT_KEYIDX) \ 67 67 R(RX_DROP_U_UNKNOWN_ACTION_REJECTED) \ 68 + R(RX_DROP_U_MESH_DS_BITS) \ 69 + R(RX_DROP_U_MESH_A3_MISMATCH) \ 70 + R(RX_DROP_U_MESH_NO_A4) \ 71 + R(RX_DROP_U_MESH_A4_MISMATCH) \ 72 + R(RX_DROP_U_MESH_UNEXP_DATA) \ 73 + R(RX_DROP_U_MESH_WRONG_ACTION) \ 74 + R(RX_DROP_U_MESH_UNEXP_MGMT) \ 75 + R(RX_DROP_U_SPURIOUS_NOTIF) \ 76 + R(RX_DROP_U_RUNT_DATA) \ 77 + R(RX_DROP_U_KEY_TAINTED) \ 78 + R(RX_DROP_U_UNPROTECTED) \ 79 + R(RX_DROP_U_MCAST_FRAGMENT) \ 80 + R(RX_DROP_U_DEFRAG_MISMATCH) \ 81 + R(RX_DROP_U_RUNT_MESH_DATA) \ 82 + /* 0x40 */ \ 83 + R(RX_DROP_U_MESH_NO_TTL) \ 84 + R(RX_DROP_U_MESH_RMC) \ 85 + R(RX_DROP_U_MESH_BAD_AE) \ 86 + R(RX_DROP_U_MESH_TTL_EXPIRED) \ 87 + R(RX_DROP_U_MESH_NOT_FORWARDING) \ 88 + R(RX_DROP_U_AMSDU_WITHOUT_DATA) \ 89 + R(RX_DROP_U_NULL_DATA) \ 90 + R(RX_DROP_U_UNEXPECTED_4ADDR) \ 91 + R(RX_DROP_U_PORT_CONTROL) \ 92 + R(RX_DROP_U_UNKNOWN_STA) \ 93 + R(RX_DROP_U_RUNT_BAR) \ 94 + R(RX_DROP_U_BAR_OUTSIDE_SESSION) \ 95 + R(RX_DROP_U_CTRL_FRAME) \ 96 + R(RX_DROP_U_RUNT_MGMT) \ 97 + R(RX_DROP_U_EXPECTED_MGMT) \ 98 + R(RX_DROP_U_NONBCAST_BEACON) \ 99 + /* 0x50 */ \ 100 + R(RX_DROP_U_MALFORMED_ACTION) \ 101 + R(RX_DROP_U_UNKNOWN_MCAST_ACTION) \ 102 + R(RX_DROP_U_UNEXPECTED_EXT_FRAME) \ 103 + R(RX_DROP_U_UNHANDLED_MGMT) \ 104 + R(RX_DROP_U_MCAST_DEAUTH) \ 105 + R(RX_DROP_U_UNHANDLED_DEAUTH) \ 106 + R(RX_DROP_U_MCAST_DISASSOC) \ 107 + R(RX_DROP_U_UNHANDLED_DISASSOC) \ 108 + R(RX_DROP_U_UNHANDLED_PREQ) \ 109 + R(RX_DROP_U_UNHANDLED_MGMT_STYPE) \ 110 + R(RX_DROP_U_NO_LINK) \ 68 111 /* this line for the trailing \ - add before this */ 69 112 70 113 /* having two enums allows for checking ieee80211_rx_result use with sparse */ ··· 128 85 enum mac80211_drop_reason { 129 86 RX_CONTINUE = (__force ieee80211_rx_result)___RX_CONTINUE, 130 87 RX_QUEUED = (__force ieee80211_rx_result)___RX_QUEUED, 131 - RX_DROP = (__force ieee80211_rx_result)___RX_DROP_UNUSABLE, 132 88 #define DEF(x) x = (__force ieee80211_rx_result)___ ## x, 133 89 MAC80211_DROP_REASONS_UNUSABLE(DEF) 134 90 #undef DEF
+50 -48
net/mac80211/rx.c
··· 6 6 * Copyright 2007-2010 Johannes Berg <johannes@sipsolutions.net> 7 7 * Copyright 2013-2014 Intel Mobile Communications GmbH 8 8 * Copyright(c) 2015 - 2017 Intel Deutschland GmbH 9 - * Copyright (C) 2018-2025 Intel Corporation 9 + * Copyright (C) 2018-2026 Intel Corporation 10 10 */ 11 11 12 12 #include <linux/jiffies.h> ··· 1137 1137 if (is_multicast_ether_addr(hdr->addr1)) { 1138 1138 if (ieee80211_has_tods(hdr->frame_control) || 1139 1139 !ieee80211_has_fromds(hdr->frame_control)) 1140 - return RX_DROP; 1140 + return RX_DROP_U_MESH_DS_BITS; 1141 1141 if (ether_addr_equal(hdr->addr3, dev_addr)) 1142 - return RX_DROP; 1142 + return RX_DROP_U_MESH_A3_MISMATCH; 1143 1143 } else { 1144 1144 if (!ieee80211_has_a4(hdr->frame_control)) 1145 - return RX_DROP; 1145 + return RX_DROP_U_MESH_NO_A4; 1146 1146 if (ether_addr_equal(hdr->addr4, dev_addr)) 1147 - return RX_DROP; 1147 + return RX_DROP_U_MESH_A4_MISMATCH; 1148 1148 } 1149 1149 } 1150 1150 ··· 1156 1156 struct ieee80211_mgmt *mgmt; 1157 1157 1158 1158 if (!ieee80211_is_mgmt(hdr->frame_control)) 1159 - return RX_DROP; 1159 + return RX_DROP_U_MESH_UNEXP_DATA; 1160 1160 1161 1161 if (ieee80211_is_action(hdr->frame_control)) { 1162 1162 u8 category; 1163 1163 1164 1164 /* make sure category field is present */ 1165 1165 if (rx->skb->len < IEEE80211_MIN_ACTION_SIZE) 1166 - return RX_DROP; 1166 + return RX_DROP_U_RUNT_ACTION; 1167 1167 1168 1168 mgmt = (struct ieee80211_mgmt *)hdr; 1169 1169 category = mgmt->u.action.category; 1170 1170 if (category != WLAN_CATEGORY_MESH_ACTION && 1171 1171 category != WLAN_CATEGORY_SELF_PROTECTED) 1172 - return RX_DROP; 1172 + return RX_DROP_U_MESH_WRONG_ACTION; 1173 1173 return RX_CONTINUE; 1174 1174 } 1175 1175 ··· 1179 1179 ieee80211_is_auth(hdr->frame_control)) 1180 1180 return RX_CONTINUE; 1181 1181 1182 - return RX_DROP; 1182 + return RX_DROP_U_MESH_UNEXP_MGMT; 1183 1183 } 1184 1184 1185 1185 return RX_CONTINUE; ··· 1605 1605 hdrlen = ieee80211_hdrlen(hdr->frame_control); 1606 1606 1607 1607 if (rx->skb->len < hdrlen + 8) 1608 - return RX_DROP; 1608 + return RX_DROP_U_RUNT_DATA; 1609 1609 1610 1610 skb_copy_bits(rx->skb, hdrlen + 6, &ethertype, 2); 1611 1611 if (ethertype == rx->sdata->control_port_protocol) ··· 1615 1615 if (rx->sdata->vif.type == NL80211_IFTYPE_AP && 1616 1616 cfg80211_rx_spurious_frame(rx->sdata->dev, hdr->addr2, 1617 1617 rx->link_id, GFP_ATOMIC)) 1618 - return RX_DROP_U_SPURIOUS; 1618 + return RX_DROP_U_SPURIOUS_NOTIF; 1619 1619 1620 - return RX_DROP; 1620 + return RX_DROP_U_SPURIOUS; 1621 1621 } 1622 1622 1623 1623 return RX_CONTINUE; ··· 2106 2106 if (rx->link_sta) { 2107 2107 if (ieee80211_is_group_privacy_action(skb) && 2108 2108 test_sta_flag(rx->sta, WLAN_STA_MFP)) 2109 - return RX_DROP; 2109 + return RX_DROP_U_UNPROTECTED; 2110 2110 2111 2111 rx->key = rcu_dereference(rx->link_sta->gtk[mmie_keyidx]); 2112 2112 } ··· 2191 2191 2192 2192 if (rx->key) { 2193 2193 if (unlikely(rx->key->flags & KEY_FLAG_TAINTED)) 2194 - return RX_DROP; 2194 + return RX_DROP_U_KEY_TAINTED; 2195 2195 2196 2196 /* TODO: add threshold stuff again */ 2197 2197 } else { 2198 - return RX_DROP; 2198 + return RX_DROP_U_UNPROTECTED; 2199 2199 } 2200 2200 2201 2201 switch (rx->key->conf.cipher) { ··· 2371 2371 goto out; 2372 2372 2373 2373 if (is_multicast_ether_addr(hdr->addr1)) 2374 - return RX_DROP; 2374 + return RX_DROP_U_MCAST_FRAGMENT; 2375 2375 2376 2376 I802_DEBUG_INC(rx->local->rx_handlers_fragments); 2377 2377 ··· 2426 2426 rx->seqno_idx, hdr); 2427 2427 if (!entry) { 2428 2428 I802_DEBUG_INC(rx->local->rx_handlers_drop_defrag); 2429 - return RX_DROP; 2429 + return RX_DROP_U_DEFRAG_MISMATCH; 2430 2430 } 2431 2431 2432 2432 /* "The receiver shall discard MSDUs and MMPDUs whose constituent ··· 2956 2956 return RX_CONTINUE; 2957 2957 2958 2958 if (!pskb_may_pull(skb, sizeof(*eth) + 6)) 2959 - return RX_DROP; 2959 + return RX_DROP_U_RUNT_MESH_DATA; 2960 2960 2961 2961 mesh_hdr = (struct ieee80211s_hdr *)(skb->data + sizeof(*eth)); 2962 2962 mesh_hdrlen = ieee80211_get_mesh_hdrlen(mesh_hdr); 2963 2963 2964 2964 if (!pskb_may_pull(skb, sizeof(*eth) + mesh_hdrlen)) 2965 - return RX_DROP; 2965 + return RX_DROP_U_RUNT_MESH_DATA; 2966 2966 2967 2967 eth = (struct ethhdr *)skb->data; 2968 2968 multicast = is_multicast_ether_addr(eth->h_dest); 2969 2969 2970 2970 mesh_hdr = (struct ieee80211s_hdr *)(eth + 1); 2971 2971 if (!mesh_hdr->ttl) 2972 - return RX_DROP; 2972 + return RX_DROP_U_MESH_NO_TTL; 2973 2973 2974 2974 /* frame is in RMC, don't forward */ 2975 2975 if (is_multicast_ether_addr(eth->h_dest) && 2976 2976 mesh_rmc_check(sdata, eth->h_source, mesh_hdr)) 2977 - return RX_DROP; 2977 + return RX_DROP_U_MESH_RMC; 2978 2978 2979 2979 /* forward packet */ 2980 2980 if (sdata->crypto_tx_tailroom_needed_cnt) ··· 2991 2991 /* has_a4 already checked in ieee80211_rx_mesh_check */ 2992 2992 proxied_addr = mesh_hdr->eaddr2; 2993 2993 else 2994 - return RX_DROP; 2994 + return RX_DROP_U_MESH_BAD_AE; 2995 2995 2996 2996 rcu_read_lock(); 2997 2997 mppath = mpp_path_lookup(sdata, proxied_addr); ··· 3023 3023 goto rx_accept; 3024 3024 3025 3025 IEEE80211_IFSTA_MESH_CTR_INC(ifmsh, dropped_frames_ttl); 3026 - return RX_DROP; 3026 + return RX_DROP_U_MESH_TTL_EXPIRED; 3027 3027 } 3028 3028 3029 3029 if (!ifmsh->mshcfg.dot11MeshForwarding) { 3030 3030 if (is_multicast_ether_addr(eth->h_dest)) 3031 3031 goto rx_accept; 3032 3032 3033 - return RX_DROP; 3033 + return RX_DROP_U_MESH_NOT_FORWARDING; 3034 3034 } 3035 3035 3036 3036 skb_set_queue_mapping(skb, ieee802_1d_to_ac[skb->priority]); ··· 3216 3216 return RX_CONTINUE; 3217 3217 3218 3218 if (unlikely(!ieee80211_is_data_present(fc))) 3219 - return RX_DROP; 3219 + return RX_DROP_U_AMSDU_WITHOUT_DATA; 3220 3220 3221 3221 if (unlikely(ieee80211_has_a4(hdr->frame_control))) { 3222 3222 switch (rx->sdata->vif.type) { ··· 3273 3273 return RX_CONTINUE; 3274 3274 3275 3275 if (unlikely(!ieee80211_is_data_present(hdr->frame_control))) 3276 - return RX_DROP; 3276 + return RX_DROP_U_NULL_DATA; 3277 3277 3278 3278 /* Send unexpected-4addr-frame event to hostapd */ 3279 3279 if (ieee80211_has_a4(hdr->frame_control) && ··· 3283 3283 cfg80211_rx_unexpected_4addr_frame( 3284 3284 rx->sdata->dev, rx->sta->sta.addr, rx->link_id, 3285 3285 GFP_ATOMIC); 3286 - return RX_DROP; 3286 + return RX_DROP_U_UNEXPECTED_4ADDR; 3287 3287 } 3288 3288 3289 3289 res = __ieee80211_data_to_8023(rx, &port_control); ··· 3295 3295 return res; 3296 3296 3297 3297 if (!ieee80211_frame_allowed(rx, fc)) 3298 - return RX_DROP; 3298 + return RX_DROP_U_PORT_CONTROL; 3299 3299 3300 3300 /* directly handle TDLS channel switch requests/responses */ 3301 3301 if (unlikely(((struct ethhdr *)rx->skb->data)->h_proto == ··· 3360 3360 }; 3361 3361 3362 3362 if (!rx->sta) 3363 - return RX_DROP; 3363 + return RX_DROP_U_UNKNOWN_STA; 3364 3364 3365 3365 if (skb_copy_bits(skb, offsetof(struct ieee80211_bar, control), 3366 3366 &bar_data, sizeof(bar_data))) 3367 - return RX_DROP; 3367 + return RX_DROP_U_RUNT_BAR; 3368 3368 3369 3369 tid = le16_to_cpu(bar_data.control) >> 12; 3370 3370 ··· 3376 3376 3377 3377 tid_agg_rx = rcu_dereference(rx->sta->ampdu_mlme.tid_rx[tid]); 3378 3378 if (!tid_agg_rx) 3379 - return RX_DROP; 3379 + return RX_DROP_U_BAR_OUTSIDE_SESSION; 3380 3380 3381 3381 start_seq_num = le16_to_cpu(bar_data.start_seq_num) >> 4; 3382 3382 event.u.ba.tid = tid; ··· 3400 3400 return RX_QUEUED; 3401 3401 } 3402 3402 3403 - return RX_DROP; 3403 + return RX_DROP_U_CTRL_FRAME; 3404 3404 } 3405 3405 3406 3406 static void ieee80211_process_sa_query_req(struct ieee80211_sub_if_data *sdata, ··· 3509 3509 * and unknown (reserved) frames are useless. 3510 3510 */ 3511 3511 if (rx->skb->len < 24) 3512 - return RX_DROP; 3512 + return RX_DROP_U_RUNT_MGMT; 3513 3513 3514 3514 if (!ieee80211_is_mgmt(mgmt->frame_control)) 3515 - return RX_DROP; 3515 + return RX_DROP_U_EXPECTED_MGMT; 3516 3516 3517 3517 /* drop too small action frames */ 3518 3518 if (ieee80211_is_action(mgmt->frame_control) && ··· 3522 3522 /* Drop non-broadcast Beacon frames */ 3523 3523 if (ieee80211_is_beacon(mgmt->frame_control) && 3524 3524 !is_broadcast_ether_addr(mgmt->da)) 3525 - return RX_DROP; 3525 + return RX_DROP_U_NONBCAST_BEACON; 3526 3526 3527 3527 if (rx->sdata->vif.type == NL80211_IFTYPE_AP && 3528 3528 ieee80211_is_beacon(mgmt->frame_control) && ··· 4054 4054 if (!(status->rx_flags & IEEE80211_RX_MALFORMED_ACTION_FRM) && 4055 4055 (sdata->vif.type == NL80211_IFTYPE_AP || 4056 4056 sdata->vif.type == NL80211_IFTYPE_AP_VLAN)) 4057 - return RX_DROP; 4057 + return RX_DROP_U_MALFORMED_ACTION; 4058 4058 4059 4059 if (is_multicast_ether_addr(mgmt->da)) 4060 - return RX_DROP; 4060 + return RX_DROP_U_UNKNOWN_MCAST_ACTION; 4061 4061 4062 4062 /* do not return rejected action frames */ 4063 4063 if (mgmt->u.action.category & 0x80) ··· 4102 4102 return RX_CONTINUE; 4103 4103 4104 4104 if (sdata->vif.type != NL80211_IFTYPE_STATION) 4105 - return RX_DROP; 4105 + return RX_DROP_U_UNEXPECTED_EXT_FRAME; 4106 4106 4107 4107 /* for now only beacons are ext, so queue them */ 4108 4108 ieee80211_queue_skb_to_iface(sdata, rx->link_id, rx->sta, rx->skb); ··· 4123 4123 sdata->vif.type != NL80211_IFTYPE_ADHOC && 4124 4124 sdata->vif.type != NL80211_IFTYPE_OCB && 4125 4125 sdata->vif.type != NL80211_IFTYPE_STATION) 4126 - return RX_DROP; 4126 + return RX_DROP_U_UNHANDLED_MGMT; 4127 4127 4128 4128 switch (stype) { 4129 4129 case cpu_to_le16(IEEE80211_STYPE_AUTH): ··· 4134 4134 case cpu_to_le16(IEEE80211_STYPE_DEAUTH): 4135 4135 if (is_multicast_ether_addr(mgmt->da) && 4136 4136 !is_broadcast_ether_addr(mgmt->da)) 4137 - return RX_DROP; 4137 + return RX_DROP_U_MCAST_DEAUTH; 4138 4138 4139 4139 /* process only for station/IBSS */ 4140 4140 if (sdata->vif.type != NL80211_IFTYPE_STATION && 4141 4141 sdata->vif.type != NL80211_IFTYPE_ADHOC) 4142 - return RX_DROP; 4142 + return RX_DROP_U_UNHANDLED_DEAUTH; 4143 4143 break; 4144 4144 case cpu_to_le16(IEEE80211_STYPE_ASSOC_RESP): 4145 4145 case cpu_to_le16(IEEE80211_STYPE_REASSOC_RESP): 4146 4146 case cpu_to_le16(IEEE80211_STYPE_DISASSOC): 4147 4147 if (is_multicast_ether_addr(mgmt->da) && 4148 4148 !is_broadcast_ether_addr(mgmt->da)) 4149 - return RX_DROP; 4149 + return RX_DROP_U_MCAST_DISASSOC; 4150 4150 4151 4151 /* process only for station */ 4152 4152 if (sdata->vif.type != NL80211_IFTYPE_STATION) 4153 - return RX_DROP; 4153 + return RX_DROP_U_UNHANDLED_DISASSOC; 4154 4154 break; 4155 4155 case cpu_to_le16(IEEE80211_STYPE_PROBE_REQ): 4156 4156 /* process only for ibss and mesh */ 4157 4157 if (sdata->vif.type != NL80211_IFTYPE_ADHOC && 4158 4158 sdata->vif.type != NL80211_IFTYPE_MESH_POINT) 4159 - return RX_DROP; 4159 + return RX_DROP_U_UNHANDLED_PREQ; 4160 4160 break; 4161 4161 default: 4162 - return RX_DROP; 4162 + return RX_DROP_U_UNHANDLED_MGMT_STYPE; 4163 4163 } 4164 4164 4165 4165 ieee80211_queue_skb_to_iface(sdata, rx->link_id, rx->sta, rx->skb); ··· 4187 4187 static void ieee80211_rx_handlers(struct ieee80211_rx_data *rx, 4188 4188 struct sk_buff_head *frames) 4189 4189 { 4190 - ieee80211_rx_result res = RX_DROP; 4190 + ieee80211_rx_result res; 4191 4191 struct sk_buff *skb; 4192 4192 4193 4193 #define CALL_RXH(rxh) \ ··· 4213 4213 */ 4214 4214 rx->skb = skb; 4215 4215 4216 - if (WARN_ON_ONCE(!rx->link)) 4216 + if (WARN_ON_ONCE(!rx->link)) { 4217 + res = RX_DROP_U_NO_LINK; 4217 4218 goto rxh_next; 4219 + } 4218 4220 4219 4221 CALL_RXH(ieee80211_rx_h_check_more_data); 4220 4222 CALL_RXH(ieee80211_rx_h_uapsd_and_pspoll); ··· 4253 4251 static void ieee80211_invoke_rx_handlers(struct ieee80211_rx_data *rx) 4254 4252 { 4255 4253 struct sk_buff_head reorder_release; 4256 - ieee80211_rx_result res = RX_DROP; 4254 + ieee80211_rx_result res; 4257 4255 4258 4256 __skb_queue_head_init(&reorder_release); 4259 4257