Skip to contentSkip to conversation

staging: rtl8723bs: Use % 4096u instead of & 0xfff

PATCH In review Abraham Samuel Adekunle 2 participants 4 messages Apr 7, 2025 – Apr 9, 2025 Staging

lore
Share & tools
lore
#0 lore raw

PATCH v5 1/1 staging: rtl8723bs: Use % 4096u instead of & 0xfff

The sequence number is constrained to a range of [0, 4095], which is a total of 4096 values. The bitmask operation using & 0xfff is used to perform this wrap-around. While this is functionally correct, it obscures the intended semantic of a 4096-based wrap.

Using a modulo operation % 4096u makes the wrap-around logic explicit and easier to understand. It clearly signals that the sequence number cycles through a range of 4096 values.
It also makes the code robust against potential changes of the 4096 upper limit, especially when it becomes a non power of 2 value while the AND(&) works solely for power of 2 values.

The use of % 4096u also guarantees that the modulo operation is performed with unsigned arithmetic, preventing potential issues with the signed types.

---
Changes in v4:
- Corrected patch to use '%' instead of '&'
- To ensure this change does not affect the functional behaviour, I compared the generated object files before and after the change using the cmp which compares the two object files byte by byte as shown below:

$ make drivers/staging/rtl8723bs/core/rtw_xmit.o $ cmp rtw_xmit_before.o rtw_xmit_after.o

No differences were found in the output, confirming that the change does not alter the compiled output.
Changes in v3:
- Added more description to the commit message.
- Removed blank line in the tag block.
- Added more patch recipients.
Changes in v2:
- Changed the commit message t a more descriptive message which makes it clear why the patch does the change.
- changed the subject title to include 4096u to show that an unsigned module is used.
Changes in v1:
- Added more patch recipients.

 drivers/staging/rtl8723bs/core/rtw_xmit.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)
drivers/staging/rtl8723bs/core/rtw_xmit.c +3 -3
index 026061b464f7..548fcf9968bd 100644
@@ -943,7 +943,7 @@ s32 rtw_make_wlanhdr(struct adapter *padapter, u8 *hdr, struct pkt_attrib *pattr
 
 			if (psta) {
 				psta->sta_xmitpriv.txseq_tid[pattrib->priority]++;
-				psta->sta_xmitpriv.txseq_tid[pattrib->priority] &= 0xFFF;
+				psta->sta_xmitpriv.txseq_tid[pattrib->priority] %= 4096u;
 				pattrib->seqnum = psta->sta_xmitpriv.txseq_tid[pattrib->priority];
 
 				SetSeqNum(hdr, pattrib->seqnum);
@@ -963,11 +963,11 @@ s32 rtw_make_wlanhdr(struct adapter *padapter, u8 *hdr, struct pkt_attrib *pattr
 					if (SN_LESS(pattrib->seqnum, tx_seq)) {
 						pattrib->ampdu_en = false;/* AGG BK */
 					} else if (SN_EQUAL(pattrib->seqnum, tx_seq)) {
-						psta->BA_starting_seqctrl[pattrib->priority & 0x0f] = (tx_seq+1)&0xfff;
+						psta->BA_starting_seqctrl[pattrib->priority & 0x0f] = (tx_seq+1)%4096u;
 
 						pattrib->ampdu_en = true;/* AGG EN */
 					} else {
-						psta->BA_starting_seqctrl[pattrib->priority & 0x0f] = (pattrib->seqnum+1)&0xfff;
+						psta->BA_starting_seqctrl[pattrib->priority & 0x0f] = (pattrib->seqnum+1)%4096u;
 						pattrib->ampdu_en = true;/* AGG EN */
 					}
 				}
Signature · 1 line
2.34.1
#1 lore raw
Quoted 16 lines · Abraham Samuel Adekunle

The sequence number is constrained to a range of [0, 4095], which is a total of 4096 values. The bitmask operation using & 0xfff is used to perform this wrap-around. While this is functionally correct, it obscures the intended semantic of a 4096-based wrap.

Using a modulo operation % 4096u makes the wrap-around logic explicit and easier to understand. It clearly signals that the sequence number cycles through a range of 4096 values.
It also makes the code robust against potential changes of the 4096 upper limit, especially when it becomes a non power of 2 value while the AND(&) works solely for power of 2 values.

The use of % 4096u also guarantees that the modulo operation is performed with unsigned arithmetic, preventing potential issues with the signed types.

...

drivers/staging/rtl8723bs/core/rtw_xmit.c s32 rtw_make_wlanhdr(struct adapter *padapter, u8 *hdr, struct pkt_attrib *pattr · line 970

Quoted 5 lines
drivers/staging/rtl8723bs/core/rtw_xmit.c +2 -2
-                                               psta->BA_starting_seqctrl[pattrib->priority & 0x0f] = (tx_seq+1)&0xfff;
+                                               psta->BA_starting_seqctrl[pattrib->priority & 0x0f] = (tx_seq+1)%4096u;
 
-                                               psta->BA_starting_seqctrl[pattrib->priority & 0x0f] = (pattrib->seqnum+1)&0xfff;
+                                               psta->BA_starting_seqctrl[pattrib->priority & 0x0f] = (pattrib->seqnum+1)%4096u;

To reduce churn, it would be nice to have another patch _before_ this one that makes above clearer (by adding spaces) as we already new in practice that it's hard to read:
So, this will become two lines in each of the cases, and in this patch only one of those line will be touched.

...

Besides that I haven't found in the changelog if you have looked at the entire driver code and checked that all usages of this field is done in the same / similar way and no need to convert anything more that these.

Signature · 2 lines
With Best Regards,
Andy Shevchenko
#2 lore raw
Quoted 25 lines · Andy Shevchenko
Quoted 16 lines · Abraham Samuel Adekunle

The sequence number is constrained to a range of [0, 4095], which is a total of 4096 values. The bitmask operation using & 0xfff is used to perform this wrap-around. While this is functionally correct, it obscures the intended semantic of a 4096-based wrap.

Using a modulo operation % 4096u makes the wrap-around logic explicit and easier to understand. It clearly signals that the sequence number cycles through a range of 4096 values.
It also makes the code robust against potential changes of the 4096 upper limit, especially when it becomes a non power of 2 value while the AND(&) works solely for power of 2 values.

The use of % 4096u also guarantees that the modulo operation is performed with unsigned arithmetic, preventing potential issues with the signed types.

...

Quoted 2 lines
drivers/staging/rtl8723bs/core/rtw_xmit.c +1 -1
-                                               psta->BA_starting_seqctrl[pattrib->priority & 0x0f] = (tx_seq+1)&0xfff;
+                                               psta->BA_starting_seqctrl[pattrib->priority & 0x0f] = (tx_seq+1)%4096u;
Quoted 8 lines

drivers/staging/rtl8723bs/core/rtw_xmit.c s32 rtw_make_wlanhdr(struct adapter *padapter, u8 *hdr, struct pkt_attrib *pattr · line 970

Quoted 2 lines
drivers/staging/rtl8723bs/core/rtw_xmit.c +1 -1
-                                               psta->BA_starting_seqctrl[pattrib->priority & 0x0f] = (pattrib->seqnum+1)&0xfff;
+                                               psta->BA_starting_seqctrl[pattrib->priority & 0x0f] = (pattrib->seqnum+1)%4096u;

To reduce churn, it would be nice to have another patch _before_ this one that makes above clearer (by adding spaces) as we already new in practice that it's hard to read:
So, this will become two lines in each of the cases, and in this patch only one of those line will be touched.

Okay, I will send a patchset for the change. The first one will add the spaces, then the
second one will add the logic, and they can be applied in sequence.

Quoted 7 lines

...

Besides that I haven't found in the changelog if you have looked at the entire driver code and checked that all usages of this field is done in the same / similar way and no need to convert anything more that these.

No, I have not checked other drivers. I will write a semantic patch to match and transform such cases

Thanks
Adekunle.

#3 lore raw
In reply to Andy Shevchenko
Quoted 16 lines · Andy Shevchenko
Quoted 6 lines · Abraham Samuel Adekunle

The sequence number is constrained to a range of [0, 4095], which is a total of 4096 values. The bitmask operation using & 0xfff is used to perform this wrap-around. While this is functionally correct, it obscures the intended semantic of a 4096-based wrap.

Quoted 7 lines

Using a modulo operation % 4096u makes the wrap-around logic explicit and easier to understand. It clearly signals that the sequence number cycles through a range of 4096 values.
It also makes the code robust against potential changes of the 4096 upper limit, especially when it becomes a non power of 2 value while the AND(&) works solely for power of 2 values.

Quoted 6 lines

...

Besides that I haven't found in the changelog if you have looked at the entire driver code and checked that all usages of this field is done in the same / similar way and no need to convert anything more that these.

I have found more cases using a small Coccinelle semantic patch. There were also cases in the media driver, but I did not touch those since it is not allowed for an outreachy applicant.
I will send a patchset soon.

Thanks
Adekunle