[Deepin-Kernel-SIG] [linux 6.6-y] [Upstream] Update kernel base to 6.6.80

[Avenger-285714]

Update kernel base to 6.6.80.

Handle ("perf/x86/intel: Fix ARCH_PERFMON_NUM_COUNTER_LEAF") because of b3b443c ("perf/x86/intel: Add common intel_pmu_init_hybrid").

[sourcery-ai]

Reviewer's Guide by Sourcery

The pull request updates the kernel base to version 6.6.80 and includes various changes across multiple subsystems, including file system, drivers, and architecture-specific code. Key changes involve updates to the XFS file system, improvements in device drivers, and enhancements in architecture-specific implementations.

Sequence diagram for md_check_recovery

sequenceDiagram
  participant md_check_recovery
  participant mddev
  participant md_bitmap_write_all
  participant queue_work
  participant md_misc_wq
  participant md_start_sync

  md_check_recovery->>mddev: md_check_recovery(mddev)
  activate md_check_recovery
  alt bitmap && need_write_bitmap
    md_check_recovery->>md_bitmap_write_all: md_bitmap_write_all(mddev->bitmap)
    activate md_bitmap_write_all
    md_bitmap_write_all-->>md_check_recovery: return
    deactivate md_bitmap_write_all
  end
  md_check_recovery->>queue_work: queue_work(md_misc_wq, &mddev->sync_work)
  activate queue_work
  queue_work->>md_misc_wq: Queue mddev->sync_work
  deactivate queue_work
  md_misc_wq->>md_start_sync: md_start_sync(mddev)
  activate md_start_sync
  md_start_sync-->>md_misc_wq: return
  deactivate md_start_sync
  md_check_recovery-->>mddev: return
  deactivate md_check_recovery

Loading

File-Level Changes

Change	Details	Files
Update XFS file system to handle attribute operations and inode management.	Removed unused function xfs_attr_leaf_try_add. Added functions xfs_attr_save_rmt_blk and xfs_attr_restore_rmt_blk for managing remote block information. Modified xfs_attr_leaf_addname to improve attribute addition logic. Updated xfs_attr3_leaf_add to return a boolean indicating success or need for further action.	fs/xfs/libxfs/xfs_attr.c fs/xfs/libxfs/xfs_attr_leaf.c fs/xfs/libxfs/xfs_attr_leaf.h
Enhance md (multiple device) driver for better synchronization and management.	Introduced __mddev_put function for better resource management. Added new work_struct sync_work for managing synchronization tasks. Updated mddev_put to use __mddev_put for cleanup.	drivers/md/md.c drivers/md/md.h
Implement changes in the Bluetooth driver for improved firmware handling.	Added qca_filename_has_extension function to check file extensions. Implemented qca_get_alt_nvm_file to handle alternative NVM file loading. Updated qca_download_firmware to retry with default firmware if board-specific file is missing.	drivers/bluetooth/btqca.c
Refactor and optimize TCP and network-related functionalities.	Introduced tcp_cleanup_skb and tcp_add_receive_queue for better skb management. Refactored tcp_read_sock to separate logic for acknowledgment handling. Enhanced strparser to support custom read_sock callback.	net/core/flow_dissector.c net/core/skmsg.c net/ipv4/tcp.c net/ipv4/tcp_input.c net/strparser/strparser.c
Add new PHY drivers for CIX USB and USBDP.	Added new driver files for CIX USB2, USB3, and USBDP PHYs. Implemented initialization and configuration logic for PHYs. Integrated with typec switch and mux for orientation and mode management.	drivers/phy/cix/phy-cix-usb2.c drivers/phy/cix/phy-cix-usb3.c drivers/phy/cix/phy-cix-usbdp.c drivers/phy/cix/phy-cix-usbdp.h

---

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.

[sourcery-ai]

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

Overall Comments:

• The diff contains a mix of bug fixes and new features, so it might be helpful to categorize the changes for easier review.

Here's what I looked at during the review

• 🟢 General issues: all looks good
• 🟢 Security: all looks good
• 🟢 Testing: all looks good
• 🟡 Complexity: 4 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]

issue (complexity): Consider extracting common parts of the flush and stats-update logic into helper functions to reduce multiple branches and duplicated counter updates without changing functionality, such as consolidating the flush logic by splitting the hcall trigger and error handling into a helper that’s parameterized by the flush mode and extracting the tx_stats updates into one helper function with an enum for the tx_type.

Consider extracting the common parts of the flush and stats‐update logic into helper functions. This can reduce the multiple branches and duplicated counter updates without changing functionality. For example, you might extract the tx_stats updates into one helper:

```c
enum tx_type {
    TX_INDIRECT,
    TX_DIRECT
};

static inline void update_tx_stats(struct ibmvnic_adapter *adapter, int queue_num,
                                   enum tx_type type, unsigned int packets, unsigned int bytes)
{
    adapter->tx_stats_buffers[queue_num].bytes += bytes;
    if (type == TX_DIRECT)
        adapter->tx_stats_buffers[queue_num].direct_packets += packets;
    else
        adapter->tx_stats_buffers[queue_num].batched_packets += packets;
}

Then within ibmvnic_xmit update counters with a single call:

// Replace separate tx_dpackets/tx_bpackets updates with:
update_tx_stats(adapter, queue_num, /* TX_DIRECT or TX_INDIRECT */ selected_type, tx_packets, skblen);

Similarly, consider consolidating the flush logic by splitting the hcall trigger and error handling into a helper that’s parameterized by the flush mode. This refactoring centralizes the routing decisions and avoids duplicated checks.

static int flush_subcrq(struct ibmvnic_adapter *adapter,
                        struct ibmvnic_sub_crq_queue *tx_scrq, bool indirect)
{
    int rc;
    if (indirect)
        rc = send_subcrq_indirect(adapter, tx_scrq->handle,
                                  (u64)tx_scrq->ind_buf.indir_dma,
                                  (u64)tx_scrq->ind_buf.index);
    else
        rc = send_subcrq_direct(adapter, tx_scrq->handle,
                                (u64 *)tx_scrq->ind_buf.indir_arr);

    if (rc)
        ibmvnic_tx_scrq_clean_buffer(adapter, tx_scrq);
    else
        tx_scrq->ind_buf.index = 0;

    return rc;
}

Then update callers to use flush_subcrq so that the flush path is unified.

These focused refactorings help keep the functionality while reducing branching complexity and duplication.

[sourcery-ai]

issue (complexity): Consider simplifying the alternate NVM file name generation by merging the extension check and replacement into one function using the “%.*s” formatter to avoid extra helper functions and temporary buffers .

Consider simplifying the alternate NVM file name generation in
`qca_get_alt_nvm_file()` by removing the extra helper and temporary buffer.
For example, you can merge the extension check and replacement into one
function using the “%.*s” formatter:

static bool qca_get_alt_nvm_file(char *filename, size_t max_size)
{
    char *dot = strrchr(filename, '.');
    if (!dot || dot == filename || !*(dot + 1))
        return false;
    /* Return if already using the default ".bin" extension */
    if (strcmp(dot, ".bin") == 0)
        return false;
    snprintf(filename, max_size, "%.*s.bin", (int)(dot - filename), filename);
    return true;
}

This reduces the number of helper functions and temporary buffers while keeping
all functionality intact.

[sourcery-ai]

issue (complexity): Consider using error codes and an out parameter to signal whether a split is still needed, instead of mixing boolean return values with error codes in functions like xfs_attr3_leaf_add and its callers, to improve clarity and maintainability of the code.

Consider unifying the error‐reporting style in these routines. In several functions (like `xfs_attr3_leaf_add` and its caller wrappers) we now mix returning a boolean (to signal “entry added” vs. “needs further split”) with error codes, which makes the caller logic non‐obvious.

One approach is to always return an error code and use an out parameter for any additional signal (for example, whether a split is still needed). For instance:

```c
/* New signature with an extra "added" out parameter */
int xfs_attr3_leaf_add(struct xfs_buf *bp, struct xfs_da_args *args, bool *added) {
    struct xfs_attr_leafblock *leaf = bp->b_addr;
    struct xfs_attr3_icleaf_hdr ichdr;
    int entsize, error;

    trace_xfs_attr_leaf_add(args);
    xfs_attr3_leaf_hdr_from_disk(args->geo, &ichdr, leaf);
    ASSERT(args->index >= 0 && args->index <= ichdr.count);
    entsize = xfs_attr_leaf_newentsize(args, NULL);

    // Compute space etc.
    if (/* not enough space */) {
        *added = false;
        return -ENOSPC;
    }

    error = xfs_attr3_leaf_add_work(bp, &ichdr, args, 0);
    if (error)
        return error;

    xfs_attr3_leaf_hdr_to_disk(args->geo, leaf, &ichdr);
    xfs_trans_log_buf(args->trans, bp,
        XFS_DA_LOGRANGE(leaf, &leaf->hdr, xfs_attr3_leaf_hdr_size(leaf)));

    /* Use the out-param to signal whether the entry was added or we need a further split */
    *added = /* condition depending on available free space */;
    return 0;
}

Callers then check the error code first and use the out parameter to detect if the split is still required:

bool added;
error = xfs_attr3_leaf_add(bp, args, &added);
if (error)
    return error;
if (!added)
    return 1;  // or a defined constant indicating a further split is needed

This approach keeps error codes and success signals separate and avoids mixing booleans with negative error numbers. Adjust similar functions (e.g. xfs_attr3_leaf_add_work) accordingly to maintain consistency while preserving all functionality.

[sourcery-ai]

issue (complexity): Consider creating a helper function to centralize the register write/update sequences, reducing code duplication and improving readability by accepting parameters for the target lane's register base and looping over the lanes to select the appropriate lane numbers by checking the flip flag, which preserves functionality while improving maintainability and reducing redundancy..

You can reduce duplication by centralizing the nearly identical register write/update sequences into a helper that accepts parameters for the target lane’s register base. For example, in the udphy_dp_phy_set_voltages() function, you could replace the repeated blocks with something like:

static void set_lane_voltage(struct cix_udphy *udphy, int lane,
                             const phy_voltage_conf_t *cfg)
{
    /* Map lane to register offsets: adjust naming/index as needed */
    const unsigned int acya_reg[]  = { TX_DIAG_ACYA_LANE0, TX_DIAG_ACYA_LANE1,
                                       TX_DIAG_ACYA_LANE2, TX_DIAG_ACYA_LANE3 };
    const unsigned int txcc_ctrl[] = { TX_TXCC_CTRL_LANE0, TX_TXCC_CTRL_LANE1,
                                       TX_TXCC_CTRL_LANE2, TX_TXCC_CTRL_LANE3 };
    const unsigned int tx_drv[]    = { DRV_DIAG_TX_DRV_LANE0, DRV_DIAG_TX_DRV_LANE1,
                                       DRV_DIAG_TX_DRV_LANE2, DRV_DIAG_TX_DRV_LANE3 };
    const unsigned int txcc_mult[] = { TX_TXCC_MGNFS_MULT_000_LANE0, TX_TXCC_MGNFS_MULT_000_LANE1,
                                       TX_TXCC_MGNFS_MULT_000_LANE2, TX_TXCC_MGNFS_MULT_000_LANE3 };
    const unsigned int txcc_cpost[] = { TX_TXCC_CPOST_MULT_00_LANE0, TX_TXCC_CPOST_MULT_00_LANE1,
                                        TX_TXCC_CPOST_MULT_00_LANE2, TX_TXCC_CPOST_MULT_00_LANE3 };

    /* Trigger update, write values, then clear update */
    regmap_update_bits(udphy->phy_regmap, acya_reg[lane], BIT(0), 0x1);
    regmap_write(udphy->phy_regmap, txcc_ctrl[lane], cfg->tx_txcc_ctrl);
    regmap_write(udphy->phy_regmap, tx_drv[lane], cfg->drv_diag_tx_drv);
    regmap_write(udphy->phy_regmap, txcc_mult[lane], cfg->tx_txcc_mgnfc_mult_000);
    regmap_write(udphy->phy_regmap, txcc_cpost[lane], cfg->tx_txcc_cpost_mult_00);
    regmap_update_bits(udphy->phy_regmap, acya_reg[lane], BIT(0), 0x0);
}

Then, in your voltage setting function, you can loop over the lanes and select the appropriate lane numbers by checking the flip flag. For example:

static int udphy_dp_phy_set_voltages(struct cix_udphy *udphy,
                                     struct phy_configure_opts_dp *dp)
{
    u32 index = dp->voltage[0] * 4 + dp->pre[0];
    const phy_voltage_conf_t *cfg = &volt_cfg[index];

    switch (dp->lanes) {
    case 1:
        set_lane_voltage(udphy, udphy->flip ? 1 : 2, cfg);
        break;
    case 2:
        if (!udphy->flip) {
            set_lane_voltage(udphy, 2, cfg);
            set_lane_voltage(udphy, 3, cfg);
        } else {
            set_lane_voltage(udphy, 0, cfg);
            set_lane_voltage(udphy, 1, cfg);
        }
        break;
    case 4:
        for (int i = 0; i < 4; i++)
            set_lane_voltage(udphy, i, cfg);
        break;
    default:
        break;
    }
    return 0;
}

This approach reduces repetition and improves readability while preserving functionality. Adjust lane-to-register mapping as needed for your hardware.

[deepin-ci-robot]

[APPROVALNOTIFIER] This PR is APPROVED

This pull-request has been approved by: opsiff

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

The pull request process is described here

Details

Needs approval from an approver in each of these files:

• deepin/OWNERS [opsiff]

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