[Deepin-Kernel-SIG] [linux 6.6-y] [Upstream] sync maple-tree patches from mainline

[opsiff]

Summary by Sourcery

This pull request introduces the ability to duplicate a maple tree, which is used in the kernel's memory management. It also fixes a number of bugs related to memory management during forking and execve, and improves the performance of forking by using the new maple tree duplication functionality.

New Features:

• Adds the ability to duplicate a maple tree using mtree_dup().

Tests:

• Adds tests for mtree_dup().

[sourcery-ai]

Reviewer's Guide by Sourcery

This pull request introduces a new function, mtree_dup, to duplicate an entire maple tree. It also includes several bug fixes and enhancements related to memory management and error handling during the duplication process. Additionally, the pull request integrates the maple tree duplication functionality into the fork() system call, improving the efficiency of memory management when creating new processes.

Sequence diagram for fork() with mtree_dup

sequenceDiagram
  participant fork()
  participant dup_mmap()
  participant __mt_dup()
  participant ksm_fork()
  participant khugepaged_fork()

  fork()->>dup_mmap(): dup_mmap(mm, oldmm)
  dup_mmap()->>__mt_dup(): __mt_dup(&oldmm->mm_mt, &mm->mm_mt, GFP_KERNEL)
  alt __mt_dup fails
    __mt_dup-->>dup_mmap(): Return error
    dup_mmap()->>ksm_fork(): ksm_fork(mm, oldmm)
    dup_mmap()->>khugepaged_fork(): khugepaged_fork(mm, oldmm)
  else __mt_dup succeeds
    __mt_dup-->>dup_mmap(): Return success
    dup_mmap()->>ksm_fork(): ksm_fork(mm, oldmm)
    dup_mmap()->>khugepaged_fork(): khugepaged_fork(mm, oldmm)
  end
  dup_mmap()->>fork(): Return result

Loading

File-Level Changes

Change	Details	Files
Introduces mtree_dup and __mt_dup functions to duplicate an entire maple tree, offering a more efficient way to copy trees compared to element-by-element insertion.	Implements mtree_dup for duplicating maple trees with locking. Implements __mt_dup for duplicating maple trees without locking. Adds mas_dup_build to build a new maple tree from a source tree. Adds mas_copy_node to copy a maple node and replace the parent. Adds mas_dup_alloc to allocate child nodes for a maple node. Adds mas_dup_free to free an incomplete duplication of a tree.	lib/maple_tree.c include/linux/maple_tree.h
Integrates maple tree duplication into the fork() system call to improve memory management efficiency during process creation.	Replaces the original VMA-based memory duplication logic in dup_mmap with __mt_dup for maple tree duplication. Handles potential memory allocation failures during maple tree duplication in dup_mmap. Introduces vma_iter_clear_gfp to clear a range of entries in the VMA iterator. Introduces XA_ZERO_ENTRY to mark failure points during mmap duplication. Adjusts KSM and khugepaged integration within dup_mmap to accommodate the new duplication mechanism. Updates exit_mmap to handle potentially incomplete VMA duplication due to errors during dup_mmap.	kernel/fork.c mm/mmap.c include/linux/mm.h mm/memory.c
Adds comprehensive tests for the new mtree_dup function, covering various scenarios including full tree duplication, normal duplication, and memory allocation failure.	Introduces compare_node to compare two maple nodes. Introduces compare_tree to compare two maple trees. Introduces build_full_tree to build a full tree for testing. Introduces check_mtree_dup to test the mtree_dup function. Modifies check_forking to use __mt_dup. Adds tests for memory allocation failures during duplication.	tools/testing/radix-tree/maple.c lib/test_maple_tree.c
Adds a test to verify KSM is enabled for the process after fork exec.	Adds ksm_fork_exec_child to test if KSM is enabled for the process. Adds test_prctl_fork_exec to verify KSM is enabled for the process after fork exec.	tools/testing/selftests/mm/ksm_functional_tests.c
Adjusts KSM integration with execve.	Calls ksm_execve with mmap write lock held. Adds ksm_execve to check if KSM is enabled for the process after execve.	fs/exec.c include/linux/ksm.h
Fixes memory freeing in kmem_cache when bulk allocation fails.	Fixes memory freeing in kmem_cache when bulk allocation fails.	tools/testing/radix-tree/linux.c
Fixes userfaultfd context handling on fork failure.	Adds dup_userfaultfd_fail to handle userfaultfd context on fork failure.	fs/userfaultfd.c include/linux/userfaultfd_k.h
Fixes a race condition in uprobes when registering for each VMA.	Adds check_stable_address_space to check if the address space is stable before registering uprobes.	kernel/events/uprobes.c

---

Tips and commands

Interacting with Sourcery

• Trigger a new review: Comment @sourcery-ai review on the pull request.
• Continue discussions: Reply directly to Sourcery's review comments.
• Generate a GitHub issue from a review comment: Ask Sourcery to create an
  issue from a review comment by replying to it. You can also reply to a
  review comment with @sourcery-ai issue to create an issue from it.
• Generate a pull request title: Write @sourcery-ai anywhere in the pull
  request title to generate a title at any time. You can also comment
  @sourcery-ai title on the pull request to (re-)generate the title at any time.
• Generate a pull request summary: Write @sourcery-ai summary anywhere in
  the pull request body to generate a PR summary at any time exactly where you
  want it. You can also comment @sourcery-ai summary on the pull request to
  (re-)generate the summary at any time.
• Generate reviewer's guide: Comment @sourcery-ai guide on the pull
  request to (re-)generate the reviewer's guide at any time.
• Resolve all Sourcery comments: Comment @sourcery-ai resolve on the
  pull request to resolve all Sourcery comments. Useful if you've already
  addressed all the comments and don't want to see them anymore.
• Dismiss all Sourcery reviews: Comment @sourcery-ai dismiss on the pull
  request to dismiss all existing Sourcery reviews. Especially useful if you
  want to start fresh with a new review - don't forget to comment
  @sourcery-ai review to trigger a new review!
• Generate a plan of action for an issue: Comment @sourcery-ai plan on
  an issue to generate a plan of action for it.

Customizing Your Experience

Access your dashboard to:

• Enable or disable review features such as the Sourcery-generated pull request
  summary, the reviewer's guide, and others.
• Change the review language.
• Add, remove or edit custom review instructions.
• Adjust other review settings.

Getting Help

• Contact our support team for questions or feedback.
• Visit our documentation for detailed guides and information.
• Keep in touch with the Sourcery team by following us on X/Twitter, LinkedIn or GitHub.

[deepin-ci-robot]

[APPROVALNOTIFIER] This PR is NOT APPROVED

This pull-request has been approved by:
Once this PR has been reviewed and has the lgtm label, please ask for approval from opsiff. For more information see the Code Review Process.

The full list of commands accepted by this bot can be found here.

Details

Needs approval from an approver in each of these files:

• deepin/OWNERS

Approvers can indicate their approval by writing /approve in a comment
Approvers can cancel approval by writing /approve cancel in a comment

[sourcery-ai]

Hey @opsiff - I've reviewed your changes - here's some feedback:

Overall Comments:

• The compare_tree function could be simplified by comparing the ma_root members directly after comparing ma_flags.
• Consider adding a comment to mas_dup_build explaining why the error code is stored in mas->node.

Here's what I looked at during the review

• 🟡 General issues: 1 issue found
• 🟢 Security: all looks good
• 🟢 Testing: all looks good
• 🟡 Complexity: 2 issues found
• 🟢 Documentation: all looks good

---

Sourcery is free for open source - if you like our reviews please consider sharing them ✨

• X
• Mastodon
• LinkedIn
• Facebook

_{Help me be more useful! Please click 👍 or 👎 on each comment and I'll use the feedback to improve your reviews.}

[sourcery-ai]

suggestion (bug_risk): Inline stub for dup_userfaultfd_fail may conflict.

There is a non-inline implementation of dup_userfaultfd_fail in fs/userfaultfd.c. The inline stub in the header might override or conflict with that implementation. Consider consolidating to a single definition to avoid potential link-time or behavioral inconsistencies.

Suggested implementation:

Make sure the non-inline definition (implementation) of dup_userfaultfd_fail in fs/userfaultfd.c is maintained and that no duplicate declarations exist.

[sourcery-ai]

issue (complexity): Consider refactoring the compare_node and build_full_tree functions into smaller helper functions to improve code readability and reduce complexity by removing the need for goto statements and simplifying control flow.

Consider refactoring the heavily interleaved control flow (especially the use of goto statements) by breaking the functions into smaller, well‐named helper functions. This can reduce complexity without reverting functionality. For example:

1. In compare_node():
   Separate the leaf and internal node comparisons into helper functions. For instance:

   static int compare_leaf_node(const struct maple_node *a, const struct maple_node *b) {
       return memcmp(a, b, sizeof(struct maple_node));
   }
   
   static int compare_internal_node(struct maple_node *a, struct maple_node *b, enum maple_type type) {
       void **slots_a = ma_slots(a, type);
       void **slots_b = ma_slots(b, type);
       for (int i = 0; i < mt_slots[type]; i++) {
           if (!slots_a[i] && !slots_b[i])
               break;
           if (!slots_a[i] || !slots_b[i]) {
               pr_err("The number of slots is different.\n");
               return -1;
           }
           ((unsigned long *)slots_a)[i] &= MAPLE_NODE_MASK;
           ((unsigned long *)slots_b)[i] &= MAPLE_NODE_MASK;
       }
       return memcmp(a, b, sizeof(struct maple_node));
   }

   Then your main function becomes more straightforward:

   static int __init compare_node(struct maple_enode *enode_a, struct maple_enode *enode_b)
   {
       // ... [pre-comparison initialization unchanged]
       if (ma_is_leaf(type))
           return compare_leaf_node(&a, &b);
       else
           return compare_internal_node(&a, &b, type);
   }

2. In build_full_tree():
   Replace goto usage by extracting loops into helper functions. For example, create a helper to perform the “store” operation:

   static inline int store_subtree(struct ma_state *mas, struct maple_tree *mt) {
       mas_subtree_max_range(mas);
       unsigned long step = mas->last - mas->index;
       if (step < 1)
           return -1;
       mas->last = mas->index + step / 2;
       mas_store_gfp(mas, xa_mk_value(5), GFP_KERNEL);
       return 0;
   }

   Then structure the main loop without gotos:

   static __init int build_full_tree(struct maple_tree *mt, unsigned int flags, int height)
   {
       MA_STATE(mas, mt, 0, 0);
       int ret = 0, cnt = 1;
       enum maple_type type;
   
       mt_init_flags(mt, flags);
       mtree_insert_range(mt, 0, ULONG_MAX, xa_mk_value(5), GFP_KERNEL);
       mtree_lock(mt);
   
       while (1) {
           mas_set(&mas, 0);
           if (mt_height(mt) < height) {
               mas.max = ULONG_MAX;
           } else {
               while (1) {
                   mas_dfs_preorder(&mas);
                   if (mas_is_none(&mas)) 
                       goto unlock;
                   type = mte_node_type(mas.node);
                   if (mas_data_end(&mas) + 1 < mt_slots[type]) {
                       mas_set(&mas, mas.min);
                       break;
                   }
               }
           }
           ret = store_subtree(&mas, mt);
           if (ret)
               goto unlock;
           ++cnt;
           // Optionally add a condition to break from the infinite loop.
       }
   unlock:
       mtree_unlock(mt);
       MT_BUG_ON(mt, mt_height(mt) != height);
       return ret;
   }

These small, focused refactorings encapsulate the convoluted parts into helper functions, making the overall flow clearer and easier to maintain.

[sourcery-ai]

issue (complexity): Consider refactoring the DFS duplication logic to improve clarity by isolating traversal steps into smaller, focused helpers or using a recursive approach where appropriate to reduce cognitive complexity without changing functionality

The DFS duplication logic mixes control flow (including a while (1) loop, manual ascent/descent management, etc.) and helper functions that can make it hard to follow. One way to reduce cognitive complexity without changing functionality is to isolate the traversal steps in small, focused helpers or even switch to a recursive approach when possible.

For example, consider splitting the non-leaf handling and leaf processing into separate inline helpers. This refactor could look like:

static inline int mas_handle_leaf(struct ma_state *mas, struct ma_state *new_mas)
{
    /* When at a leaf and not at the final node, ascend until a subtree change is needed */
    do {
        mas_ascend(mas);
        mas_ascend(new_mas);
    } while (mas->offset == mas_data_end(mas));

    mas->offset++;
    new_mas->offset++;
    return 0; // You can also return an error code if needed
}

And then in the main duplication routine, refactor the DFS loop to improve clarity:

static inline void mas_dup_build(struct ma_state *mas, struct ma_state *new_mas, gfp_t gfp)
{
    struct maple_node *node;
    struct maple_pnode *parent = NULL;
    struct maple_enode *root;
    enum maple_type type;

    if (unlikely(mt_attr(mas->tree) != mt_attr(new_mas->tree)) ||
        unlikely(!mtree_empty(new_mas->tree))) {
        mas_set_err(mas, -EINVAL);
        return;
    }

    root = mas_start(mas);
    if (mas_is_ptr(mas) || mas_is_none(mas))
        goto set_new_tree;

    node = mt_alloc_one(gfp);
    if (!node) {
        new_mas->node = MAS_NONE;
        mas_set_err(mas, -ENOMEM);
        return;
    }

    type = mte_node_type(mas->node);
    root = mt_mk_node(node, type);
    new_mas->node = root;
    new_mas->min = 0;
    new_mas->max = ULONG_MAX;
    root = mte_mk_root(root);

    while (1) {
        mas_copy_node(mas, new_mas, parent);
        if (!mte_is_leaf(mas->node)) {
            /* Allocate child nodes for non-leaf nodes */
            mas_dup_alloc(mas, new_mas, gfp);
            if (unlikely(mas_is_err(mas)))
                return;
        } else {
            /* Process leaf: if duplication complete, break; otherwise, adjust state */
            if (mas->max == ULONG_MAX)
                break;
            mas_handle_leaf(mas, new_mas);
        }

        mas_descend(mas);
        parent = ma_parent_ptr(mte_to_node(new_mas->node));
        mas_descend(new_mas);
        mas->offset = 0;
        new_mas->offset = 0;
    }

    /* Special handling for root parent update */
    mte_to_node(root)->parent = ma_parent_ptr(mas_tree_parent(new_mas));

set_new_tree:
    new_mas->tree->ma_flags = mas->tree->ma_flags;
    rcu_assign_pointer(new_mas->tree->ma_root, root);
}

Actionable Steps:

1. Extract leaf handling: Isolate the logic for processing leaf nodes (e.g., the ascent loop and offset adjustments) into its own helper function as shown above.
2. Refactor the DFS loop: Use the helper(s) to break up the lengthy while (1) loop into logically separated steps. This makes the control flow easier to follow.
3. Consider a recursive approach: Where safe (e.g., tree depth is bounded), a recursive helper could replace the manual state management. Ensure to measure stack usage if you choose that route.

These changes keep the functionality intact while reducing the interleaving of complex control flow and inline operations.

[opsiff]

@sourcery-ai review

[sourcery-ai]

Hey @opsiff - I've reviewed your changes - here's some feedback:

Overall Comments:

• Consider adding a comment describing the locking strategy for mtree_dup.
• The compare_tree function in tools/testing/radix-tree/maple.c could be improved by using a MA_STATE for both trees simultaneously, instead of calling mas_dfs_preorder repeatedly.

Here's what I looked at during the review

• 🟡 General issues: 1 issue found
• 🟢 Security: all looks good
• 🟢 Testing: all looks good
• 🟡 Complexity: 1 issue found
• 🟢 Documentation: all looks good

---

Sourcery is free for open source - if you like our reviews please consider sharing them ✨

• X
• Mastodon
• LinkedIn
• Facebook

_{Help me be more useful! Please click 👍 or 👎 on each comment and I'll use the feedback to improve your reviews.}

[sourcery-ai]

issue (complexity): Consider refactoring compare_node and build_full_tree to use early returns and clearer loop constructs instead of gotos to improve readability and reduce complexity.

In several functions (particularly in `compare_node` and `build_full_tree`), the complexity is increased by nested conditions and nonlocal jumps with `goto`. Consider refactoring those sections to use early returns or clearer loop constructs. For example:

**In `compare_node`:**
Replace the use of `goto cmp` with an early exit for leaf nodes. For example, change
```c
if (ma_is_leaf(type))
    goto cmp;

to:

if (ma_is_leaf(type))
    return memcmp(&a, &b, sizeof(struct maple_node));

and then do the rest of the comparisons normally. This flattens the control flow.

In build_full_tree:
You can refactor the inner while (1) and goto store/goto unlock by using flags or breaking out of the loops. For example, refactor like this:

static __init int build_full_tree(struct maple_tree *mt, unsigned int flags, int height)
{
    MA_STATE(mas, mt, 0, 0);
    unsigned long step;
    int ret = 0, cnt = 1;
    enum maple_type type;

    mt_init_flags(mt, flags);
    mtree_insert_range(mt, 0, ULONG_MAX, xa_mk_value(5), GFP_KERNEL);
    mtree_lock(mt);

    while (1) {
        mas_set(&mas, 0);

        if (mt_height(mt) < height) {
            mas.max = ULONG_MAX;
            /* Process store step */
        } else {
            bool found = false;
            while (1) {
                mas_dfs_preorder(&mas);
                if (mas_is_none(&mas)) {
                    ret = 0;
                    goto unlock;
                }
                type = mte_node_type(mas.node);
                if (mas_data_end(&mas) + 1 < mt_slots[type]) {
                    mas_set(&mas, mas.min);
                    found = true;
                    break;
                }
            }
            if (!found)
                break;  /* terminate if processing is done */
        }

        mas_subtree_max_range(&mas);
        step = mas.last - mas.index;
        if (step < 1) {
            ret = -1;
            break;
        }
        step /= 2;
        mas.last = mas.index + step;
        mas_store_gfp(&mas, xa_mk_value(5), GFP_KERNEL);
        ++cnt;
    }
unlock:
    mtree_unlock(mt);
    MT_BUG_ON(mt, mt_height(mt) != height);
    return ret;
}

This refactoring uses a flag (found) and break statements rather than interleaving goto labels, which helps to document the different stages more clearly.

These small changes can greatly improve readability while preserving all the functionality.

[opsiff]

/test-ok