Skip to contentSkip to conversation

rust: page: add Rust version of PAGE_ALIGN

PATCH Applied Alice Ryhl 4 participants 15 messages Oct 16, 2024 – Oct 21, 2024

Subsystems (3)
lore
Share & tools
lore

Alice Ryhl

author maintainer
#0 lore raw

PATCH v2 1/1 rust: page: add Rust version of PAGE_ALIGN

This is a useful for helper for working with indices into buffers that consist of several pages. I forgot to include it when I added PAGE_SIZE and PAGE_MASK for the same purpose in commit fc6e66f4696b ("rust: add abstraction for struct page").

---
Changes in v2:
- Make the function const.
- Address integer overflow in docs.
- Link to v1: https://lore.kernel.org/r/[email protected]

---
 rust/kernel/page.rs | 9 +++++++++
 1 file changed, 9 insertions(+)
rust/kernel/page.rs +9 -0
index 208a006d587c..9ef01929e7d0 100644
@@ -20,6 +20,15 @@
 /// A bitmask that gives the page containing a given address.
 pub const PAGE_MASK: usize = !(PAGE_SIZE - 1);
 
+/// Round up the given number to the next multiple of `PAGE_SIZE`.
+///
+/// It is incorrect to pass an address where the next multiple of `PAGE_SIZE` doesn't fit in a
+/// `usize`.
+pub const fn page_align(addr: usize) -> usize {
+    // Brackets around PAGE_SIZE-1 to avoid triggering overflow sanitizers in the wrong cases.
+    (addr + (PAGE_SIZE - 1)) & PAGE_MASK
+}
+
 /// A pointer to a page that owns the page allocation.
 ///
 /// # Invariants

---
base-commit: 8d8f785ceb21b9a0de11e05b811cc52d6fa79318
change-id: 20241015-page-align-7e5fa4c751be

Best regards,

Signature · 1 line
Alice Ryhl <[email protected]>
Applied
#1 lore raw
Quoted 8 lines · Alice Ryhl

This is a useful for helper for working with indices into buffers that consist of several pages. I forgot to include it when I added PAGE_SIZE and PAGE_MASK for the same purpose in commit fc6e66f4696b ("rust: add abstraction for struct page").

Applied to rust-next -- thanks everyone!

[ Added intra-doc links, formatted comment. - Miguel ]

Cheers,
Miguel

#2 lore raw
In reply to Alice Ryhl
Quoted 21 lines · Alice Ryhl

This is a useful for helper for working with indices into buffers that consist of several pages. I forgot to include it when I added PAGE_SIZE and PAGE_MASK for the same purpose in commit fc6e66f4696b ("rust: add abstraction for struct page").

---
Changes in v2:
- Make the function const.
- Address integer overflow in docs.
- Link to v1: https://lore.kernel.org/r/[email protected]

---
  rust/kernel/page.rs | 9 +++++++++
  1 file changed, 9 insertions(+)
rust/kernel/page.rs +0 -0
index 208a006d587c..9ef01929e7d0 100644

rust/kernel/page.rs line 28

Quoted 9 lines
rust/kernel/page.rs +6 -0
@@ -20,6 +20,15 @@
  /// A bitmask that gives the page containing a given address.
  pub const PAGE_MASK: usize = !(PAGE_SIZE - 1);
 
+/// Round up the given number to the next multiple of `PAGE_SIZE`.
+///
+/// It is incorrect to pass an address where the next multiple of `PAGE_SIZE` doesn't fit in a
+/// `usize`.
+pub const fn page_align(addr: usize) -> usize {
+    // Brackets around PAGE_SIZE-1 to avoid triggering overflow sanitizers in the wrong cases.

Silly nit, but I did start looking for brackets that aren't there, so:

s/Brackets/parentheses/

Quoted 11 lines
rust/kernel/page.rs +3 -1
+    (addr + (PAGE_SIZE - 1)) & PAGE_MASK
+}
+
  /// A pointer to a page that owns the page allocation.
  ///
  /// # Invariants
 
---

base-commit: 8d8f785ceb21b9a0de11e05b811cc52d6fa79318
change-id: 20241015-page-align-7e5fa4c751be

Quoted 1 line

Best regards,

thanks,

Signature · 1 line
John Hubbard
#3 lore raw
Quoted 36 lines · John Hubbard
Quoted 31 lines · Alice Ryhl

This is a useful for helper for working with indices into buffers that consist of several pages. I forgot to include it when I added PAGE_SIZE and PAGE_MASK for the same purpose in commit fc6e66f4696b ("rust: add abstraction for struct page").

---
Changes in v2:
- Make the function const.
- Address integer overflow in docs.
- Link to v1: https://lore.kernel.org/r/20241015-page-align-
[email protected]
---
  rust/kernel/page.rs | 9 +++++++++

  1 file changed, 9 insertions(+)
rust/kernel/page.rs +3 -0
index 208a006d587c..9ef01929e7d0 100644
@@ -20,6 +20,15 @@
   /// A bitmask that gives the page containing a given address.
   pub const PAGE_MASK: usize = !(PAGE_SIZE - 1);
+/// Round up the given number to the next multiple of `PAGE_SIZE`.
+///
+/// It is incorrect to pass an address where the next multiple of 

PAGE_SIZE doesn't fit in a

rust/kernel/page.rs +3 -0
+/// `usize`.
+pub const fn page_align(addr: usize) -> usize {
+    // Brackets around PAGE_SIZE-1 to avoid triggering overflow 
Quoted 1 line

sanitizers in the wrong cases.

Silly nit, but I did start looking for brackets that aren't there, so:

Quoted 1 line

s/Brackets/parentheses/

This isn't a distinction that exists in my vocabulary, shrug.

Miguel, feel free to reword when you pick this.

Alice

#5 lore raw
In reply to John Hubbard
Quoted 4 lines · John Hubbard

Silly nit, but I did start looking for brackets that aren't there, so:

s/Brackets/parentheses/

I noticed that too, but I checked it and brackets is the BE spelling. So I left it as it is...

Cheers,
Miguel

#6 lore raw
Quoted 9 lines · Miguel Ojeda
Quoted 4 lines · John Hubbard

Silly nit, but I did start looking for brackets that aren't there, so:

s/Brackets/parentheses/

I noticed that too, but I checked it and brackets is the BE spelling. So I left it as it is...

Is this another case of C and Rust using different words for things?? Wow. OK...

thanks,

Signature · 1 line
John Hubbard
#7 lore raw
Quoted 3 lines · John Hubbard

Is this another case of C and Rust using different words for things?? Wow. OK...

I am not sure what you mean -- by BE I meant British English.

See my other reply as well -- I just changed it anyway because Rust apparently uses "parentheses".

Cheers,
Miguel

#8 lore raw
Quoted 10 lines · Miguel Ojeda
Quoted 3 lines · John Hubbard

Is this another case of C and Rust using different words for things?? Wow. OK...

I am not sure what you mean -- by BE I meant British English.

See my other reply as well -- I just changed it anyway because Rust apparently uses "parentheses".

Right. For spoken languages, that's simply preference, and I would not try to impose anything on anyone there.

But in this case, at least for C (and, from reading my Rust book(s), I thought for Rust also), "parentheses" is a technical specification, and we should prefer to be accurate:

    parentheses: ()
    brackets:    []

Yes?

thanks,

Signature · 1 line
John Hubbard
#9 lore raw
Quoted 15 lines · John Hubbard
Quoted 10 lines · Miguel Ojeda
Quoted 3 lines · John Hubbard

Is this another case of C and Rust using different words for things?? Wow. OK...

I am not sure what you mean -- by BE I meant British English.

See my other reply as well -- I just changed it anyway because Rust apparently uses "parentheses".

Right. For spoken languages, that's simply preference, and I would not try to impose anything on anyone there.

Quoted 8 lines

But in this case, at least for C (and, from reading my Rust book(s), I thought for Rust also), "parentheses" is a technical specification, and we should prefer to be accurate:

    parentheses: ()
    brackets:    []

Yes?

What word would you use to collectively talk about (), [], {}? In my native language they're all a kind of parenthesis.

Alice

#10 lore raw
Quoted 20 lines · Alice Ryhl
Quoted 19 lines · John Hubbard
Quoted 10 lines · Miguel Ojeda
Quoted 3 lines · John Hubbard

Is this another case of C and Rust using different words for things?? Wow. OK...

I am not sure what you mean -- by BE I meant British English.

See my other reply as well -- I just changed it anyway because Rust apparently uses "parentheses".

Right. For spoken languages, that's simply preference, and I would not try to impose anything on anyone there.

But in this case, at least for C (and, from reading my Rust book(s), I thought for Rust also), "parentheses" is a technical specification, and we should prefer to be accurate:

Quoted 6 lines
Quoted 4 lines

     parentheses: ()
     brackets:    []

Yes?

What word would you use to collectively talk about (), [], {}? In my native language they're all a kind of parenthesis.

Good question. I've never attempted that when discussing programming language details, because it hasn't come up, because it would be a programming error in C to use one in place of the other. And it is rare to refer to both cases in C.

Rust so far seems to have the same distinction, although I am standing by to be corrected as necessary, there! :)

At a higher level of abstraction, though, perhaps "grouping" is a good word.

thanks,

Signature · 1 line
John Hubbard
author maintainer
#11 lore raw
Quoted 34 lines · John Hubbard
Quoted 20 lines · Alice Ryhl
Quoted 19 lines · John Hubbard
Quoted 10 lines · Miguel Ojeda
Quoted 3 lines · John Hubbard

Is this another case of C and Rust using different words for things?? Wow. OK...

I am not sure what you mean -- by BE I meant British English.

See my other reply as well -- I just changed it anyway because Rust apparently uses "parentheses".

Right. For spoken languages, that's simply preference, and I would not try to impose anything on anyone there.

But in this case, at least for C (and, from reading my Rust book(s), I thought for Rust also), "parentheses" is a technical specification, and we should prefer to be accurate:

Quoted 6 lines
Quoted 4 lines
     parentheses: ()
     brackets:    []

Yes?

What word would you use to collectively talk about (), [], {}? In my native language they're all a kind of parenthesis.

Good question. I've never attempted that when discussing programming language details, because it hasn't come up, because it would be a programming error in C to use one in place of the other. And it is rare to refer to both cases in C.

Quoted 5 lines

Rust so far seems to have the same distinction, although I am standing by to be corrected as necessary, there! :)

At a higher level of abstraction, though, perhaps "grouping" is a good word.

Rust macros can use different types of brackets. For example, the assert!(1 < 2) macro uses round parenthesises, the vec![1,2,3] macro uses square parenthesises, and the thread_local! { ... } macro uses curly parenthesies. The round and square brackets are used for expression-like things, and the curlies are used for things that expand to top-level items such as global variables or functions.

Macros cannot use any other delimiter than those three. So e.g. <> wouldn't work.

Alice

#12 lore raw
Quoted 48 lines · Alice Ryhl
Quoted 34 lines · John Hubbard
Quoted 20 lines · Alice Ryhl
Quoted 19 lines · John Hubbard
Quoted 10 lines · Miguel Ojeda
Quoted 3 lines · John Hubbard

Is this another case of C and Rust using different words for things?? Wow. OK...

I am not sure what you mean -- by BE I meant British English.

See my other reply as well -- I just changed it anyway because Rust apparently uses "parentheses".

Right. For spoken languages, that's simply preference, and I would not try to impose anything on anyone there.

But in this case, at least for C (and, from reading my Rust book(s), I thought for Rust also), "parentheses" is a technical specification, and we should prefer to be accurate:

Quoted 6 lines
Quoted 4 lines
      parentheses: ()
      brackets:    []

Yes?

What word would you use to collectively talk about (), [], {}? In my native language they're all a kind of parenthesis.

Good question. I've never attempted that when discussing programming language details, because it hasn't come up, because it would be a programming error in C to use one in place of the other. And it is rare to refer to both cases in C.

Quoted 5 lines

Rust so far seems to have the same distinction, although I am standing by to be corrected as necessary, there! :)

At a higher level of abstraction, though, perhaps "grouping" is a good word.

Rust macros can use different types of brackets. For example, the assert!(1 < 2) macro uses round parenthesises, the vec![1,2,3] macro uses square parenthesises, and the thread_local! { ... } macro uses curly parenthesies. The round and square brackets are used for expression-like things, and the curlies are used for things that expand to top-level items such as global variables or functions.

Quoted 2 lines

Macros cannot use any other delimiter than those three. So e.g. <> wouldn't work.

That answers my implicit "are there any cases in which you would want to collectively refer to all three types of...bracket?", yes.

For the original point, though, we are not in a Rust macro. Is it actually allowable to use [] or {} here:

+ // Brackets around PAGE_SIZE-1 to avoid triggering overflow sanitizers in the wrong cases.
+ (addr + (PAGE_SIZE - 1)) & PAGE_MASK

? Is that why you were not seeing a difference between saying "brackets" vs. "parentheses" there? If so, this would be yet another case of my Rust newbie-ness being inflicted on you. :)

thanks,

Signature · 1 line
John Hubbard
#13 lore raw
Quoted 58 lines · John Hubbard
Quoted 48 lines · Alice Ryhl
Quoted 34 lines · John Hubbard
Quoted 20 lines · Alice Ryhl
Quoted 19 lines · John Hubbard
Quoted 10 lines · Miguel Ojeda
Quoted 3 lines · John Hubbard

Is this another case of C and Rust using different words for things?? Wow. OK...

I am not sure what you mean -- by BE I meant British English.

See my other reply as well -- I just changed it anyway because Rust apparently uses "parentheses".

Right. For spoken languages, that's simply preference, and I would not try to impose anything on anyone there.

But in this case, at least for C (and, from reading my Rust book(s), I thought for Rust also), "parentheses" is a technical specification, and we should prefer to be accurate:

Quoted 6 lines
Quoted 4 lines

      parentheses: ()
      brackets:    []

Yes?

What word would you use to collectively talk about (), [], {}? In my native language they're all a kind of parenthesis.

Good question. I've never attempted that when discussing programming language details, because it hasn't come up, because it would be a programming error in C to use one in place of the other. And it is rare to refer to both cases in C.

Quoted 5 lines

Rust so far seems to have the same distinction, although I am standing by to be corrected as necessary, there! :)

At a higher level of abstraction, though, perhaps "grouping" is a good word.

Rust macros can use different types of brackets. For example, the assert!(1 < 2) macro uses round parenthesises, the vec![1,2,3] macro uses square parenthesises, and the thread_local! { ... } macro uses curly parenthesies. The round and square brackets are used for expression-like things, and the curlies are used for things that expand to top-level items such as global variables or functions.

Quoted 2 lines

Macros cannot use any other delimiter than those three. So e.g. <> wouldn't work.

That answers my implicit "are there any cases in which you would want to collectively refer to all three types of...bracket?", yes.

For the original point, though, we are not in a Rust macro. Is it actually allowable to use [] or {} here:

Quoted 7 lines

+    // Brackets around PAGE_SIZE-1 to avoid triggering overflow sanitizers in the wrong cases.
+    (addr + (PAGE_SIZE - 1)) & PAGE_MASK

? Is that why you were not seeing a difference between saying "brackets" vs. "parentheses" there? If so, this would be yet another case of my Rust newbie-ness being inflicted on you. :)

You can use both () and {}, but you can only use brackets if you're European. ;)

Using {} to create a block works because a block evaluates to the value of the last expression in the block. It would be super weird to define a block here, though.

Alice

#14 lore raw
Quoted 3 lines · Alice Ryhl
Quoted 2 lines · John Hubbard
Quoted 1 line · Alice Ryhl

On Mon, Oct 21, 2024 at 9:09 PM John Hubbard <[email protected]> wrote:

...

Quoted 16 lines
Quoted 16 lines
Quoted 9 lines

Rust macros can use different types of brackets. For example, the assert!(1 < 2) macro uses round parenthesises, the vec![1,2,3] macro uses square parenthesises, and the thread_local! { ... } macro uses curly parenthesies. The round and square brackets are used for expression-like things, and the curlies are used for things that expand to top-level items such as global variables or functions.

Macros cannot use any other delimiter than those three. So e.g. <> wouldn't work.

That answers my implicit "are there any cases in which you would want to collectively refer to all three types of...bracket?", yes.

For the original point, though, we are not in a Rust macro. Is it actually allowable to use [] or {} here:

Quoted 7 lines
Quoted 6 lines

+    // Brackets around PAGE_SIZE-1 to avoid triggering overflow sanitizers in the wrong cases. +    (addr + (PAGE_SIZE - 1)) & PAGE_MASK

? Is that why you were not seeing a difference between saying "brackets" vs. "parentheses" there? If so, this would be yet another case of my Rust newbie-ness being inflicted on you. :)

You can use both () and {}, but you can only use brackets if you're European. ;)

I *knew* I was missing out! hahaha

Quoted 3 lines

Using {} to create a block works because a block evaluates to the value of the last expression in the block. It would be super weird to define a block here, though.

No argument there. :)

thanks,

Signature · 1 line
John Hubbard