[-V2,5/5] swap: comments get_swap_device() with usage rule

Commit Message

Huang, Ying May 22, 2023, 7:09 a.m. UTC

The general rule to use a swap entry is as follows.

When we get a swap entry, if there isn't some other way to prevent
swapoff, such as page lock for swap cache, page table lock, etc., the
swap entry may become invalid because of swapoff.  Then, we need to
enclose all swap related functions with get_swap_device() and
put_swap_device(), unless the swap functions call
get/put_swap_device() by themselves.

Add the rule as comments of get_swap_device().

Signed-off-by: "Huang, Ying" <[e-mail]>
Cc: David Hildenbrand <[e-mail]>
Cc: Hugh Dickins <[e-mail]>
Cc: Johannes Weiner <[e-mail]>
Cc: Matthew Wilcox <[e-mail]>
Cc: Michal Hocko <[e-mail]>
Cc: Minchan Kim <[e-mail]>
Cc: Tim Chen <[e-mail]>
Cc: Yang Shi <[e-mail]>
Cc: Yu Zhao <[e-mail]>
---
 mm/swapfile.c | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

Comments

David Hildenbrand May 22, 2023, 12:07 p.m. UTC | #1

On 22.05.23 09:09, Huang Ying wrote:
> The general rule to use a swap entry is as follows.
> 
> When we get a swap entry, if there isn't some other way to prevent
> swapoff, such as page lock for swap cache, page table lock, etc., the
> swap entry may become invalid because of swapoff.  Then, we need to
> enclose all swap related functions with get_swap_device() and
> put_swap_device(), unless the swap functions call
> get/put_swap_device() by themselves.
> 
> Add the rule as comments of get_swap_device().
> 
> Signed-off-by: "Huang, Ying" <[e-mail]>
> Cc: David Hildenbrand <[e-mail]>
> Cc: Hugh Dickins <[e-mail]>
> Cc: Johannes Weiner <[e-mail]>
> Cc: Matthew Wilcox <[e-mail]>
> Cc: Michal Hocko <[e-mail]>
> Cc: Minchan Kim <[e-mail]>
> Cc: Tim Chen <[e-mail]>
> Cc: Yang Shi <[e-mail]>
> Cc: Yu Zhao <[e-mail]>
> ---
>   mm/swapfile.c | 12 +++++++++---
>   1 file changed, 9 insertions(+), 3 deletions(-)
> 
> diff --git a/mm/swapfile.c b/mm/swapfile.c
> index 4dbaea64635d..0c1cb935b2eb 100644
> --- a/mm/swapfile.c
> +++ b/mm/swapfile.c
> @@ -1219,6 +1219,13 @@ static unsigned char __swap_entry_free_locked(struct swap_info_struct *p,
>   }
>   
>   /*
> + * When we get a swap entry, if there isn't some other way to prevent
> + * swapoff, such as page lock for swap cache, page table lock, etc.,

Again "page lock for swap cache" might be imprecise.

> + * the swap entry may become invalid because of swapoff.  Then, we
> + * need to enclose all swap related functions with get_swap_device()
> + * and put_swap_device(), unless the swap functions call
> + * get/put_swap_device() by themselves.
> + *
>    * Check whether swap entry is valid in the swap device.  If so,
>    * return pointer to swap_info_struct, and keep the swap entry valid
>    * via preventing the swap device from being swapoff, until
> @@ -1227,9 +1234,8 @@ static unsigned char __swap_entry_free_locked(struct swap_info_struct *p,
>    * Notice that swapoff or swapoff+swapon can still happen before the
>    * percpu_ref_tryget_live() in get_swap_device() or after the
>    * percpu_ref_put() in put_swap_device() if there isn't any other way
> - * to prevent swapoff, such as page lock, page table lock, etc.  The
> - * caller must be prepared for that.  For example, the following
> - * situation is possible.
> + * to prevent swapoff.  The caller must be prepared for that.  For
> + * example, the following situation is possible.
>    *
>    *   CPU1				CPU2
>    *   do_swap_page()

Reviewed-by: David Hildenbrand <[e-mail]>

Huang, Ying May 23, 2023, 1 a.m. UTC | #2

David Hildenbrand <[e-mail]> writes:

> On 22.05.23 09:09, Huang Ying wrote:
>> The general rule to use a swap entry is as follows.
>> When we get a swap entry, if there isn't some other way to prevent
>> swapoff, such as page lock for swap cache, page table lock, etc., the
>> swap entry may become invalid because of swapoff.  Then, we need to
>> enclose all swap related functions with get_swap_device() and
>> put_swap_device(), unless the swap functions call
>> get/put_swap_device() by themselves.
>> Add the rule as comments of get_swap_device().
>> Signed-off-by: "Huang, Ying" <[e-mail]>
>> Cc: David Hildenbrand <[e-mail]>
>> Cc: Hugh Dickins <[e-mail]>
>> Cc: Johannes Weiner <[e-mail]>
>> Cc: Matthew Wilcox <[e-mail]>
>> Cc: Michal Hocko <[e-mail]>
>> Cc: Minchan Kim <[e-mail]>
>> Cc: Tim Chen <[e-mail]>
>> Cc: Yang Shi <[e-mail]>
>> Cc: Yu Zhao <[e-mail]>
>> ---
>>   mm/swapfile.c | 12 +++++++++---
>>   1 file changed, 9 insertions(+), 3 deletions(-)
>> diff --git a/mm/swapfile.c b/mm/swapfile.c
>> index 4dbaea64635d..0c1cb935b2eb 100644
>> --- a/mm/swapfile.c
>> +++ b/mm/swapfile.c
>> @@ -1219,6 +1219,13 @@ static unsigned char __swap_entry_free_locked(struct swap_info_struct *p,
>>   }
>>     /*
>> + * When we get a swap entry, if there isn't some other way to prevent
>> + * swapoff, such as page lock for swap cache, page table lock, etc.,
>
> Again "page lock for swap cache" might be imprecise.

Sure.  Will revise this.

>> + * the swap entry may become invalid because of swapoff.  Then, we
>> + * need to enclose all swap related functions with get_swap_device()
>> + * and put_swap_device(), unless the swap functions call
>> + * get/put_swap_device() by themselves.
>> + *
>>    * Check whether swap entry is valid in the swap device.  If so,
>>    * return pointer to swap_info_struct, and keep the swap entry valid
>>    * via preventing the swap device from being swapoff, until
>> @@ -1227,9 +1234,8 @@ static unsigned char __swap_entry_free_locked(struct swap_info_struct *p,
>>    * Notice that swapoff or swapoff+swapon can still happen before the
>>    * percpu_ref_tryget_live() in get_swap_device() or after the
>>    * percpu_ref_put() in put_swap_device() if there isn't any other way
>> - * to prevent swapoff, such as page lock, page table lock, etc.  The
>> - * caller must be prepared for that.  For example, the following
>> - * situation is possible.
>> + * to prevent swapoff.  The caller must be prepared for that.  For
>> + * example, the following situation is possible.
>>    *
>>    *   CPU1				CPU2
>>    *   do_swap_page()
>
> Reviewed-by: David Hildenbrand <[e-mail]>

Thanks!

Best Regards,
Huang, Ying

Yosry Ahmed May 23, 2023, 1:37 a.m. UTC | #3

On Mon, May 22, 2023 at 12:09 AM Huang Ying <[e-mail]> wrote:
>
> The general rule to use a swap entry is as follows.
>
> When we get a swap entry, if there isn't some other way to prevent
> swapoff, such as page lock for swap cache, page table lock, etc., the
> swap entry may become invalid because of swapoff.  Then, we need to
> enclose all swap related functions with get_swap_device() and
> put_swap_device(), unless the swap functions call
> get/put_swap_device() by themselves.
>
> Add the rule as comments of get_swap_device().
>
> Signed-off-by: "Huang, Ying" <[e-mail]>
> Cc: David Hildenbrand <[e-mail]>
> Cc: Hugh Dickins <[e-mail]>
> Cc: Johannes Weiner <[e-mail]>
> Cc: Matthew Wilcox <[e-mail]>
> Cc: Michal Hocko <[e-mail]>
> Cc: Minchan Kim <[e-mail]>
> Cc: Tim Chen <[e-mail]>
> Cc: Yang Shi <[e-mail]>
> Cc: Yu Zhao <[e-mail]>
> ---
>  mm/swapfile.c | 12 +++++++++---
>  1 file changed, 9 insertions(+), 3 deletions(-)
>
> diff --git a/mm/swapfile.c b/mm/swapfile.c
> index 4dbaea64635d..0c1cb935b2eb 100644
> --- a/mm/swapfile.c
> +++ b/mm/swapfile.c
> @@ -1219,6 +1219,13 @@ static unsigned char __swap_entry_free_locked(struct swap_info_struct *p,
>  }
>
>  /*
> + * When we get a swap entry, if there isn't some other way to prevent
> + * swapoff, such as page lock for swap cache, page table lock, etc.,
> + * the swap entry may become invalid because of swapoff.  Then, we
> + * need to enclose all swap related functions with get_swap_device()
> + * and put_swap_device(), unless the swap functions call
> + * get/put_swap_device() by themselves.
> + *
>   * Check whether swap entry is valid in the swap device.  If so,
>   * return pointer to swap_info_struct, and keep the swap entry valid
>   * via preventing the swap device from being swapoff, until
> @@ -1227,9 +1234,8 @@ static unsigned char __swap_entry_free_locked(struct swap_info_struct *p,
>   * Notice that swapoff or swapoff+swapon can still happen before the
>   * percpu_ref_tryget_live() in get_swap_device() or after the
>   * percpu_ref_put() in put_swap_device() if there isn't any other way
> - * to prevent swapoff, such as page lock, page table lock, etc.  The
> - * caller must be prepared for that.  For example, the following
> - * situation is possible.
> + * to prevent swapoff.  The caller must be prepared for that.  For
> + * example, the following situation is possible.
>   *
>   *   CPU1                              CPU2
>   *   do_swap_page()
> --
> 2.39.2
>
>

Thanks for clarifying the code!

With David's comments:
Reviewed-by: Yosry Ahmed <[e-mail]>

Patch

diff --git a/mm/swapfile.c b/mm/swapfile.c
index 4dbaea64635d..0c1cb935b2eb 100644
--- a/mm/swapfile.c
+++ b/mm/swapfile.c
@@ -1219,6 +1219,13 @@  static unsigned char __swap_entry_free_locked(struct swap_info_struct *p,
 }
 
 /*
+ * When we get a swap entry, if there isn't some other way to prevent
+ * swapoff, such as page lock for swap cache, page table lock, etc.,
+ * the swap entry may become invalid because of swapoff.  Then, we
+ * need to enclose all swap related functions with get_swap_device()
+ * and put_swap_device(), unless the swap functions call
+ * get/put_swap_device() by themselves.
+ *
  * Check whether swap entry is valid in the swap device.  If so,
  * return pointer to swap_info_struct, and keep the swap entry valid
  * via preventing the swap device from being swapoff, until
@@ -1227,9 +1234,8 @@  static unsigned char __swap_entry_free_locked(struct swap_info_struct *p,
  * Notice that swapoff or swapoff+swapon can still happen before the
  * percpu_ref_tryget_live() in get_swap_device() or after the
  * percpu_ref_put() in put_swap_device() if there isn't any other way
- * to prevent swapoff, such as page lock, page table lock, etc.  The
- * caller must be prepared for that.  For example, the following
- * situation is possible.
+ * to prevent swapoff.  The caller must be prepared for that.  For
+ * example, the following situation is possible.
  *
  *   CPU1				CPU2
  *   do_swap_page()