Skip to contentSkip to conversation

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

PATCH Superseded Abraham Samuel Adekunle 5 participants 11 messages Apr 7, 2025 Staging

v4 of 5 Superseded Latest is v5 →

lore
Share & tools
lore
#0 lore raw

PATCH v4 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 with 4096u makes the wrap-around logic explicit and easier to understand. It clearly signals that the sequence number cycles though 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 signed types.

---
Changes in v3:
- Added more description to the commit message
- Removed blank line in tag block.
- Added more patch recipients.
Changes in v2:
- Changed the commit message to 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 297c93d65315..f534bf2448c3 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
maintainer
#1 lore raw
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.

Using a modulo operation with 4096u makes the wrap-around logic

<snip>

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

Quoted 2 lines
drivers/staging/rtl8723bs/core/rtw_xmit.c +1 -1
-				psta->sta_xmitpriv.txseq_tid[pattrib->priority] &= 0xFFF;
+				psta->sta_xmitpriv.txseq_tid[pattrib->priority] &= 4096u;

I do not see a modulo operation here, only another & operation.

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

Quoted 9 lines
drivers/staging/rtl8723bs/core/rtw_xmit.c +1 -1
 				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;

This also looks odd, nothing is being "AND" here, it's an address value being set (and an odd one at that, but that's another issue...)

How was any of this tested?

Slow down, take some time, and think about what you are wanting to do here. There's no rush.

thanks,

greg k-h

maintainer
#2 lore raw
Quoted 17 lines · Greg KH
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.

Using a modulo operation with 4096u makes the wrap-around logic

<snip>

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

Quoted 2 lines
drivers/staging/rtl8723bs/core/rtw_xmit.c +1 -1
-				psta->sta_xmitpriv.txseq_tid[pattrib->priority] &= 0xFFF;
+				psta->sta_xmitpriv.txseq_tid[pattrib->priority] &= 4096u;

I do not see a modulo operation here, only another & operation.

Quoted 2 lines

pattrib->seqnum = psta->sta_xmitpriv.txseq_tid[pattrib->priority];

Quoted 10 lines

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

Quoted 7 lines
drivers/staging/rtl8723bs/core/rtw_xmit.c +1 -1
 				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;

This also looks odd, nothing is being "AND" here, it's an address value being set (and an odd one at that, but that's another issue...)

Sorry, no, I was wrong, it is being & here, but not %. My fault, the lack of spaces here threw me.

thanks,

greg k-h

#3 lore raw
Quoted 8 lines · Greg KH
Quoted 6 lines · Greg KH
Quoted 5 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 8 lines
Quoted 8 lines
Quoted 1 line

Using a modulo operation with 4096u makes the wrap-around logic

<snip>

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

Quoted 2 lines
drivers/staging/rtl8723bs/core/rtw_xmit.c +1 -1
-                           psta->sta_xmitpriv.txseq_tid[pattrib->priority] &= 0xFFF;
+                           psta->sta_xmitpriv.txseq_tid[pattrib->priority] &= 4096u;

I do not see a modulo operation here, only another & operation.

I'm sorry ...

Quoted 14 lines
Quoted 13 lines

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

Quoted 10 lines
                            pattrib->seqnum = psta->sta_xmitpriv.txseq_tid[pattrib->priority];

                            SetSeqNum(hdr, pattrib->seqnum);
drivers/staging/rtl8723bs/core/rtw_xmit.c +1 -1
@@ -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;

This also looks odd, nothing is being "AND" here, it's an address value being set (and an odd one at that, but that's another issue...)

Quoted 2 lines

Sorry, no, I was wrong, it is being & here, but not %. My fault, the lack of spaces here threw me.

I want to add spaces for readability. But since the changes occurs on the same line,
I am a bit confused about the best approach to take
Do I create a patchset, a patch for adding spaces, and a second for changing from & to %?

Also, should be second patch be based on the file after the first change I made, or it should be based on the original staging tree file.

Thanks
Adekunle.

#4 lore raw
In reply to Greg KH
Quoted 29 lines · On Mon, 7 Apr 2025 08:53:30 +0200 Greg KH <[email protected]> wrote:
Quoted 17 lines · Greg KH
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.

Using a modulo operation with 4096u makes the wrap-around logic

<snip>

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

Quoted 2 lines
drivers/staging/rtl8723bs/core/rtw_xmit.c +1 -1
-				psta->sta_xmitpriv.txseq_tid[pattrib->priority] &= 0xFFF;
+				psta->sta_xmitpriv.txseq_tid[pattrib->priority] &= 4096u;  

I do not see a modulo operation here, only another & operation.

Quoted 2 lines

pattrib->seqnum = psta->sta_xmitpriv.txseq_tid[pattrib->priority];

Quoted 10 lines

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

Quoted 7 lines
drivers/staging/rtl8723bs/core/rtw_xmit.c +1 -1
 				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;  

This also looks odd, nothing is being "AND" here, it's an address value being set (and an odd one at that, but that's another issue...)

Quoted 2 lines

Sorry, no, I was wrong, it is being & here, but not %. My fault, the lack of spaces here threw me.

It is still wrong '& 0xfff' => '% 4096u'.
But it is all rather pointless especially if you can't test it.

Plausibly more useful would be to find ALL of the uses of 0xfff/4096 (I suspect there is an array lurking somewhere) and change them to use the same constant. But you need to be able to test the changes - or at least discover that they make absolutely no difference to the generated object code.

David

Quoted 4 lines

thanks,

greg k-h

#5 lore raw
Quoted 4 lines · David Laight
Quoted 2 lines · On Mon, 7 Apr 2025 08:53:30 +0200 Greg KH <[email protected]> wrote:
Quoted 1 line · Greg KH

On Mon, Apr 07, 2025 at 06:30:50AM +0000, Abraham Samuel Adekunle wrote:

<snip>

Quoted 18 lines
Quoted 18 lines
Quoted 17 lines

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

Quoted 2 lines
drivers/staging/rtl8723bs/core/rtw_xmit.c +1 -1
-				psta->sta_xmitpriv.txseq_tid[pattrib->priority] &= 0xFFF;
+				psta->sta_xmitpriv.txseq_tid[pattrib->priority] &= 4096u;  

I do not see a modulo operation here, only another & operation.

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

Quoted 9 lines
drivers/staging/rtl8723bs/core/rtw_xmit.c +1 -1
 				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;  

This also looks odd, nothing is being "AND" here, it's an address value being set (and an odd one at that, but that's another issue...)

Quoted 4 lines
Quoted 2 lines

Sorry, no, I was wrong, it is being & here, but not %. My fault, the lack of spaces here threw me.

It is still wrong '& 0xfff' => '% 4096u'.

Why?

Quoted 6 lines

But it is all rather pointless especially if you can't test it.

Plausibly more useful would be to find ALL of the uses of 0xfff/4096 (I suspect there is an array lurking somewhere) and change them to use the same constant. But you need to be able to test the changes - or at least discover that they make absolutely no difference to the generated object code.

The problem with &, it's not non-power-of-2 tolerable solution. Also using hexadecimal there is not so helpful as when we are talking about sequences (or indices in the circular buffer), the decimal makes more sense.

Signature · 2 lines
With Best Regards,
Andy Shevchenko
#6 lore raw
Quoted 26 lines · On Mon, 7 Apr 2025 15:28:34 +0300 Andy Shevchenko <[email protected]> wrote:
Quoted 4 lines · David Laight
Quoted 2 lines · On Mon, 7 Apr 2025 08:53:30 +0200 Greg KH <[email protected]> wrote:
Quoted 1 line · Greg KH

On Mon, Apr 07, 2025 at 06:30:50AM +0000, Abraham Samuel Adekunle wrote:

<snip>

Quoted 18 lines
Quoted 18 lines
Quoted 17 lines

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

Quoted 2 lines
drivers/staging/rtl8723bs/core/rtw_xmit.c +1 -1
-				psta->sta_xmitpriv.txseq_tid[pattrib->priority] &= 0xFFF;
+				psta->sta_xmitpriv.txseq_tid[pattrib->priority] &= 4096u;    

I do not see a modulo operation here, only another & operation.

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

Quoted 9 lines
drivers/staging/rtl8723bs/core/rtw_xmit.c +1 -1
 				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;    

This also looks odd, nothing is being "AND" here, it's an address value being set (and an odd one at that, but that's another issue...)

Quoted 6 lines
Quoted 4 lines
Quoted 2 lines

Sorry, no, I was wrong, it is being & here, but not %. My fault, the lack of spaces here threw me.

It is still wrong '& 0xfff' => '% 4096u'.

Why?

Do some math :-)

Quoted 11 lines
Quoted 6 lines

But it is all rather pointless especially if you can't test it.

Plausibly more useful would be to find ALL of the uses of 0xfff/4096 (I suspect there is an array lurking somewhere) and change them to use the same constant. But you need to be able to test the changes - or at least discover that they make absolutely no difference to the generated object code.

The problem with &, it's not non-power-of-2 tolerable solution. Also using hexadecimal there is not so helpful as when we are talking about sequences (or indices in the circular buffer), the decimal makes more sense.

Except that you either want your circular buffer size to be a power of 2 or reduce with a conditional (eg: if (++x == SIZE) x = 0;) not a divide.

David

#7 lore raw
Quoted 7 lines · David Laight
Quoted 5 lines · On Mon, 7 Apr 2025 15:28:34 +0300 Andy Shevchenko <[email protected]> wrote:
Quoted 4 lines · David Laight
Quoted 2 lines · On Mon, 7 Apr 2025 08:53:30 +0200 Greg KH <[email protected]> wrote:
Quoted 1 line · Greg KH

On Mon, Apr 07, 2025 at 06:30:50AM +0000, Abraham Samuel Adekunle wrote:

<snip>

Quoted 18 lines
Quoted 18 lines
Quoted 18 lines
Quoted 18 lines
Quoted 17 lines

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

Quoted 2 lines
drivers/staging/rtl8723bs/core/rtw_xmit.c +1 -1
-				psta->sta_xmitpriv.txseq_tid[pattrib->priority] &= 0xFFF;
+				psta->sta_xmitpriv.txseq_tid[pattrib->priority] &= 4096u;    

I do not see a modulo operation here, only another & operation.

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

Quoted 9 lines
drivers/staging/rtl8723bs/core/rtw_xmit.c +1 -1
 				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;    

This also looks odd, nothing is being "AND" here, it's an address value being set (and an odd one at that, but that's another issue...)

Quoted 8 lines
Quoted 6 lines
Quoted 4 lines
Quoted 2 lines

Sorry, no, I was wrong, it is being & here, but not %. My fault, the lack of spaces here threw me.

It is still wrong '& 0xfff' => '% 4096u'.

Why?

Do some math :-)

Can you be more specific, please?

Quoted 7 lines
Quoted 7 lines
Quoted 6 lines

But it is all rather pointless especially if you can't test it.

Plausibly more useful would be to find ALL of the uses of 0xfff/4096 (I suspect there is an array lurking somewhere) and change them to use the same constant. But you need to be able to test the changes - or at least discover that they make absolutely no difference to the generated object code.

Quoted 6 lines
Quoted 3 lines

The problem with &, it's not non-power-of-2 tolerable solution. Also using hexadecimal there is not so helpful as when we are talking about sequences (or indices in the circular buffer), the decimal makes more sense.

Except that you either want your circular buffer size to be a power of 2 or reduce with a conditional (eg: if (++x == SIZE) x = 0;) not a divide.

Where do you see a divide in the generated code? And if even so, it means that compiler optimiser thinks that it's not worse than the bit operations.

Signature · 2 lines
With Best Regards,
Andy Shevchenko
#8 lore raw
In reply to David Laight
Quoted 36 lines · David Laight
Quoted 29 lines · On Mon, 7 Apr 2025 08:53:30 +0200 Greg KH <[email protected]> wrote:
Quoted 17 lines · Greg KH
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.

Using a modulo operation with 4096u makes the wrap-around logic

<snip>

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

Quoted 2 lines
drivers/staging/rtl8723bs/core/rtw_xmit.c +1 -1
-                         psta->sta_xmitpriv.txseq_tid[pattrib->priority] &= 0xFFF;
+                         psta->sta_xmitpriv.txseq_tid[pattrib->priority] &= 4096u;

I do not see a modulo operation here, only another & operation.

Quoted 2 lines
                          pattrib->seqnum = psta->sta_xmitpriv.txseq_tid[pattrib->priority];
Quoted 10 lines

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

Quoted 7 lines
                          SetSeqNum(hdr, pattrib->seqnum);
drivers/staging/rtl8723bs/core/rtw_xmit.c +1 -1
@@ -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;

This also looks odd, nothing is being "AND" here, it's an address value being set (and an odd one at that, but that's another issue...)

Quoted 2 lines

Sorry, no, I was wrong, it is being & here, but not %. My fault, the lack of spaces here threw me.

Quoted 7 lines

It is still wrong '& 0xfff' => '% 4096u'.
But it is all rather pointless especially if you can't test it.

Plausibly more useful would be to find ALL of the uses of 0xfff/4096 (I suspect there is an array lurking somewhere) and change them to use the same constant. But you need to be able to test the changes - or at least discover that they make absolutely no difference to the generated object code.

Yes, thank you for this, David.

I will compare the generated object files for both cases and compare them to make sure there is no difference.

Then, to check for other cases in the codebase, a semantic patch will be useful, so I will write one to search for
such cases and change them to use the constant.

Thank you very much

Adekunle

#9 lore raw
In reply to Abraham Samuel Adekunle
Quoted 38 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 with 4096u makes the wrap-around logic explicit and easier to understand. It clearly signals that the sequence number cycles though 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 signed types.

---
Changes in v3:
- Added more description to the commit message
- Removed blank line in tag block.
- Added more patch recipients.
Changes in v2:
- Changed the commit message to 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 +0 -0
index 297c93d65315..f534bf2448c3 100644

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

Quoted 5 lines
drivers/staging/rtl8723bs/core/rtw_xmit.c +1 -1
@@ -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;

You forgot to change the & to %.

regards,
dan carpenter

#10 lore raw
Quoted 41 lines · Dan Carpenter
Quoted 39 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 with 4096u makes the wrap-around logic explicit and easier to understand. It clearly signals that the sequence number cycles though 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 signed types.

---
Changes in v3:
- Added more description to the commit message
- Removed blank line in tag block.
- Added more patch recipients.
Changes in v2:
- Changed the commit message to 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 +0 -0
index 297c93d65315..f534bf2448c3 100644
@@ -943,7 +943,7 @@ s32 rtw_make_wlanhdr(struct adapter *padapter, u8 *hdr, struct pkt_attrib *pattr
 
Quoted 6 lines

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

Quoted 4 lines
drivers/staging/rtl8723bs/core/rtw_xmit.c +1 -1
                      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;

You forgot to change the & to %.

Thank you very much, Dan. I will correct and resend the patch.

Adekunle