lkml.org 
[lkml]   [2015]   [Jun]   [17]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[PATCH 3.19.y-ckt 146/146] be2net: Replace dma/pci_alloc_coherent() calls with dma_zalloc_coherent()
    Date
    3.19.8-ckt2 -stable review patch.  If anyone has any objections, please let me know.

    ------------------

    From: Sriharsha Basavapatna <sriharsha.basavapatna@avagotech.com>

    [ Upstream commit e51000db4c880165eab06ec0990605f24e75203f ]

    There are several places in the driver (all in control paths) where
    coherent dma memory is being allocated using either dma_alloc_coherent()
    or the deprecated pci_alloc_consistent(). All these calls should be
    changed to use dma_zalloc_coherent() to avoid uninitialized fields in
    data structures backed by this memory.

    Reported-by: Joerg Roedel <jroedel@suse.de>
    Tested-by: Joerg Roedel <jroedel@suse.de>
    Signed-off-by: Sriharsha Basavapatna <sriharsha.basavapatna@avagotech.com>
    Signed-off-by: David S. Miller <davem@davemloft.net>
    Signed-off-by: Kamal Mostafa <kamal@canonical.com>
    ---
    drivers/net/ethernet/emulex/benet/be_cmds.c | 87 +++++++++++++++-----------
    drivers/net/ethernet/emulex/benet/be_ethtool.c | 18 +++---
    drivers/net/ethernet/emulex/benet/be_main.c | 16 ++---
    3 files changed, 68 insertions(+), 53 deletions(-)

    diff --git a/drivers/net/ethernet/emulex/benet/be_cmds.c b/drivers/net/ethernet/emulex/benet/be_cmds.c
    index fead5c6..9c827b7 100644
    --- a/drivers/net/ethernet/emulex/benet/be_cmds.c
    +++ b/drivers/net/ethernet/emulex/benet/be_cmds.c
    @@ -1705,9 +1705,9 @@ int be_cmd_get_regs(struct be_adapter *adapter, u32 buf_len, void *buf)
    total_size = buf_len;

    get_fat_cmd.size = sizeof(struct be_cmd_req_get_fat) + 60*1024;
    - get_fat_cmd.va = pci_alloc_consistent(adapter->pdev,
    - get_fat_cmd.size,
    - &get_fat_cmd.dma);
    + get_fat_cmd.va = dma_zalloc_coherent(&adapter->pdev->dev,
    + get_fat_cmd.size,
    + &get_fat_cmd.dma, GFP_ATOMIC);
    if (!get_fat_cmd.va) {
    dev_err(&adapter->pdev->dev,
    "Memory allocation failure while reading FAT data\n");
    @@ -1752,8 +1752,8 @@ int be_cmd_get_regs(struct be_adapter *adapter, u32 buf_len, void *buf)
    log_offset += buf_size;
    }
    err:
    - pci_free_consistent(adapter->pdev, get_fat_cmd.size,
    - get_fat_cmd.va, get_fat_cmd.dma);
    + dma_free_coherent(&adapter->pdev->dev, get_fat_cmd.size,
    + get_fat_cmd.va, get_fat_cmd.dma);
    spin_unlock_bh(&adapter->mcc_lock);
    return status;
    }
    @@ -2223,12 +2223,12 @@ int be_cmd_read_port_transceiver_data(struct be_adapter *adapter,
    return -EINVAL;

    cmd.size = sizeof(struct be_cmd_resp_port_type);
    - cmd.va = pci_alloc_consistent(adapter->pdev, cmd.size, &cmd.dma);
    + cmd.va = dma_zalloc_coherent(&adapter->pdev->dev, cmd.size, &cmd.dma,
    + GFP_ATOMIC);
    if (!cmd.va) {
    dev_err(&adapter->pdev->dev, "Memory allocation failed\n");
    return -ENOMEM;
    }
    - memset(cmd.va, 0, cmd.size);

    spin_lock_bh(&adapter->mcc_lock);

    @@ -2253,7 +2253,7 @@ int be_cmd_read_port_transceiver_data(struct be_adapter *adapter,
    }
    err:
    spin_unlock_bh(&adapter->mcc_lock);
    - pci_free_consistent(adapter->pdev, cmd.size, cmd.va, cmd.dma);
    + dma_free_coherent(&adapter->pdev->dev, cmd.size, cmd.va, cmd.dma);
    return status;
    }

    @@ -2702,7 +2702,8 @@ int be_cmd_get_phy_info(struct be_adapter *adapter)
    goto err;
    }
    cmd.size = sizeof(struct be_cmd_req_get_phy_info);
    - cmd.va = pci_alloc_consistent(adapter->pdev, cmd.size, &cmd.dma);
    + cmd.va = dma_zalloc_coherent(&adapter->pdev->dev, cmd.size, &cmd.dma,
    + GFP_ATOMIC);
    if (!cmd.va) {
    dev_err(&adapter->pdev->dev, "Memory alloc failure\n");
    status = -ENOMEM;
    @@ -2736,7 +2737,7 @@ int be_cmd_get_phy_info(struct be_adapter *adapter)
    BE_SUPPORTED_SPEED_1GBPS;
    }
    }
    - pci_free_consistent(adapter->pdev, cmd.size, cmd.va, cmd.dma);
    + dma_free_coherent(&adapter->pdev->dev, cmd.size, cmd.va, cmd.dma);
    err:
    spin_unlock_bh(&adapter->mcc_lock);
    return status;
    @@ -2787,8 +2788,9 @@ int be_cmd_get_cntl_attributes(struct be_adapter *adapter)

    memset(&attribs_cmd, 0, sizeof(struct be_dma_mem));
    attribs_cmd.size = sizeof(struct be_cmd_resp_cntl_attribs);
    - attribs_cmd.va = pci_alloc_consistent(adapter->pdev, attribs_cmd.size,
    - &attribs_cmd.dma);
    + attribs_cmd.va = dma_zalloc_coherent(&adapter->pdev->dev,
    + attribs_cmd.size,
    + &attribs_cmd.dma, GFP_ATOMIC);
    if (!attribs_cmd.va) {
    dev_err(&adapter->pdev->dev, "Memory allocation failure\n");
    status = -ENOMEM;
    @@ -2815,8 +2817,8 @@ int be_cmd_get_cntl_attributes(struct be_adapter *adapter)
    err:
    mutex_unlock(&adapter->mbox_lock);
    if (attribs_cmd.va)
    - pci_free_consistent(adapter->pdev, attribs_cmd.size,
    - attribs_cmd.va, attribs_cmd.dma);
    + dma_free_coherent(&adapter->pdev->dev, attribs_cmd.size,
    + attribs_cmd.va, attribs_cmd.dma);
    return status;
    }

    @@ -2954,9 +2956,10 @@ int be_cmd_get_mac_from_list(struct be_adapter *adapter, u8 *mac,

    memset(&get_mac_list_cmd, 0, sizeof(struct be_dma_mem));
    get_mac_list_cmd.size = sizeof(struct be_cmd_resp_get_mac_list);
    - get_mac_list_cmd.va = pci_alloc_consistent(adapter->pdev,
    - get_mac_list_cmd.size,
    - &get_mac_list_cmd.dma);
    + get_mac_list_cmd.va = dma_zalloc_coherent(&adapter->pdev->dev,
    + get_mac_list_cmd.size,
    + &get_mac_list_cmd.dma,
    + GFP_ATOMIC);

    if (!get_mac_list_cmd.va) {
    dev_err(&adapter->pdev->dev,
    @@ -3029,8 +3032,8 @@ int be_cmd_get_mac_from_list(struct be_adapter *adapter, u8 *mac,

    out:
    spin_unlock_bh(&adapter->mcc_lock);
    - pci_free_consistent(adapter->pdev, get_mac_list_cmd.size,
    - get_mac_list_cmd.va, get_mac_list_cmd.dma);
    + dma_free_coherent(&adapter->pdev->dev, get_mac_list_cmd.size,
    + get_mac_list_cmd.va, get_mac_list_cmd.dma);
    return status;
    }

    @@ -3083,8 +3086,8 @@ int be_cmd_set_mac_list(struct be_adapter *adapter, u8 *mac_array,

    memset(&cmd, 0, sizeof(struct be_dma_mem));
    cmd.size = sizeof(struct be_cmd_req_set_mac_list);
    - cmd.va = dma_alloc_coherent(&adapter->pdev->dev, cmd.size,
    - &cmd.dma, GFP_KERNEL);
    + cmd.va = dma_zalloc_coherent(&adapter->pdev->dev, cmd.size, &cmd.dma,
    + GFP_KERNEL);
    if (!cmd.va)
    return -ENOMEM;

    @@ -3255,7 +3258,8 @@ int be_cmd_get_acpi_wol_cap(struct be_adapter *adapter)

    memset(&cmd, 0, sizeof(struct be_dma_mem));
    cmd.size = sizeof(struct be_cmd_resp_acpi_wol_magic_config_v1);
    - cmd.va = pci_alloc_consistent(adapter->pdev, cmd.size, &cmd.dma);
    + cmd.va = dma_zalloc_coherent(&adapter->pdev->dev, cmd.size, &cmd.dma,
    + GFP_ATOMIC);
    if (!cmd.va) {
    dev_err(&adapter->pdev->dev, "Memory allocation failure\n");
    status = -ENOMEM;
    @@ -3290,7 +3294,8 @@ int be_cmd_get_acpi_wol_cap(struct be_adapter *adapter)
    err:
    mutex_unlock(&adapter->mbox_lock);
    if (cmd.va)
    - pci_free_consistent(adapter->pdev, cmd.size, cmd.va, cmd.dma);
    + dma_free_coherent(&adapter->pdev->dev, cmd.size, cmd.va,
    + cmd.dma);
    return status;

    }
    @@ -3304,8 +3309,9 @@ int be_cmd_set_fw_log_level(struct be_adapter *adapter, u32 level)

    memset(&extfat_cmd, 0, sizeof(struct be_dma_mem));
    extfat_cmd.size = sizeof(struct be_cmd_resp_get_ext_fat_caps);
    - extfat_cmd.va = pci_alloc_consistent(adapter->pdev, extfat_cmd.size,
    - &extfat_cmd.dma);
    + extfat_cmd.va = dma_zalloc_coherent(&adapter->pdev->dev,
    + extfat_cmd.size, &extfat_cmd.dma,
    + GFP_ATOMIC);
    if (!extfat_cmd.va)
    return -ENOMEM;

    @@ -3327,8 +3333,8 @@ int be_cmd_set_fw_log_level(struct be_adapter *adapter, u32 level)

    status = be_cmd_set_ext_fat_capabilites(adapter, &extfat_cmd, cfgs);
    err:
    - pci_free_consistent(adapter->pdev, extfat_cmd.size, extfat_cmd.va,
    - extfat_cmd.dma);
    + dma_free_coherent(&adapter->pdev->dev, extfat_cmd.size, extfat_cmd.va,
    + extfat_cmd.dma);
    return status;
    }

    @@ -3341,8 +3347,9 @@ int be_cmd_get_fw_log_level(struct be_adapter *adapter)

    memset(&extfat_cmd, 0, sizeof(struct be_dma_mem));
    extfat_cmd.size = sizeof(struct be_cmd_resp_get_ext_fat_caps);
    - extfat_cmd.va = pci_alloc_consistent(adapter->pdev, extfat_cmd.size,
    - &extfat_cmd.dma);
    + extfat_cmd.va = dma_zalloc_coherent(&adapter->pdev->dev,
    + extfat_cmd.size, &extfat_cmd.dma,
    + GFP_ATOMIC);

    if (!extfat_cmd.va) {
    dev_err(&adapter->pdev->dev, "%s: Memory allocation failure\n",
    @@ -3360,8 +3367,8 @@ int be_cmd_get_fw_log_level(struct be_adapter *adapter)
    level = cfgs->module[0].trace_lvl[j].dbg_lvl;
    }
    }
    - pci_free_consistent(adapter->pdev, extfat_cmd.size, extfat_cmd.va,
    - extfat_cmd.dma);
    + dma_free_coherent(&adapter->pdev->dev, extfat_cmd.size, extfat_cmd.va,
    + extfat_cmd.dma);
    err:
    return level;
    }
    @@ -3567,7 +3574,8 @@ int be_cmd_get_func_config(struct be_adapter *adapter, struct be_resources *res)

    memset(&cmd, 0, sizeof(struct be_dma_mem));
    cmd.size = sizeof(struct be_cmd_resp_get_func_config);
    - cmd.va = pci_alloc_consistent(adapter->pdev, cmd.size, &cmd.dma);
    + cmd.va = dma_zalloc_coherent(&adapter->pdev->dev, cmd.size, &cmd.dma,
    + GFP_ATOMIC);
    if (!cmd.va) {
    dev_err(&adapter->pdev->dev, "Memory alloc failure\n");
    status = -ENOMEM;
    @@ -3607,7 +3615,8 @@ int be_cmd_get_func_config(struct be_adapter *adapter, struct be_resources *res)
    err:
    mutex_unlock(&adapter->mbox_lock);
    if (cmd.va)
    - pci_free_consistent(adapter->pdev, cmd.size, cmd.va, cmd.dma);
    + dma_free_coherent(&adapter->pdev->dev, cmd.size, cmd.va,
    + cmd.dma);
    return status;
    }

    @@ -3628,7 +3637,8 @@ int be_cmd_get_profile_config(struct be_adapter *adapter,

    memset(&cmd, 0, sizeof(struct be_dma_mem));
    cmd.size = sizeof(struct be_cmd_resp_get_profile_config);
    - cmd.va = pci_alloc_consistent(adapter->pdev, cmd.size, &cmd.dma);
    + cmd.va = dma_zalloc_coherent(&adapter->pdev->dev, cmd.size, &cmd.dma,
    + GFP_ATOMIC);
    if (!cmd.va)
    return -ENOMEM;

    @@ -3667,7 +3677,8 @@ int be_cmd_get_profile_config(struct be_adapter *adapter,
    res->vf_if_cap_flags = vf_res->cap_flags;
    err:
    if (cmd.va)
    - pci_free_consistent(adapter->pdev, cmd.size, cmd.va, cmd.dma);
    + dma_free_coherent(&adapter->pdev->dev, cmd.size, cmd.va,
    + cmd.dma);
    return status;
    }

    @@ -3682,7 +3693,8 @@ static int be_cmd_set_profile_config(struct be_adapter *adapter, void *desc,

    memset(&cmd, 0, sizeof(struct be_dma_mem));
    cmd.size = sizeof(struct be_cmd_req_set_profile_config);
    - cmd.va = pci_alloc_consistent(adapter->pdev, cmd.size, &cmd.dma);
    + cmd.va = dma_zalloc_coherent(&adapter->pdev->dev, cmd.size, &cmd.dma,
    + GFP_ATOMIC);
    if (!cmd.va)
    return -ENOMEM;

    @@ -3698,7 +3710,8 @@ static int be_cmd_set_profile_config(struct be_adapter *adapter, void *desc,
    status = be_cmd_notify_wait(adapter, &wrb);

    if (cmd.va)
    - pci_free_consistent(adapter->pdev, cmd.size, cmd.va, cmd.dma);
    + dma_free_coherent(&adapter->pdev->dev, cmd.size, cmd.va,
    + cmd.dma);
    return status;
    }

    diff --git a/drivers/net/ethernet/emulex/benet/be_ethtool.c b/drivers/net/ethernet/emulex/benet/be_ethtool.c
    index 73a500c..9a5b48b 100644
    --- a/drivers/net/ethernet/emulex/benet/be_ethtool.c
    +++ b/drivers/net/ethernet/emulex/benet/be_ethtool.c
    @@ -266,8 +266,8 @@ static int lancer_cmd_read_file(struct be_adapter *adapter, u8 *file_name,
    int status = 0;

    read_cmd.size = LANCER_READ_FILE_CHUNK;
    - read_cmd.va = pci_alloc_consistent(adapter->pdev, read_cmd.size,
    - &read_cmd.dma);
    + read_cmd.va = dma_zalloc_coherent(&adapter->pdev->dev, read_cmd.size,
    + &read_cmd.dma, GFP_ATOMIC);

    if (!read_cmd.va) {
    dev_err(&adapter->pdev->dev,
    @@ -291,8 +291,8 @@ static int lancer_cmd_read_file(struct be_adapter *adapter, u8 *file_name,
    break;
    }
    }
    - pci_free_consistent(adapter->pdev, read_cmd.size, read_cmd.va,
    - read_cmd.dma);
    + dma_free_coherent(&adapter->pdev->dev, read_cmd.size, read_cmd.va,
    + read_cmd.dma);

    return status;
    }
    @@ -818,8 +818,9 @@ static int be_test_ddr_dma(struct be_adapter *adapter)
    };

    ddrdma_cmd.size = sizeof(struct be_cmd_req_ddrdma_test);
    - ddrdma_cmd.va = dma_alloc_coherent(&adapter->pdev->dev, ddrdma_cmd.size,
    - &ddrdma_cmd.dma, GFP_KERNEL);
    + ddrdma_cmd.va = dma_zalloc_coherent(&adapter->pdev->dev,
    + ddrdma_cmd.size, &ddrdma_cmd.dma,
    + GFP_KERNEL);
    if (!ddrdma_cmd.va)
    return -ENOMEM;

    @@ -941,8 +942,9 @@ static int be_read_eeprom(struct net_device *netdev,

    memset(&eeprom_cmd, 0, sizeof(struct be_dma_mem));
    eeprom_cmd.size = sizeof(struct be_cmd_req_seeprom_read);
    - eeprom_cmd.va = dma_alloc_coherent(&adapter->pdev->dev, eeprom_cmd.size,
    - &eeprom_cmd.dma, GFP_KERNEL);
    + eeprom_cmd.va = dma_zalloc_coherent(&adapter->pdev->dev,
    + eeprom_cmd.size, &eeprom_cmd.dma,
    + GFP_KERNEL);

    if (!eeprom_cmd.va)
    return -ENOMEM;
    diff --git a/drivers/net/ethernet/emulex/benet/be_main.c b/drivers/net/ethernet/emulex/benet/be_main.c
    index d48806b..8948048 100644
    --- a/drivers/net/ethernet/emulex/benet/be_main.c
    +++ b/drivers/net/ethernet/emulex/benet/be_main.c
    @@ -4118,8 +4118,8 @@ static int lancer_fw_download(struct be_adapter *adapter,

    flash_cmd.size = sizeof(struct lancer_cmd_req_write_object)
    + LANCER_FW_DOWNLOAD_CHUNK;
    - flash_cmd.va = dma_alloc_coherent(dev, flash_cmd.size,
    - &flash_cmd.dma, GFP_KERNEL);
    + flash_cmd.va = dma_zalloc_coherent(dev, flash_cmd.size,
    + &flash_cmd.dma, GFP_KERNEL);
    if (!flash_cmd.va)
    return -ENOMEM;

    @@ -4214,8 +4214,8 @@ static int be_fw_download(struct be_adapter *adapter, const struct firmware* fw)
    int status = 0, i = 0, num_imgs = 0, ufi_type = 0;

    flash_cmd.size = sizeof(struct be_cmd_write_flashrom);
    - flash_cmd.va = dma_alloc_coherent(&adapter->pdev->dev, flash_cmd.size,
    - &flash_cmd.dma, GFP_KERNEL);
    + flash_cmd.va = dma_zalloc_coherent(&adapter->pdev->dev, flash_cmd.size,
    + &flash_cmd.dma, GFP_KERNEL);
    if (!flash_cmd.va) {
    status = -ENOMEM;
    goto be_fw_exit;
    @@ -4646,10 +4646,10 @@ static int be_ctrl_init(struct be_adapter *adapter)
    goto done;

    mbox_mem_alloc->size = sizeof(struct be_mcc_mailbox) + 16;
    - mbox_mem_alloc->va = dma_alloc_coherent(&adapter->pdev->dev,
    - mbox_mem_alloc->size,
    - &mbox_mem_alloc->dma,
    - GFP_KERNEL);
    + mbox_mem_alloc->va = dma_zalloc_coherent(&adapter->pdev->dev,
    + mbox_mem_alloc->size,
    + &mbox_mem_alloc->dma,
    + GFP_KERNEL);
    if (!mbox_mem_alloc->va) {
    status = -ENOMEM;
    goto unmap_pci_bars;
    --
    1.9.1


    \
     
     \ /
      Last update: 2015-06-18 00:41    [W:4.153 / U:0.296 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site