This commit provides a mechanism for the host drivers to advertise the
support for different beacon intervals among the respective interface
combinations in a group, through diff_beacon_int_gcd_min (u32).
Following sets the expectation for diff_beacon_int_gcd_min.
= 0 - all beacon intervals for different interfaces must be same.
> 0 - any beacon interval for the interface part of this combination
must also be bigger than this value
Signed-off-by: Purushottam Kushwaha <[email protected]>
---
include/net/cfg80211.h | 9 +++++++-
include/uapi/linux/nl80211.h | 8 +++++--
net/wireless/core.h | 2 +-
net/wireless/nl80211.c | 13 ++++++++---
net/wireless/util.c | 53 +++++++++++++++++++++++++++++++++++++++++---
5 files changed, 75 insertions(+), 10 deletions(-)
diff --git a/include/net/cfg80211.h b/include/net/cfg80211.h
index c58afc8..b149a57 100644
--- a/include/net/cfg80211.h
+++ b/include/net/cfg80211.h
@@ -2943,6 +2943,11 @@ struct ieee80211_iface_limit {
* only in special cases.
* @radar_detect_widths: bitmap of channel widths supported for radar detection
* @radar_detect_regions: bitmap of regions supported for radar detection
+ * @beacon_int_min_gcd: This interface combination supports different
+ * beacon intervals.
+ * = 0 - all beacon intervals for different interface must be same.
+ * > 0 - any beacon interval for the interface part of this combination
+ * must also be bigger than this value
*
* With this structure the driver can describe which interface
* combinations it supports concurrently.
@@ -2963,7 +2968,7 @@ struct ieee80211_iface_limit {
* };
*
*
- * 2. Allow #{AP, P2P-GO} <= 8, channels = 1, 8 total:
+ * 2. Allow #{AP, P2P-GO} <= 8, BI min gcd = 10, channels = 1, 8 total:
*
* struct ieee80211_iface_limit limits2[] = {
* { .max = 8, .types = BIT(NL80211_IFTYPE_AP) |
@@ -2974,6 +2979,7 @@ struct ieee80211_iface_limit {
* .n_limits = ARRAY_SIZE(limits2),
* .max_interfaces = 8,
* .num_different_channels = 1,
+ * .beacon_int_min_gcd = 10,
* };
*
*
@@ -3001,6 +3007,7 @@ struct ieee80211_iface_combination {
bool beacon_int_infra_match;
u8 radar_detect_widths;
u8 radar_detect_regions;
+ u32 beacon_int_min_gcd;
};
struct ieee80211_txrx_stypes {
diff --git a/include/uapi/linux/nl80211.h b/include/uapi/linux/nl80211.h
index 2206941..5770d4f 100644
--- a/include/uapi/linux/nl80211.h
+++ b/include/uapi/linux/nl80211.h
@@ -4203,6 +4203,9 @@ enum nl80211_iface_limit_attrs {
* of supported channel widths for radar detection.
* @NL80211_IFACE_COMB_RADAR_DETECT_REGIONS: u32 attribute containing the bitmap
* of supported regulatory regions for radar detection.
+ * @NL80211_IFACE_COMB_BI_MIN_GCD: u32 attribute specifying the minimum GCD of
+ * different beacon intervals supported by all the interface combinations
+ * in this group (if not present, all beacon interval must match).
* @NUM_NL80211_IFACE_COMB: number of attributes
* @MAX_NL80211_IFACE_COMB: highest attribute number
*
@@ -4210,8 +4213,8 @@ enum nl80211_iface_limit_attrs {
* limits = [ #{STA} <= 1, #{AP} <= 1 ], matching BI, channels = 1, max = 2
* => allows an AP and a STA that must match BIs
*
- * numbers = [ #{AP, P2P-GO} <= 8 ], channels = 1, max = 8
- * => allows 8 of AP/GO
+ * numbers = [ #{AP, P2P-GO} <= 8 ], BI min gcd, channels = 1, max = 8,
+ * => allows 8 of AP/GO that can have BI gcd >= min gcd
*
* numbers = [ #{STA} <= 2 ], channels = 2, max = 2
* => allows two STAs on different channels
@@ -4237,6 +4240,7 @@ enum nl80211_if_combination_attrs {
NL80211_IFACE_COMB_NUM_CHANNELS,
NL80211_IFACE_COMB_RADAR_DETECT_WIDTHS,
NL80211_IFACE_COMB_RADAR_DETECT_REGIONS,
+ NL80211_IFACE_COMB_BI_MIN_GCD,
/* keep last */
NUM_NL80211_IFACE_COMB,
diff --git a/net/wireless/core.h b/net/wireless/core.h
index eee9144..5fffe58 100644
--- a/net/wireless/core.h
+++ b/net/wireless/core.h
@@ -475,7 +475,7 @@ int ieee80211_get_ratemask(struct ieee80211_supported_band *sband,
u32 *mask);
int cfg80211_validate_beacon_int(struct cfg80211_registered_device *rdev,
- u32 beacon_int);
+ enum nl80211_iftype iftype, u32 beacon_int);
void cfg80211_update_iface_num(struct cfg80211_registered_device *rdev,
enum nl80211_iftype iftype, int num);
diff --git a/net/wireless/nl80211.c b/net/wireless/nl80211.c
index 047bd26..4ee01ad 100644
--- a/net/wireless/nl80211.c
+++ b/net/wireless/nl80211.c
@@ -1020,6 +1020,10 @@ static int nl80211_put_iface_combinations(struct wiphy *wiphy,
nla_put_u32(msg, NL80211_IFACE_COMB_RADAR_DETECT_REGIONS,
c->radar_detect_regions)))
goto nla_put_failure;
+ if (c->beacon_int_min_gcd &&
+ nla_put_u32(msg, NL80211_IFACE_COMB_BI_MIN_GCD,
+ c->beacon_int_min_gcd))
+ goto nla_put_failure;
nla_nest_end(msg, nl_combi);
}
@@ -3692,7 +3696,8 @@ static int nl80211_start_ap(struct sk_buff *skb, struct genl_info *info)
params.dtim_period =
nla_get_u32(info->attrs[NL80211_ATTR_DTIM_PERIOD]);
- err = cfg80211_validate_beacon_int(rdev, params.beacon_interval);
+ err = cfg80211_validate_beacon_int(rdev, dev->ieee80211_ptr->iftype,
+ params.beacon_interval);
if (err)
return err;
@@ -8063,7 +8068,8 @@ static int nl80211_join_ibss(struct sk_buff *skb, struct genl_info *info)
ibss.beacon_interval =
nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
- err = cfg80211_validate_beacon_int(rdev, ibss.beacon_interval);
+ err = cfg80211_validate_beacon_int(rdev, NL80211_IFTYPE_ADHOC,
+ ibss.beacon_interval);
if (err)
return err;
@@ -9323,7 +9329,8 @@ static int nl80211_join_mesh(struct sk_buff *skb, struct genl_info *info)
setup.beacon_interval =
nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
- err = cfg80211_validate_beacon_int(rdev, setup.beacon_interval);
+ err = cfg80211_validate_beacon_int(rdev, NL80211_IFTYPE_MESH_POINT,
+ setup.beacon_interval);
if (err)
return err;
}
diff --git a/net/wireless/util.c b/net/wireless/util.c
index 0675f51..ee8e5c5 100644
--- a/net/wireless/util.c
+++ b/net/wireless/util.c
@@ -1553,25 +1553,72 @@ bool ieee80211_chandef_to_operating_class(struct cfg80211_chan_def *chandef,
}
EXPORT_SYMBOL(ieee80211_chandef_to_operating_class);
+static void
+cfg80211_get_beacon_int_min_gcd(const struct ieee80211_iface_combination *c,
+ void *data)
+{
+ u32 *gcd = data;
+
+ /* Get the least beacon_int_min_gcd among the matched combinations */
+ if (c->beacon_int_min_gcd) {
+ if (*gcd) {
+ if (*gcd > c->beacon_int_min_gcd)
+ *gcd = c->beacon_int_min_gcd;
+ } else {
+ *gcd = c->beacon_int_min_gcd;
+ }
+ }
+}
+
int cfg80211_validate_beacon_int(struct cfg80211_registered_device *rdev,
- u32 beacon_int)
+ enum nl80211_iftype iftype, u32 beacon_int)
{
struct wireless_dev *wdev;
int res = 0;
+ u32 min_gcd = 0;
+ u32 bi_prev, tmp_bi, gcd;
+ int iftype_num[NUM_NL80211_IFTYPES];
if (beacon_int < 10 || beacon_int > 10000)
return -EINVAL;
+ memset(iftype_num, 0, sizeof(iftype_num));
+ list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
+ if (!wdev->beacon_interval)
+ continue;
+ iftype_num[wdev->iftype]++;
+ }
+ iftype_num[iftype]++;
+
+ res = cfg80211_iter_combinations(&rdev->wiphy, 0, 0, iftype_num,
+ cfg80211_get_beacon_int_min_gcd,
+ &min_gcd);
+ if (res)
+ return res;
+
+ /* GCD(n) = n */
+ gcd = beacon_int;
list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
if (!wdev->beacon_interval)
continue;
if (wdev->beacon_interval != beacon_int) {
- res = -EINVAL;
+ /* beacon_int_min_gcd=0 or not specified, all
+ * beacon interval of this combination must match
+ */
+ if (min_gcd == 0)
+ return -EINVAL;
+ /* Get the GCD */
+ bi_prev = wdev->beacon_interval;
+ while (bi_prev != 0) {
+ tmp_bi = bi_prev;
+ bi_prev = gcd % bi_prev;
+ gcd = tmp_bi;
+ }
break;
}
}
- return res;
+ return (gcd < min_gcd) ? -EINVAL : 0;
}
int cfg80211_iter_combinations(struct wiphy *wiphy,
--
1.9.1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PkluIG9yZGVyIHRvIHZhbGlkYXRlIGEgbmV3IGJlYWNvbiBpbnRlcnZhbCwgeW91J3JlIGZpcnN0
IGxvb2tpbmcgdXAgdGhlIG1pbiBHQ0QgdmFsdWUgb2YgYWxsIHRoZSBjb21iaW5hdGlvbnMgdGhh
dCBhbGxvdyB0aGUgKmN1cnJlbnQqIHNjZW5hcmlvLCBidXQgZG9pbmcgdGhhdCBtYXRjaGluZyB3
aXRob3V0IHRoZSByaWdodCAjIG9mIGNoYW5uZWxzIG9yID5yYWRhciBkZXRlY3QgcGFyYW1ldGVy
cz8gQW5kIHRoZW4geW91J3JlIHRyeWluZyB0byBtYXRjaCB0aGF0IHRvIHRoZSBuZXcgYmVhY29u
IGludGVydmFsPw0KWWVzIC4gUGxlYXNlIGFsbG93IHVzIHRvIGV4cGxhaW4gdGhlIHJhdGlvbmFs
ZSBmb3IgZG9pbmcgc28uIA0KMS4gVGhlIGludGVudGlvbiBoZXJlIGlzIHRvIGVuc3VyZSB0aGF0
IHRoZSBiZWFjb24gaW50ZXJ2YWwgY29uZmlndXJlZCBmb3IgYW55IHNpbmdsZSBpbnRlcmZhY2Ug
aXMgZ3JlYXRlciB0aGFuIHRoZSAiZGlmZl9iZWFjb25faW50X2djZF9taW4iICBzcGVjaWZpZWQg
aW4gdGhlIHJlc3BlY3RpdmUgY29tYmluYXRpb25zLiAgDQoyLiBTaW5jZSAiZGlmZl9iZWFjb25f
aW50X2djZF9taW4iICBpcyBvbmx5IHNwZWNpZmllZCAvIGFkdmVydGlzZWQgaW4gdGhlIGludGVy
ZmFjZSBjb21iaW5hdGlvbnMgLCBvdXIgbG9naWMgd2FzIHRvIGdldCB0aGUgbWluaW1hbCAiZGlm
Zl9iZWFjb25faW50X2djZF9taW4iIG9mIGFsbCB0aGUgbWF0Y2hpbmcgY29tYmluYXRpb25zIGFu
ZCBsYXRlciANCiAgICBjb21wYXJlIHdpdGggdGhlIG5ldyBiZWFjb24gaW50ZXJ2YWwuIChBUEkg
ImNmZzgwMjExX2l0ZXJfY29tYmluYXRpb25zIiBoYXMgdG8gYmUgaW52b2tlZCB0byBnZXQgdGhl
IGNvcnJlc3BvbmRpbmcgImRpZmZfYmVhY29uX2ludF9nY2RfbWluIikNCjMuIElmIHRoZSBiZWFj
b24gaW50ZXJ2YWwgY29uZmlndXJlZCBuZWVkcyB0byBiZSBlbnN1cmVkIHRvIGJlIGdyZWF0ZXIg
dGhhbiB0aGUgImRpZmZfYmVhY29uX2ludF9nY2RfbWluIiBjb25maWd1cmVkIGZvciBib3RoIHRo
ZSAic2luZ2xlIGludGVyZmFjZSIgYW5kICJpbnRlcmZhY2UgY29tYmluYXRpb24iICwgd2UgaGF2
ZSByZXNvcnRlZCB0byANCiAgICAgIjIiICAoZ2V0IHRoZSBtaW5pbWFsIG9mICJkaWZmX2JlYWNv
bl9pbnRfZ2NkX21pbiIgYW1vbmcgYWxsIHRoZSBtYXRjaGVkIGludGVyZmFjZSBjb21iaW5hdGlv
bnMgYW5kIHRoZW4gY29tcGFyZSBpdCB3aXRoIHRoZSBjb25maWd1cmVkIGJlYWNvbiBpbnRlcnZh
bCkuIA0KDQo+SWYgdGhlIGRyaXZlciBzcGVjaWZpZWQgZGlmZl9iZWFjb25faW50X2djZF9taW4s
IHRoZW4gZG9uJ3QgZG8gYW55dGhpbmcgaW4gY2ZnODAyMTFfdmFsaWRhdGVfYmVhY29uX2ludCgp
LCBvdGhlciB0aGFuIHBlcmhhcHMgYSBtaW5pbWFsIHJhbmdlIGNoZWNrIGFnYWluc3QgdGhlIG1p
bmltdW0gb2YgYWxsID5kaWZmX2JlYWNvbl9pbnRfZ2NkX21pbiB2YWx1ZXMgZm9yIGFsbCBjb21i
aW5hdGlvbnMuDQo+IFRoYXQgbmV3IGFyZ3VtZW50IGNvdWxkIGJlIG1hZGUgdGhlIEdDRCBvZiBh
bGwgZXhpc3RpbmcgYmVhY29uaW5nIGludGVyZmFjZXMgKG9yIDAgaWYgbm8gc3VjaCBleGlzdHMp
LCBzaW5jZSB0aGF0J3Mgc3VmZmljaWVudCBmb3IgY2hlY2tpbmcgYWdhaW5zdCBhIG5ldyBtaW5f
Z2NkLg0KSWYgSSB1bmRlcnN0YW5kIHRoaXMgY29ycmVjdGx5ICwgYXJlIHlvdSBzYXlpbmcgdGhh
dCB0aGlzIG5ldyBhcmd1bWVudCB0byBjZmc4MDIxMV9pdGVyX2NvbWJpbmF0aW9ucyBzaGFsbCBi
ZSB0aGUgR0NEIG9mIGFsbCB0aGUgZXhpc3RpbmcgYmVhY29uIGludGVydmFscyBhbmQgd291bGQg
YmUgdXNlZCB0byBtYXRjaCB3aXRoIHRoZSBjb3JyZXNwb25kaW5nICJkaWZmX2JlYWNvbl9pbnRf
Z2NkX21pbiIgb2YgdGhlIGludGVyZmFjZSBjb21iaW5hdGlvbnMgaW4gImNmZzgwMjExX2l0ZXJf
Y29tYmluYXRpb25zIi4gDQpJZiB5ZXMgLCB0aGlzIEdDRCBhcmd1bWVudCBkb2VzIG5vdCByZXBy
ZXNlbnQgLCBpZiB0aGUgYmVhY29uIGludGVydmFscyBvZiBhbGwgdGhlIGV4aXN0aW5nIGludGVy
ZmFjZXMgZGlmZmVyIG9yIG5vdCAsIGlzbuKAmXQgPyBJZiB0aGUgImRpZmZfYmVhY29uX2ludF9n
Y2RfbWluIiAgb2YgdGhlIGFsbCB0aGUgbWF0Y2hpbmcgaW50ZXJmYWNlIGNvbWJpbmF0aW9ucyBp
cyAwICwgc3VjaCBkaWZmZXJlZCBiZWFjb24gaW50ZXJ2YWxzIHdvdWxkIHBhc3MgdGhlIGNoZWNr
ICwgY29udHJhZGljdGluZyB0aGUgZXhpc3RpbmcgbG9naWMgKCBub3QgYWxsb3dpbmcgdGhlIGRp
ZmZlcmVkIGJlYWNvbiBpbnRlcnZhbHMpLCBpc24ndCA/IA0KDQpUaHVzLCB3b3VsZG4ndCBpdCBi
ZSBhIGJldHRlciBvcHRpb24gdG8gZmlyc3QgZ2V0IHRoZSAiZGlmZl9iZWFjb25faW50X2djZF9t
aW4iIGFkdmVydGlzZWQgYnkgdGhlIHJlc3BlY3RpdmUgaW50ZXJmYWNlIGNvbWJpbmF0aW9ucyBh
bmQgdGhlbiBsYXRlciBjb21wYXJlIGl0IHdpdGggdGhlIGNvbmZpZ3VyZWQgLyBjYWxjdWxhdGVk
IGJlYWNvbiANCmludGVydmFsJ3MgR0NEIC4gDQpBbHNvICwgbm90IHF1aXRlIHN1cmUgaG93IHdv
dWxkIHlvdXIgY29tbWVudCAiIG1hdGNoaW5nIHdpdGhvdXQgdGhlIHJpZ2h0ICMgb2YgY2hhbm5l
bHMgb3IgcmFkYXIgZGV0ZWN0IHBhcmFtZXRlcnMiIGdldCBhZGRyZXNzZWQgd2l0aCB5b3VyIG5l
dyBwcm9wb3NhbCAoIGFkZGluZyBhIG5ldyBhcmd1bWVudCB0byAiY2ZnODAyMTFfaXRlcl9jb21i
aW5hdGlvbnMiICkgDQoNClJlZ2FyZHMsDQpTdW5pbA0KDQoNCg0KDQoNCi0tLS0tT3JpZ2luYWwg
TWVzc2FnZS0tLS0tDQpGcm9tOiBKb2hhbm5lcyBCZXJnIFttYWlsdG86am9oYW5uZXNAc2lwc29s
dXRpb25zLm5ldF0gDQpTZW50OiBNb25kYXksIFNlcHRlbWJlciAxMiwgMjAxNiAzOjU0IFBNDQpU
bzogS3VzaHdhaGEsIFB1cnVzaG90dGFtIDxwa3VzaHdhaEBxdGkucXVhbGNvbW0uY29tPg0KQ2M6
IGxpbnV4LXdpcmVsZXNzQHZnZXIua2VybmVsLm9yZzsgTWFsaW5lbiwgSm91bmkgPGpvdW5pQHFj
YS5xdWFsY29tbS5jb20+OyBVbmRla2FyaSwgU3VuaWwgRHV0dCA8dXNkdXR0QHF0aS5xdWFsY29t
bS5jb20+OyBIdWxsdXIgU3VicmFtYW55YW0sIEFtYXJuYXRoIDxhbWFybmF0aEBxY2EucXVhbGNv
bW0uY29tPg0KU3ViamVjdDogUmU6IFtQQVRDSCB2OF0gY2ZnODAyMTE6IFByb3Zpc2lvbiB0byBh
bGxvdyB0aGUgc3VwcG9ydCBmb3IgZGlmZmVyZW50IGJlYWNvbiBpbnRlcnZhbHMNCg0KSG1tLiBB
cGFydCBmcm9tIHNvbWUgbWlzbGVhZGluZyBkb2N1bWVudGF0aW9uLCB0aGF0IGRvZXNuJ3QgbWVu
dGlvbiAiR0NEIiBhdCBhbGwsIHRoZSBsb2dpYyBzZWVtcyBvZGQuDQoNCkluIG9yZGVyIHRvIHZh
bGlkYXRlIGEgbmV3IGJlYWNvbiBpbnRlcnZhbCwgeW91J3JlIGZpcnN0IGxvb2tpbmcgdXAgdGhl
IG1pbiBHQ0QgdmFsdWUgb2YgYWxsIHRoZSBjb21iaW5hdGlvbnMgdGhhdCBhbGxvdyB0aGUgKmN1
cnJlbnQqIHNjZW5hcmlvLCBidXQgZG9pbmcgdGhhdCBtYXRjaGluZyB3aXRob3V0IHRoZSByaWdo
dCAjIG9mIGNoYW5uZWxzIG9yIHJhZGFyIGRldGVjdCBwYXJhbWV0ZXJzPyBBbmQgdGhlbiB5b3Un
cmUgdHJ5aW5nIHRvIG1hdGNoIHRoYXQgdG8gdGhlIG5ldyBiZWFjb24gaW50ZXJ2YWw/DQoNCkl0
IHNlZW1zIHRvIG1lIHRoYXQgdGhlIGxvZ2ljIHNob3VsZCBiZSBzb21ldGhpbmcgbGlrZToNCg0K
SWYgdGhlIGRyaXZlciBzcGVjaWZpZWTCoGRpZmZfYmVhY29uX2ludF9nY2RfbWluLCB0aGVuIGRv
bid0IGRvIGFueXRoaW5nIGluwqBjZmc4MDIxMV92YWxpZGF0ZV9iZWFjb25faW50KCksIG90aGVy
IHRoYW4gcGVyaGFwcyBhIG1pbmltYWwgcmFuZ2UgY2hlY2sgYWdhaW5zdCB0aGUgbWluaW11bSBv
ZiBhbGwgZGlmZl9iZWFjb25faW50X2djZF9taW4gdmFsdWVzIGZvciBhbGwgY29tYmluYXRpb25z
Lg0KDQpUaGVuLCBhZGQgYSBuZXcgYXJndW1lbnQgdG/CoGNmZzgwMjExX2NoZWNrX2NvbWJpbmF0
aW9ucygpIChhbmQNCmNmZzgwMjExX2l0ZXJfY29tYmluYXRpb25zKCkpIHRvIGhhdmUgdGhlIGJl
YWNvbiBpbnRlcnZhbHMgZm9yIGVhY2ggYmVhY29uaW5nIGludGVyZmFjZSwgYW5kIHVzZSB0aGF0
IGluIG9yZGVyIHRvIG1hdGNoIGlmIGEgY29tYmluYXRpb24gZml0cywgaW5zaWRlwqBjZmc4MDIx
MV9pdGVyX2NvbWJpbmF0aW9ucygpLg0KDQpUaGF0IG5ldyBhcmd1bWVudCBjb3VsZCBiZSBtYWRl
IHRoZSBHQ0Qgb2YgYWxsIGV4aXN0aW5nIGJlYWNvbmluZyBpbnRlcmZhY2VzIChvciAwIGlmIG5v
IHN1Y2ggZXhpc3RzKSwgc2luY2UgdGhhdCdzIHN1ZmZpY2llbnQgZm9yIGNoZWNraW5nIGFnYWlu
c3QgYSBuZXcgbWluX2djZC4NCg0Kam9oYW5uZXMNCg==
Hmm. Apart from some misleading documentation, that doesn't mention
"GCD" at all, the logic seems odd.
In order to validate a new beacon interval, you're first looking up the
min GCD value of all the combinations that allow the *current*
scenario, but doing that matching without the right # of channels or
radar detect parameters? And then you're trying to match that to the
new beacon interval?
It seems to me that the logic should be something like:
If the driver specified diff_beacon_int_gcd_min, then don't do anything
in cfg80211_validate_beacon_int(), other than perhaps a minimal range
check against the minimum of all diff_beacon_int_gcd_min values for all
combinations.
Then, add a new argument to cfg80211_check_combinations() (and
cfg80211_iter_combinations()) to have the beacon intervals for each
beaconing interface, and use that in order to match if a combination
fits, inside cfg80211_iter_combinations().
That new argument could be made the GCD of all existing beaconing
interfaces (or 0 if no such exists), since that's sufficient for
checking against a new min_gcd.
johannes
Hi,
Sorry for the long delay.
> > In order to validate a new beacon interval, you're first looking up
> > the min GCD value of all the combinations that allow the *current*
> > scenario, but doing that matching without the right # of channels
> > or radar detect parameters? And then you're trying to match that to
> > the new beacon interval?
> Yes . Please allow us to explain the rationale for doing so.
> 1. The intention here is to ensure that the beacon interval
> configured for any single interface is greater than the
> "diff_beacon_int_gcd_min" specified in the respective
> combinations.
Sure, ok, so far so good - not that I think it would really be
necessary to validate it this way, but ok.
> 2. Since "diff_beacon_int_gcd_min" is only specified / advertised in
> the interface combinations , our logic was to get the minimal
> "diff_beacon_int_gcd_min" of all the matching combinations and later
> compare with the new beacon interval. (API
> "cfg80211_iter_combinations" has to be invoked to get the
> corresponding "diff_beacon_int_gcd_min")
Yeah, but you get the diff_beacon_int_gcd_min for all combinations that
allow the *current* combination of interfaces, not the combinations
that allow the new *new* combination of interfaces, no?
I mean, consider the case that you have a single AP interface, with
beacon interval 300, and you're adding another AP, with beacon interval
150, and the following allowed combinations:
* ap = 1
mesh = 1
diff_beacon_int_gcd_min = 100
* ap = 2
diff_beacon_int_gcd_min = 50
Wouldn't you prevent that, or something?
Or say you have
* ap = 1
mesh = 1
diff_beacon_int_gcd_min = 100
* ap = 2
diff_beacon_int_gcd_min = 200
Probably doesn't really make sense, but now if you have an existing AP
interface, you would think the min is 100, when really while adding
another AP it should be 200.
> 3. If the beacon interval configured needs to be ensured to be
> greater than the "diff_beacon_int_gcd_min" configured for both the
> "single interface" and "interface combination" , we have resorted to
> "2" (get the minimal of "diff_beacon_int_gcd_min" among all the
> matched interface combinations and then compare it with the
> configured beacon interval).
Yeah, I think you're just matching the interface combinations wrong; I
think it needs to take into account the new interfaces and the existing
beacon intervals.
> > If the driver specified diff_beacon_int_gcd_min, then don't do
> > anything in cfg80211_validate_beacon_int(), other than perhaps a
> > minimal range check against the minimum of all
> > >diff_beacon_int_gcd_min values for all combinations.
> > That new argument could be made the GCD of all existing beaconing
> > interfaces (or 0 if no such exists), since that's sufficient for
> > checking against a new min_gcd.
> If I understand this correctly , are you saying that this new
> argument to cfg80211_iter_combinations shall be the GCD of all the
> existing beacon intervals and would be used to match with the
> corresponding "diff_beacon_int_gcd_min" of the interface combinations
> in "cfg80211_iter_combinations".
Yes, that's what I was thinking.
> If yes , this GCD argument does not represent , if the beacon
> intervals of all the existing interfaces differ or not , isn’t ? If
> the "diff_beacon_int_gcd_min" of the all the matching interface
> combinations is 0 , such differed beacon intervals would pass the
> check , contradicting the existing logic ( not allowing the differed
> beacon intervals), isn't ?
Oh, well, ok - if all existing and new beacon intervals are the same
we'd have to do the lookup without the existing beacon interval GCD and
still compare to the min separately.
> Thus, wouldn't it be a better option to first get the
> "diff_beacon_int_gcd_min" advertised by the respective interface
> combinations and then later compare it with the configured /
> calculated beacon interval's GCD .
As above, I think you might find a combination that no longer applies
after the new interface is added, thus causing a situation that isn't
actually covered by the allowed combinations.
> Also , not quite sure how would your comment " matching without the
> right # of channels or radar detect parameters" get addressed with
> your new proposal ( adding a new argument to
> "cfg80211_iter_combinations" )
That's just addressed by not doing the "get min min_gcd" first step,
where you used it wrong, afaict.
johannes
Hi,
> In PATCH v8 , cfg80211_validate_beacon_int ->
> cfg80211_iter_combinations carries the argument iftype_num , which
> also considers the "new interface" that is getting added.
Ah, right, I remember now, sorry.
> Thus , in the example you have quoted above , the iftype_num shall
> represent 2 ( AP + AP ) , and thus the min_gcd obtained out of
> cfg80211_iter_combinations (cfg80211_get_beacon_int_min_gcd) shall be
> 50 for the example 1 and 200 for the example 2 .
> Thus , considering the two examples mentioned above , the second AP
> should succeed for "example 1" vs failure for "example 2" with patch
> V8 , isn't ?
Yeah, I tried to simplify and did so too much. I believe you are, for
this purpose, ignoring for example radar detection.
Since you're passing 0 for num_different_channels and radar_detect, you
might find a combination isn't actually currently usable, but that
allows the new beacon interval configuration.
So I think overall this will only work right if it's done with all
necessary information, no?
Trying to construct another example ... let's say permitted
combinations are
* go = 3, channels = 1, min_bcn_gcd = 50
* go = 3, channels = 2, min_bcn_gcd = 100
(which isn't actually all that far-fetched, since channel hopping takes
time)
For simplification, say you already have two GOs active on different
channels (with BI 100), and want to add another one - with beacon
interval 50 - this isn't possible, but I don't think your code would
detect it?
Or, perhaps I'm reading this wrong, if your code *does* detect it then
changing the scenario a bit to have just a single channel, your code
would prevent it even though it's allowed?
> The current behavior of the kernel is to not allow the configuration
> of different beacon intervals and our expectation is that this new
> patch should be backward compatible with the existing behavior.
Correct, and I agree, we shouldn't break that.
> Now , if we go with this approach of "introducing a new argument to
> cfg80211_iter_combinations which shall be the GCD of all the existing
> combinations to check against the respective
> "diff_beacon_int_gcd_min"" , consider the case ( same one which is
> mentioned above ) that we have a single AP interface ( beacon
> interval = 300 ) , and a new AP is getting added ( beacon interval =
> 150 ), with the following allowed combinations:
>
> 1) * ap = 2
> diff_beacon_int_gcd_min = 0 ( rather not specified )
> 2) * ap = 2
> diff_beacon_int_gcd_min = 100
>
> The GCD calculated is 150 . cfg80211_iter_combinations shall return
> success for both the scenarios ( 1 and 2 ) (The intention here is to
> compare with only the nonzero " diff_beacon_int_gcd_min" )
>
> This success from "cfg80211_iter_combinations" does not represent if
> the GCD passed is compared against a 0 / non zero
> "diff_beacon_int_gcd_min" , isn't ?
>
> Thus , we are trying to solve this problem , by getting the
> "diff_beacon_int_gcd_min" for the respective interface combination ,
> before comparing it with the calculated GCD.
Oh. I think I finally understand your concern - good point!
Let me see if I understand correctly - you're saying that if I first
calculate
g = GCD(all BIs, including the new one)
and then do
cfg80211_iter_combinations(... existing variables ..., g)
then I cannot accurately determine whether or not I can use a
combination that doesn't specify a min_beacon_interval_gcd, you can't
know if the "all BIs" were the same, or not.
That's actually a very good point.
However, it seems pretty easy to solve by passing another bool that
indicates "all the same"?
johannes
On Fri, 2016-10-07 at 07:42 +0000, Kushwaha, Purushottam wrote:
> >
> > However, it seems pretty easy to solve by passing another bool that
> > indicates "all the same"?
> Yes . Thanks .
> We are planning to get the following changes in 2 commits . Let me
> know your consent .
> 1. cfg80211: Provision to allow the support for different beacon
> intervals. ( Would like to go with this in a separate commit as the
> current infrastructure also does not support the validation of
> radar_detect / num_different_channel ) .
> 2. cfg80211 : Check radar_detect and num_different_channels with
> beacon interface combinations.
>
Seems fine, no driver will be able to advertise the different BIs
inbetween the two patches anyway.
I think we might want to add another patch before or inbetween, that
converts the far-too-long argument list of the combination
iter/validation functions to a structure?
johannes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