d/freebsd-nq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

dev: make some use of mallocarray(9).

Browse Source 
Focus on code where we are doing multiplications within malloc(9). None of
these is likely to overflow, however the change is still useful as some
static checkers can benefit from the allocation attributes we use for
mallocarray.

This initial sweep only covers malloc(9) calls with M_NOWAIT. No good
reason but I started doing the changes before r327796 and at that time it
was convenient to make sure the sorrounding code could handle NULL values.
This commit is contained in:
Pedro F. Giffuni 2018-01-13 22:30:30 +00:00
parent a019e26c0f
commit 26c1d774b5
43 changed files with 139 additions and 128 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
sys/dev/aacraid/aacraid.c
View File

@ -1458,7 +1458,7 @@ aac_convert_sgraw2(struct aac_softc *sc, struct aac_raw_io2 *raw,
int i, j, pos;
u_int32_t addr_low;
sge = malloc(nseg_new * sizeof(struct aac_sge_ieee1212),
sge = mallocarray(nseg_new, sizeof(struct aac_sge_ieee1212),
M_AACRAIDBUF, M_NOWAIT|M_ZERO);
if (sge == NULL)
return nseg;

2
sys/dev/advansys/advansys.c
View File

@ -1255,7 +1255,7 @@ adv_attach(adv)
* a transaction and use it for mapping the queue to the
* upper level SCSI transaction it represents.
*/
adv->ccb_infos = malloc(sizeof(*adv->ccb_infos) * adv->max_openings,
adv->ccb_infos = mallocarray(adv->max_openings, sizeof(*adv->ccb_infos),
M_DEVBUF, M_NOWAIT);
if (adv->ccb_infos == NULL)

5
sys/dev/ath/if_ath_rx_edma.c
View File

@ -901,9 +901,8 @@ ath_edma_setup_rxfifo(struct ath_softc *sc, HAL_RX_QUEUE qtype)
re->m_fifolen);
/* Allocate ath_buf FIFO array, pre-zero'ed */
re->m_fifo = malloc(sizeof(struct ath_buf *) * re->m_fifolen,
M_ATHDEV,
M_NOWAIT | M_ZERO);
re->m_fifo = mallocarray(re->m_fifolen, sizeof(struct ath_buf *),
M_ATHDEV, M_NOWAIT | M_ZERO);
if (re->m_fifo == NULL) {
device_printf(sc->sc_dev, "%s: malloc failed\n",
__func__);

2
sys/dev/beri/virtio/virtio.c
View File

@ -250,7 +250,7 @@ getcopy(struct iovec *iov, int n)
struct iovec *tiov;
int i;
tiov = malloc(n * sizeof(struct iovec), M_DEVBUF, M_NOWAIT);
tiov = mallocarray(n, sizeof(struct iovec), M_DEVBUF, M_NOWAIT);
for (i = 0; i < n; i++) {
tiov[i].iov_base = iov[i].iov_base;
tiov[i].iov_len = iov[i].iov_len;

19
sys/dev/bnxt/if_bnxt.c
View File

@ -351,7 +351,7 @@ bnxt_tx_queues_alloc(if_ctx_t ctx, caddr_t *vaddrs,
softc = iflib_get_softc(ctx);
softc->tx_cp_rings = malloc(sizeof(struct bnxt_cp_ring) * ntxqsets,
softc->tx_cp_rings = mallocarray(ntxqsets, sizeof(struct bnxt_cp_ring),
M_DEVBUF, M_NOWAIT | M_ZERO);
if (!softc->tx_cp_rings) {
device_printf(iflib_get_dev(ctx),
@ -359,7 +359,7 @@ bnxt_tx_queues_alloc(if_ctx_t ctx, caddr_t *vaddrs,
rc = ENOMEM;
goto cp_alloc_fail;
}
softc->tx_rings = malloc(sizeof(struct bnxt_ring) * ntxqsets,
softc->tx_rings = mallocarray(ntxqsets, sizeof(struct bnxt_ring),
M_DEVBUF, M_NOWAIT | M_ZERO);
if (!softc->tx_rings) {
device_printf(iflib_get_dev(ctx),
@ -446,7 +446,7 @@ bnxt_rx_queues_alloc(if_ctx_t ctx, caddr_t *vaddrs,
softc = iflib_get_softc(ctx);
softc->rx_cp_rings = malloc(sizeof(struct bnxt_cp_ring) * nrxqsets,
softc->rx_cp_rings = mallocarray(nrxqsets, sizeof(struct bnxt_cp_ring),
M_DEVBUF, M_NOWAIT | M_ZERO);
if (!softc->rx_cp_rings) {
device_printf(iflib_get_dev(ctx),
@ -454,7 +454,7 @@ bnxt_rx_queues_alloc(if_ctx_t ctx, caddr_t *vaddrs,
rc = ENOMEM;
goto cp_alloc_fail;
}
softc->rx_rings = malloc(sizeof(struct bnxt_ring) * nrxqsets,
softc->rx_rings = mallocarray(nrxqsets, sizeof(struct bnxt_ring),
M_DEVBUF, M_NOWAIT | M_ZERO);
if (!softc->rx_rings) {
device_printf(iflib_get_dev(ctx),
@ -462,7 +462,7 @@ bnxt_rx_queues_alloc(if_ctx_t ctx, caddr_t *vaddrs,
rc = ENOMEM;
goto ring_alloc_fail;
}
softc->ag_rings = malloc(sizeof(struct bnxt_ring) * nrxqsets,
softc->ag_rings = mallocarray(nrxqsets, sizeof(struct bnxt_ring),
M_DEVBUF, M_NOWAIT | M_ZERO);
if (!softc->ag_rings) {
device_printf(iflib_get_dev(ctx),
@ -470,7 +470,7 @@ bnxt_rx_queues_alloc(if_ctx_t ctx, caddr_t *vaddrs,
rc = ENOMEM;
goto ag_alloc_fail;
}
softc->grp_info = malloc(sizeof(struct bnxt_grp_info) * nrxqsets,
softc->grp_info = mallocarray(nrxqsets, sizeof(struct bnxt_grp_info),
M_DEVBUF, M_NOWAIT | M_ZERO);
if (!softc->grp_info) {
device_printf(iflib_get_dev(ctx),
@ -540,9 +540,10 @@ bnxt_rx_queues_alloc(if_ctx_t ctx, caddr_t *vaddrs,
softc->rx_rings[i].paddr = paddrs[i * nrxqs + 1];
/* Allocate the TPA start buffer */
softc->rx_rings[i].tpa_start = malloc(sizeof(struct bnxt_full_tpa_start) *
(RX_TPA_START_CMPL_AGG_ID_MASK >> RX_TPA_START_CMPL_AGG_ID_SFT),
M_DEVBUF, M_NOWAIT | M_ZERO);
softc->rx_rings[i].tpa_start = mallocarray(
RX_TPA_START_CMPL_AGG_ID_MASK >> RX_TPA_START_CMPL_AGG_ID_SFT,
sizeof(struct bnxt_full_tpa_start), M_DEVBUF,
M_NOWAIT | M_ZERO);
if (softc->rx_rings[i].tpa_start == NULL) {
rc = -ENOMEM;
device_printf(softc->dev,

4
sys/dev/bwn/if_bwn.c
View File

@ -2677,8 +2677,8 @@ bwn_dma_ringsetup(struct bwn_mac *mac, int controller_index,
if (for_tx)
dr->dr_numslots = BWN_TXRING_SLOTS;
dr->dr_meta = malloc(dr->dr_numslots * sizeof(struct bwn_dmadesc_meta),
M_DEVBUF, M_NOWAIT | M_ZERO);
dr->dr_meta = mallocarray(dr->dr_numslots,
sizeof(struct bwn_dmadesc_meta), M_DEVBUF, M_NOWAIT | M_ZERO);
if (dr->dr_meta == NULL)
goto fail0;

2
sys/dev/bwn/if_bwn_phy_lp.c
View File

@ -1127,7 +1127,7 @@ bwn_phy_lp_bugfix(struct bwn_mac *mac)
uint8_t mode;
int8_t txpwridx;
tabs = (uint32_t *)malloc(sizeof(uint32_t) * size, M_DEVBUF,
tabs = (uint32_t *)mallocarray(size, sizeof(uint32_t), M_DEVBUF,
M_NOWAIT | M_ZERO);
if (tabs == NULL) {
device_printf(sc->sc_dev, "failed to allocate buffer.\n");

10
sys/dev/ciss/ciss.c
View File

@ -1427,7 +1427,7 @@ ciss_init_logical(struct ciss_softc *sc)
}
sc->ciss_logical =
malloc(sc->ciss_max_logical_bus * sizeof(struct ciss_ldrive *),
mallocarray(sc->ciss_max_logical_bus, sizeof(struct ciss_ldrive *),
CISS_MALLOC_CLASS, M_NOWAIT | M_ZERO);
if (sc->ciss_logical == NULL) {
error = ENXIO;
@ -1436,7 +1436,7 @@ ciss_init_logical(struct ciss_softc *sc)
for (i = 0; i < sc->ciss_max_logical_bus; i++) {
sc->ciss_logical[i] =
malloc(sc->ciss_cfg->max_logical_supported *
mallocarray(sc->ciss_cfg->max_logical_supported,
sizeof(struct ciss_ldrive),
CISS_MALLOC_CLASS, M_NOWAIT | M_ZERO);
if (sc->ciss_logical[i] == NULL) {
@ -1549,7 +1549,7 @@ ciss_init_physical(struct ciss_softc *sc)
}
sc->ciss_controllers =
malloc(sc->ciss_max_logical_bus * sizeof (union ciss_device_address),
mallocarray(sc->ciss_max_logical_bus, sizeof(union ciss_device_address),
CISS_MALLOC_CLASS, M_NOWAIT | M_ZERO);
if (sc->ciss_controllers == NULL) {
@ -1566,7 +1566,7 @@ ciss_init_physical(struct ciss_softc *sc)
}
sc->ciss_physical =
malloc(sc->ciss_max_physical_bus * sizeof(struct ciss_pdrive *),
mallocarray(sc->ciss_max_physical_bus, sizeof(struct ciss_pdrive *),
CISS_MALLOC_CLASS, M_NOWAIT | M_ZERO);
if (sc->ciss_physical == NULL) {
ciss_printf(sc, "Could not allocate memory for physical device map\n");
@ -2873,7 +2873,7 @@ ciss_cam_init(struct ciss_softc *sc)
*/
maxbus = max(sc->ciss_max_logical_bus, sc->ciss_max_physical_bus +
CISS_PHYSICAL_BASE);
sc->ciss_cam_sim = malloc(maxbus * sizeof(struct cam_sim*),
sc->ciss_cam_sim = mallocarray(maxbus, sizeof(struct cam_sim*),
CISS_MALLOC_CLASS, M_NOWAIT | M_ZERO);
if (sc->ciss_cam_sim == NULL) {
ciss_printf(sc, "can't allocate memory for controller SIM\n");

2
sys/dev/cxgbe/crypto/t4_crypto.c
View File

@ -1900,7 +1900,7 @@ ccr_newsession(device_t dev, uint32_t *sidp, struct cryptoini *cri)
}
}
if (sess == -1) {
s = malloc(sizeof(*s) * (sc->nsessions + 1), M_CCR,
s = mallocarray(sc->nsessions + 1, sizeof(*s), M_CCR,
M_NOWAIT | M_ZERO);
if (s == NULL) {
mtx_unlock(&sc->lock);

2
sys/dev/esp/ncr53c9x.c
View File

@ -292,7 +292,7 @@ ncr53c9x_attach(struct ncr53c9x_softc *sc)
} else
sc->sc_imess_self = 0;
sc->sc_tinfo = malloc(sc->sc_ntarg * sizeof(sc->sc_tinfo[0]),
sc->sc_tinfo = mallocarray(sc->sc_ntarg, sizeof(sc->sc_tinfo[0]),
M_DEVBUF, M_NOWAIT | M_ZERO);
if (sc->sc_tinfo == NULL) {
device_printf(sc->sc_dev,

4
sys/dev/fb/splash.c
View File

@ -136,8 +136,8 @@ splash_register(splash_decoder_t *decoder)
break;
}
if ((i >= decoders) && (decoders % DECODER_ARRAY_DELTA) == 0) {
p = malloc(sizeof(*p)*(decoders + DECODER_ARRAY_DELTA),
M_DEVBUF, M_NOWAIT);
p = mallocarray(decoders + DECODER_ARRAY_DELTA,
sizeof(*p), M_DEVBUF, M_NOWAIT);
if (p == NULL)
return ENOMEM;
if (decoder_set != NULL) {

6
sys/dev/gpio/gpiobus.c
View File

@ -235,7 +235,7 @@ gpiobus_init_softc(device_t dev)
/* Pins = GPIO_PIN_MAX() + 1 */
sc->sc_npins++;
sc->sc_pins = malloc(sizeof(*sc->sc_pins) * sc->sc_npins, M_DEVBUF,
sc->sc_pins = mallocarray(sc->sc_npins, sizeof(*sc->sc_pins), M_DEVBUF,
M_NOWAIT | M_ZERO);
if (sc->sc_pins == NULL)
return (ENOMEM);
@ -251,11 +251,11 @@ gpiobus_alloc_ivars(struct gpiobus_ivar *devi)
{
/* Allocate pins and flags memory. */
devi->pins = malloc(sizeof(uint32_t) * devi->npins, M_DEVBUF,
devi->pins = mallocarray(devi->npins, sizeof(uint32_t), M_DEVBUF,
M_NOWAIT | M_ZERO);
if (devi->pins == NULL)
return (ENOMEM);
devi->flags = malloc(sizeof(uint32_t) * devi->npins, M_DEVBUF,
devi->flags = mallocarray(devi->npins, sizeof(uint32_t), M_DEVBUF,
M_NOWAIT | M_ZERO);
if (devi->flags == NULL) {
free(devi->pins, M_DEVBUF);

4
sys/dev/if_ndis/if_ndis.c
View File

@ -665,8 +665,8 @@ ndis_attach(device_t dev)
if (sc->ndis_maxpkts == 0)
sc->ndis_maxpkts = 10;
sc->ndis_txarray = malloc(sizeof(ndis_packet *) *
sc->ndis_maxpkts, M_DEVBUF, M_NOWAIT|M_ZERO);
sc->ndis_txarray = mallocarray(sc->ndis_maxpkts,
sizeof(ndis_packet *), M_DEVBUF, M_NOWAIT|M_ZERO);
/* Allocate a pool of ndis_packets for TX encapsulation. */

4
sys/dev/iwi/if_iwi.c
View File

@ -640,7 +640,7 @@ iwi_alloc_tx_ring(struct iwi_softc *sc, struct iwi_tx_ring *ring, int count,
goto fail;
}
ring->data = malloc(count * sizeof (struct iwi_tx_data), M_DEVBUF,
ring->data = mallocarray(count, sizeof(struct iwi_tx_data), M_DEVBUF,
M_NOWAIT | M_ZERO);
if (ring->data == NULL) {
device_printf(sc->sc_dev, "could not allocate soft data\n");
@ -748,7 +748,7 @@ iwi_alloc_rx_ring(struct iwi_softc *sc, struct iwi_rx_ring *ring, int count)
ring->count = count;
ring->cur = 0;
ring->data = malloc(count * sizeof (struct iwi_rx_data), M_DEVBUF,
ring->data = mallocarray(count, sizeof(struct iwi_rx_data), M_DEVBUF,
M_NOWAIT | M_ZERO);
if (ring->data == NULL) {
device_printf(sc->sc_dev, "could not allocate soft data\n");

7
sys/dev/kbd/kbd.c
View File

@ -94,17 +94,18 @@ kbd_realloc_array(void)
{
keyboard_t **new_kbd;
keyboard_switch_t **new_kbdsw;
int newsize;
u_int newsize;
int s;
s = spltty();
newsize = rounddown(keyboards + ARRAY_DELTA, ARRAY_DELTA);
new_kbd = malloc(sizeof(*new_kbd)*newsize, M_DEVBUF, M_NOWAIT|M_ZERO);
new_kbd = mallocarray(newsize, sizeof(*new_kbd), M_DEVBUF,
M_NOWAIT|M_ZERO);
if (new_kbd == NULL) {
splx(s);
return (ENOMEM);
}
new_kbdsw = malloc(sizeof(*new_kbdsw)*newsize, M_DEVBUF,
new_kbdsw = mallocarray(newsize, sizeof(*new_kbdsw), M_DEVBUF,
M_NOWAIT|M_ZERO);
if (new_kbdsw == NULL) {
free(new_kbd, M_DEVBUF);

2
sys/dev/liquidio/base/lio_request_manager.c
View File

@ -110,7 +110,7 @@ lio_init_instr_queue(struct octeon_device *oct, union octeon_txpciq txpciq,
* Initialize a list to holds requests that have been posted to
* Octeon but has yet to be fetched by octeon
*/
iq->request_list = malloc(sizeof(*iq->request_list) * num_descs,
iq->request_list = mallocarray(num_descs, sizeof(*iq->request_list),
M_DEVBUF, M_NOWAIT | M_ZERO);
if (iq->request_list == NULL) {
lio_dev_err(oct, "Alloc failed for IQ[%d] nr free list\n",

12
sys/dev/liquidio/lio_main.c
View File

@ -1724,12 +1724,12 @@ lio_setup_glists(struct octeon_device *oct, struct lio *lio, int num_iqs)
struct lio_gather *g;
int i, j;
lio->glist_lock = malloc(num_iqs * sizeof(*lio->glist_lock), M_DEVBUF,
M_NOWAIT | M_ZERO);
lio->glist_lock = mallocarray(num_iqs, sizeof(*lio->glist_lock),
M_DEVBUF, M_NOWAIT | M_ZERO);
if (lio->glist_lock == NULL)
return (1);
lio->ghead = malloc(num_iqs * sizeof(*lio->ghead), M_DEVBUF,
lio->ghead = mallocarray(num_iqs, sizeof(*lio->ghead), M_DEVBUF,
M_NOWAIT | M_ZERO);
if (lio->ghead == NULL) {
free((void *)lio->glist_lock, M_DEVBUF);
@ -1743,10 +1743,10 @@ lio_setup_glists(struct octeon_device *oct, struct lio *lio, int num_iqs)
* allocate memory to store virtual and dma base address of
* per glist consistent memory
*/
lio->glists_virt_base = malloc(num_iqs * sizeof(void *), M_DEVBUF,
lio->glists_virt_base = mallocarray(num_iqs, sizeof(void *), M_DEVBUF,
M_NOWAIT | M_ZERO);
lio->glists_dma_base = malloc(num_iqs * sizeof(vm_paddr_t), M_DEVBUF,
M_NOWAIT | M_ZERO);
lio->glists_dma_base = mallocarray(num_iqs, sizeof(vm_paddr_t),
M_DEVBUF, M_NOWAIT | M_ZERO);
if ((lio->glists_virt_base == NULL) || (lio->glists_dma_base == NULL)) {
lio_delete_glists(oct, lio);
return (1);

2
sys/dev/mpr/mpr.c
View File

@ -1192,7 +1192,7 @@ mpr_alloc_queues(struct mpr_softc *sc)
nq = sc->msi_msgs;
mpr_dprint(sc, MPR_INIT|MPR_XINFO, "Allocating %d I/O queues\n", nq);
sc->queues = malloc(sizeof(struct mpr_queue) * nq, M_MPR,
sc->queues = mallocarray(nq, sizeof(struct mpr_queue), M_MPR,
M_NOWAIT|M_ZERO);
if (sc->queues == NULL)
return (ENOMEM);

22
sys/dev/mpr/mpr_mapping.c
View File

@ -2141,27 +2141,27 @@ mpr_mapping_allocate_memory(struct mpr_softc *sc)
{
uint32_t dpm_pg0_sz;
sc->mapping_table = malloc((sizeof(struct dev_mapping_table) *
sc->max_devices), M_MPR, M_ZERO|M_NOWAIT);
sc->mapping_table = mallocarray(sc->max_devices,
sizeof(struct dev_mapping_table), M_MPR, M_ZERO|M_NOWAIT);
if (!sc->mapping_table)
goto free_resources;
sc->removal_table = malloc((sizeof(struct map_removal_table) *
sc->max_devices), M_MPR, M_ZERO|M_NOWAIT);
sc->removal_table = mallocarray(sc->max_devices,
sizeof(struct map_removal_table), M_MPR, M_ZERO|M_NOWAIT);
if (!sc->removal_table)
goto free_resources;
sc->enclosure_table = malloc((sizeof(struct enc_mapping_table) *
sc->max_enclosures), M_MPR, M_ZERO|M_NOWAIT);
sc->enclosure_table = mallocarray(sc->max_enclosures,
sizeof(struct enc_mapping_table), M_MPR, M_ZERO|M_NOWAIT);
if (!sc->enclosure_table)
goto free_resources;
sc->dpm_entry_used = malloc((sizeof(u8) * sc->max_dpm_entries),
sc->dpm_entry_used = mallocarray(sc->max_dpm_entries, sizeof(u8),
M_MPR, M_ZERO|M_NOWAIT);
if (!sc->dpm_entry_used)
goto free_resources;
sc->dpm_flush_entry = malloc((sizeof(u8) * sc->max_dpm_entries),
sc->dpm_flush_entry = mallocarray(sc->max_dpm_entries, sizeof(u8),
M_MPR, M_ZERO|M_NOWAIT);
if (!sc->dpm_flush_entry)
goto free_resources;
@ -2912,7 +2912,7 @@ mpr_mapping_topology_change_event(struct mpr_softc *sc,
if (!num_entries)
goto out;
phy_change = malloc(sizeof(struct _map_phy_change) * num_entries,
phy_change = mallocarray(num_entries, sizeof(struct _map_phy_change),
M_MPR, M_NOWAIT|M_ZERO);
topo_change.phy_details = phy_change;
if (!phy_change)
@ -2963,7 +2963,7 @@ mpr_mapping_pcie_topology_change_event(struct mpr_softc *sc,
if (!num_entries)
goto out;
port_change = malloc(sizeof(struct _map_port_change) * num_entries,
port_change = mallocarray(num_entries, sizeof(struct _map_port_change),
M_MPR, M_NOWAIT|M_ZERO);
topo_change.port_details = port_change;
if (!port_change)
@ -3003,7 +3003,7 @@ mpr_mapping_ir_config_change_event(struct mpr_softc *sc,
struct dev_mapping_table *mt_entry;
u16 element_flags;
wwid_table = malloc(sizeof(u64) * event_data->NumElements, M_MPR,
wwid_table = mallocarray(event_data->NumElements, sizeof(u64), M_MPR,
M_NOWAIT | M_ZERO);
if (!wwid_table)
goto out;

4
sys/dev/mps/mps.c
View File

@ -1164,12 +1164,12 @@ static int
mps_alloc_queues(struct mps_softc *sc)
{
struct mps_queue *q;
int nq, i;
u_int nq, i;
nq = sc->msi_msgs;
mps_dprint(sc, MPS_INIT|MPS_XINFO, "Allocating %d I/O queues\n", nq);
sc->queues = malloc(sizeof(struct mps_queue) * nq, M_MPT2,
sc->queues = mallocarray(nq, sizeof(struct mps_queue), M_MPT2,
M_NOWAIT|M_ZERO);
if (sc->queues == NULL)
return (ENOMEM);

20
sys/dev/mps/mps_mapping.c
View File

@ -1694,27 +1694,27 @@ mps_mapping_allocate_memory(struct mps_softc *sc)
{
uint32_t dpm_pg0_sz;
sc->mapping_table = malloc((sizeof(struct dev_mapping_table) *
sc->max_devices), M_MPT2, M_ZERO|M_NOWAIT);
sc->mapping_table = mallocarray(sc->max_devices,
sizeof(struct dev_mapping_table), M_MPT2, M_ZERO|M_NOWAIT);
if (!sc->mapping_table)
goto free_resources;
sc->removal_table = malloc((sizeof(struct map_removal_table) *
sc->max_devices), M_MPT2, M_ZERO|M_NOWAIT);
sc->removal_table = mallocarray(sc->max_devices,
sizeof(struct map_removal_table), M_MPT2, M_ZERO|M_NOWAIT);
if (!sc->removal_table)
goto free_resources;
sc->enclosure_table = malloc((sizeof(struct enc_mapping_table) *
sc->max_enclosures), M_MPT2, M_ZERO|M_NOWAIT);
sc->enclosure_table = mallocarray(sc->max_enclosures,
sizeof(struct enc_mapping_table), M_MPT2, M_ZERO|M_NOWAIT);
if (!sc->enclosure_table)
goto free_resources;
sc->dpm_entry_used = malloc((sizeof(u8) * sc->max_dpm_entries),
sc->dpm_entry_used = mallocarray(sc->max_dpm_entries, sizeof(u8),
M_MPT2, M_ZERO|M_NOWAIT);
if (!sc->dpm_entry_used)
goto free_resources;
sc->dpm_flush_entry = malloc((sizeof(u8) * sc->max_dpm_entries),
sc->dpm_flush_entry = mallocarray(sc->max_dpm_entries, sizeof(u8),
M_MPT2, M_ZERO|M_NOWAIT);
if (!sc->dpm_flush_entry)
goto free_resources;
@ -2451,7 +2451,7 @@ mps_mapping_topology_change_event(struct mps_softc *sc,
if (!num_entries)
goto out;
phy_change = malloc(sizeof(struct _map_phy_change) * num_entries,
phy_change = mallocarray(num_entries, sizeof(struct _map_phy_change),
M_MPT2, M_NOWAIT|M_ZERO);
topo_change.phy_details = phy_change;
if (!phy_change)
@ -2492,7 +2492,7 @@ mps_mapping_ir_config_change_event(struct mps_softc *sc,
struct dev_mapping_table *mt_entry;
u16 element_flags;
wwid_table = malloc(sizeof(u64) * event_data->NumElements, M_MPT2,
wwid_table = mallocarray(event_data->NumElements, sizeof(u64), M_MPT2,
M_NOWAIT | M_ZERO);
if (!wwid_table)
goto out;

6
sys/dev/mpt/mpt_cam.c
View File

@ -637,8 +637,8 @@ mptsas_sas_io_unit_pg0(struct mpt_softc *mpt, struct mptsas_portinfo *portinfo)
}
portinfo->num_phys = buffer->NumPhys;
portinfo->phy_info = malloc(sizeof(*portinfo->phy_info) *
portinfo->num_phys, M_DEVBUF, M_NOWAIT|M_ZERO);
portinfo->phy_info = mallocarray(portinfo->num_phys,
sizeof(*portinfo->phy_info), M_DEVBUF, M_NOWAIT|M_ZERO);
if (portinfo->phy_info == NULL) {
free(buffer, M_DEVBUF);
error = ENOMEM;
@ -4234,7 +4234,7 @@ mpt_add_target_commands(struct mpt_softc *mpt)
max = mpt->mpt_max_tgtcmds;
}
mpt->tgt_cmd_ptrs =
malloc(max * sizeof (request_t *), M_DEVBUF, M_NOWAIT | M_ZERO);
mallocarray(max, sizeof(request_t *), M_DEVBUF, M_NOWAIT | M_ZERO);
if (mpt->tgt_cmd_ptrs == NULL) {
mpt_prt(mpt,
"mpt_add_target_commands: could not allocate cmd ptrs\n");

3
sys/dev/mrsas/mrsas.c
View File

@ -2566,7 +2566,8 @@ mrsas_alloc_mpt_cmds(struct mrsas_softc *sc)
* Allocate the dynamic array first and then allocate individual
* commands.
*/
sc->mpt_cmd_list = malloc(sizeof(struct mrsas_mpt_cmd *) * max_cmd, M_MRSAS, M_NOWAIT);
sc->mpt_cmd_list = mallocarray(max_cmd, sizeof(struct mrsas_mpt_cmd *),
M_MRSAS, M_NOWAIT);
if (!sc->mpt_cmd_list) {
device_printf(sc->mrsas_dev, "Cannot alloc memory for mpt_cmd_list.\n");
return (ENOMEM);

14
sys/dev/mxge/if_mxge.c
View File

@ -688,7 +688,7 @@ z_alloc(void *nil, u_int items, u_int size)
{
void *ptr;
ptr = malloc(items * size, M_TEMP, M_NOWAIT);
ptr = mallocarray(items, size, M_TEMP, M_NOWAIT);
return ptr;
}
@ -4390,8 +4390,8 @@ mxge_alloc_slices(mxge_softc_t *sc)
sc->rx_ring_size = cmd.data0;
max_intr_slots = 2 * (sc->rx_ring_size / sizeof (mcp_dma_addr_t));
bytes = sizeof (*sc->ss) * sc->num_slices;
sc->ss = malloc(bytes, M_DEVBUF, M_NOWAIT | M_ZERO);
sc->ss = mallocarray(sc->num_slices, sizeof(*sc->ss), M_DEVBUF,
M_NOWAIT | M_ZERO);
if (sc->ss == NULL)
return (ENOMEM);
for (i = 0; i < sc->num_slices; i++) {
@ -4563,8 +4563,8 @@ mxge_add_msix_irqs(mxge_softc_t *sc)
err = ENOSPC;
goto abort_with_msix;
}
bytes = sizeof (*sc->msix_irq_res) * sc->num_slices;
sc->msix_irq_res = malloc(bytes, M_DEVBUF, M_NOWAIT|M_ZERO);
sc->msix_irq_res = mallocarray(sc->num_slices,
sizeof(*sc->msix_irq_res), M_DEVBUF, M_NOWAIT|M_ZERO);
if (sc->msix_irq_res == NULL) {
err = ENOMEM;
goto abort_with_msix;
@ -4583,8 +4583,8 @@ mxge_add_msix_irqs(mxge_softc_t *sc)
}
}
bytes = sizeof (*sc->msix_ih) * sc->num_slices;
sc->msix_ih = malloc(bytes, M_DEVBUF, M_NOWAIT|M_ZERO);
sc->msix_ih = mallocarray(sc->num_slices, sizeof(*sc->msix_ih),
M_DEVBUF, M_NOWAIT|M_ZERO);
for (i = 0; i < sc->num_slices; i++) {
err = bus_setup_intr(sc->dev, sc->msix_irq_res[i],

2
sys/dev/netmap/if_ptnet.c
View File

@ -351,7 +351,7 @@ ptnet_attach(device_t dev)
sc->num_tx_rings = num_tx_rings;
/* Allocate and initialize per-queue data structures. */
sc->queues = malloc(sizeof(struct ptnet_queue) * sc->num_rings,
sc->queues = mallocarray(sc->num_rings, sizeof(struct ptnet_queue),
M_DEVBUF, M_NOWAIT | M_ZERO);
if (sc->queues == NULL) {
err = ENOMEM;

3
sys/dev/nvme/nvme_ns.c
View File

@ -321,7 +321,8 @@ nvme_allocate_child_bios(int num_bios)
struct bio **child_bios;
int err = 0, i;
child_bios = malloc(num_bios * sizeof(struct bio *), M_NVME, M_NOWAIT);
child_bios = mallocarray(num_bios, sizeof(struct bio *), M_NVME,
M_NOWAIT);
if (child_bios == NULL)
return (NULL);

2
sys/dev/pst/pst-iop.c
View File

@ -323,7 +323,7 @@ iop_get_lct(struct iop_softc *sc)
contigfree(reply, ALLOCSIZE, M_PSTIOP);
return 0;
}
if (!(sc->lct = malloc(reply->table_size * sizeof(struct i2o_lct_entry),
if (!(sc->lct = mallocarray(reply->table_size, sizeof(struct i2o_lct_entry),
M_PSTIOP, M_NOWAIT | M_ZERO))) {
contigfree(reply, ALLOCSIZE, M_PSTIOP);
return 0;

6
sys/dev/ral/rt2560.c
View File

@ -488,7 +488,7 @@ rt2560_alloc_tx_ring(struct rt2560_softc *sc, struct rt2560_tx_ring *ring,
goto fail;
}
ring->data = malloc(count * sizeof (struct rt2560_tx_data), M_DEVBUF,
ring->data = mallocarray(count, sizeof(struct rt2560_tx_data), M_DEVBUF,
M_NOWAIT | M_ZERO);
if (ring->data == NULL) {
device_printf(sc->sc_dev, "could not allocate soft data\n");
@ -632,8 +632,8 @@ rt2560_alloc_rx_ring(struct rt2560_softc *sc, struct rt2560_rx_ring *ring,
goto fail;
}
ring->data = malloc(count * sizeof (struct rt2560_rx_data), M_DEVBUF,
M_NOWAIT | M_ZERO);
ring->data = mallocarray(count, sizeof (struct rt2560_rx_data),
M_DEVBUF, M_NOWAIT | M_ZERO);
if (ring->data == NULL) {
device_printf(sc->sc_dev, "could not allocate soft data\n");
error = ENOMEM;

4
sys/dev/ral/rt2661.c
View File

@ -497,7 +497,7 @@ rt2661_alloc_tx_ring(struct rt2661_softc *sc, struct rt2661_tx_ring *ring,
goto fail;
}
ring->data = malloc(count * sizeof (struct rt2661_tx_data), M_DEVBUF,
ring->data = mallocarray(count, sizeof(struct rt2661_tx_data), M_DEVBUF,
M_NOWAIT | M_ZERO);
if (ring->data == NULL) {
device_printf(sc->sc_dev, "could not allocate soft data\n");
@ -638,7 +638,7 @@ rt2661_alloc_rx_ring(struct rt2661_softc *sc, struct rt2661_rx_ring *ring,
goto fail;
}
ring->data = malloc(count * sizeof (struct rt2661_rx_data), M_DEVBUF,
ring->data = mallocarray(count, sizeof(struct rt2661_rx_data), M_DEVBUF,
M_NOWAIT | M_ZERO);
if (ring->data == NULL) {
device_printf(sc->sc_dev, "could not allocate soft data\n");

3
sys/dev/rp/rp.c
View File

@ -732,7 +732,8 @@ rp_attachcommon(CONTROLLER_T *ctlp, int num_aiops, int num_ports)
ctlp->num_ports = num_ports;
ctlp->rp = rp = (struct rp_port *)
malloc(sizeof(struct rp_port) * num_ports, M_DEVBUF, M_NOWAIT | M_ZERO);
mallocarray(num_ports, sizeof(struct rp_port), M_DEVBUF,
M_NOWAIT | M_ZERO);
if (rp == NULL) {
device_printf(ctlp->dev, "rp_attachcommon: Could not malloc rp_ports structures.\n");
retval = ENOMEM;

6
sys/dev/rp/rp_isa.c
View File

@ -178,8 +178,10 @@ rp_probe(device_t dev)
/* The IO ports of AIOPs for an ISA controller are discrete. */
ctlp->io_num = 1;
ctlp->io_rid = malloc(sizeof(*(ctlp->io_rid)) * MAX_AIOPS_PER_BOARD, M_DEVBUF, M_NOWAIT | M_ZERO);
ctlp->io = malloc(sizeof(*(ctlp->io)) * MAX_AIOPS_PER_BOARD, M_DEVBUF, M_NOWAIT | M_ZERO);
ctlp->io_rid = mallocarray(MAX_AIOPS_PER_BOARD, sizeof(*(ctlp->io_rid)),
M_DEVBUF, M_NOWAIT | M_ZERO);
ctlp->io = mallocarray(MAX_AIOPS_PER_BOARD, sizeof(*(ctlp->io)),
M_DEVBUF, M_NOWAIT | M_ZERO);
if (ctlp->io_rid == NULL || ctlp->io == NULL) {
device_printf(dev, "rp_attach: Out of memory.\n");
retval = ENOMEM;

6
sys/dev/rp/rp_pci.c
View File

@ -164,8 +164,10 @@ rp_pciattach(device_t dev)
/* The IO ports of AIOPs for a PCI controller are continuous. */
ctlp->io_num = 1;
ctlp->io_rid = malloc(sizeof(*(ctlp->io_rid)) * ctlp->io_num, M_DEVBUF, M_NOWAIT | M_ZERO);
ctlp->io = malloc(sizeof(*(ctlp->io)) * ctlp->io_num, M_DEVBUF, M_NOWAIT | M_ZERO);
ctlp->io_rid = mallocarray(ctlp->io_num, sizeof(*(ctlp->io_rid)),
M_DEVBUF, M_NOWAIT | M_ZERO);
ctlp->io = mallocarray(ctlp->io_num, sizeof(*(ctlp->io)), M_DEVBUF,
M_NOWAIT | M_ZERO);
if (ctlp->io_rid == NULL || ctlp->io == NULL) {
device_printf(dev, "rp_pciattach: Out of memory.\n");
retval = ENOMEM;

5
sys/dev/sound/midi/midi.c
View File

@ -340,14 +340,15 @@ midi_init(kobj_class_t cls, int unit, int channel, void *cookie)
mtx_lock(&m->qlock);
if (inqsize)
buf = malloc(sizeof(MIDI_TYPE) * inqsize, M_MIDI, M_NOWAIT);
buf = mallocarray(inqsize, sizeof(MIDI_TYPE), M_MIDI, M_NOWAIT);
else
buf = NULL;
MIDIQ_INIT(m->inq, buf, inqsize);
if (outqsize)
buf = malloc(sizeof(MIDI_TYPE) * outqsize, M_MIDI, M_NOWAIT);
buf = mallocarray(outqsize, sizeof(MIDI_TYPE), M_MIDI,
M_NOWAIT);
else
buf = NULL;
m->hiwat = outqsize / 2;

16
sys/dev/sound/pci/hda/hdaa.c
View File

@ -3034,8 +3034,8 @@ hdaa_audio_ctl_parse(struct hdaa_devinfo *devinfo)
if (max < 1)
return;
ctls = (struct hdaa_audio_ctl *)malloc(
sizeof(*ctls) * max, M_HDAA, M_ZERO | M_NOWAIT);
ctls = (struct hdaa_audio_ctl *)mallocarray(max,
sizeof(*ctls), M_HDAA, M_ZERO | M_NOWAIT);
if (ctls == NULL) {
/* Blekh! */
@ -3187,8 +3187,8 @@ hdaa_audio_as_parse(struct hdaa_devinfo *devinfo)
if (max < 1)
return;
as = (struct hdaa_audio_as *)malloc(
sizeof(*as) * max, M_HDAA, M_ZERO | M_NOWAIT);
as = (struct hdaa_audio_as *)mallocarray(max,
sizeof(*as), M_HDAA, M_ZERO | M_NOWAIT);
if (as == NULL) {
/* Blekh! */
@ -4078,8 +4078,8 @@ hdaa_audio_bind_as(struct hdaa_devinfo *devinfo)
cnt += as[j].num_chans;
}
if (devinfo->num_chans == 0) {
devinfo->chans = (struct hdaa_chan *)malloc(
sizeof(struct hdaa_chan) * cnt,
devinfo->chans = (struct hdaa_chan *)mallocarray(cnt,
sizeof(struct hdaa_chan),
M_HDAA, M_ZERO | M_NOWAIT);
if (devinfo->chans == NULL) {
device_printf(devinfo->dev,
@ -5491,8 +5491,8 @@ hdaa_prepare_pcms(struct hdaa_devinfo *devinfo)
devinfo->num_devs =
max(ardev, apdev) + max(drdev, dpdev);
devinfo->devs =
(struct hdaa_pcm_devinfo *)malloc(
devinfo->num_devs * sizeof(struct hdaa_pcm_devinfo),
(struct hdaa_pcm_devinfo *)mallocarray(
devinfo->num_devs, sizeof(struct hdaa_pcm_devinfo),
M_HDAA, M_ZERO | M_NOWAIT);
if (devinfo->devs == NULL) {
device_printf(devinfo->dev,

2
sys/dev/syscons/fire/fire_saver.c
View File

@ -155,7 +155,7 @@ fire_init(video_adapter_t *adp)
scrw = info.vi_width;
scrh = info.vi_height;
buf = (u_char *)malloc(scrw * (scrh + 1), M_DEVBUF, M_NOWAIT);
buf = (u_char *)mallocarray(scrw, scrh + 1, M_DEVBUF, M_NOWAIT);
if (buf) {
bzero(buf, scrw * (scrh + 1));
} else {

10
sys/dev/virtio/console/virtio_console.c
View File

@ -474,11 +474,11 @@ static int
vtcon_alloc_scports(struct vtcon_softc *sc)
{
struct vtcon_softc_port *scport;
int max, i;
u_int max, i;
max = sc->vtcon_max_ports;
sc->vtcon_ports = malloc(sizeof(struct vtcon_softc_port) * max,
sc->vtcon_ports = mallocarray(max, sizeof(struct vtcon_softc_port),
M_DEVBUF, M_NOWAIT | M_ZERO);
if (sc->vtcon_ports == NULL)
return (ENOMEM);
@ -497,7 +497,8 @@ vtcon_alloc_virtqueues(struct vtcon_softc *sc)
device_t dev;
struct vq_alloc_info *info;
struct vtcon_softc_port *scport;
int i, idx, portidx, nvqs, error;
u_int i, idx, portidx, nvqs;
int error;
dev = sc->vtcon_dev;
@ -505,7 +506,8 @@ vtcon_alloc_virtqueues(struct vtcon_softc *sc)
if (sc->vtcon_flags & VTCON_FLAG_MULTIPORT)
nvqs += 2;
info = malloc(sizeof(struct vq_alloc_info) * nvqs, M_TEMP, M_NOWAIT);
info = mallocarray(nvqs, sizeof(struct vq_alloc_info), M_TEMP,
M_NOWAIT);
if (info == NULL)
return (ENOMEM);

2
sys/dev/virtio/mmio/virtio_mmio.c
View File

@ -507,7 +507,7 @@ vtmmio_alloc_virtqueues(device_t dev, int flags, int nvqs,
if (nvqs <= 0)
return (EINVAL);
sc->vtmmio_vqs = malloc(nvqs * sizeof(struct vtmmio_virtqueue),
sc->vtmmio_vqs = mallocarray(nvqs, sizeof(struct vtmmio_virtqueue),
M_DEVBUF, M_NOWAIT | M_ZERO);
if (sc->vtmmio_vqs == NULL)
return (ENOMEM);

7
sys/dev/virtio/network/if_vtnet.c
View File

@ -755,9 +755,9 @@ vtnet_alloc_rxtx_queues(struct vtnet_softc *sc)
npairs = sc->vtnet_max_vq_pairs;
sc->vtnet_rxqs = malloc(sizeof(struct vtnet_rxq) * npairs, M_DEVBUF,
sc->vtnet_rxqs = mallocarray(npairs, sizeof(struct vtnet_rxq), M_DEVBUF,
M_NOWAIT | M_ZERO);
sc->vtnet_txqs = malloc(sizeof(struct vtnet_txq) * npairs, M_DEVBUF,
sc->vtnet_txqs = mallocarray(npairs, sizeof(struct vtnet_txq), M_DEVBUF,
M_NOWAIT | M_ZERO);
if (sc->vtnet_rxqs == NULL || sc->vtnet_txqs == NULL)
return (ENOMEM);
@ -887,7 +887,8 @@ vtnet_alloc_virtqueues(struct vtnet_softc *sc)
if (sc->vtnet_flags & VTNET_FLAG_CTRL_VQ)
nvqs++;
info = malloc(sizeof(struct vq_alloc_info) * nvqs, M_TEMP, M_NOWAIT);
info = mallocarray(nvqs, sizeof(struct vq_alloc_info), M_TEMP,
M_NOWAIT);
if (info == NULL)
return (ENOMEM);

4
sys/dev/virtio/pci/virtio_pci.c
View File

@ -491,7 +491,7 @@ vtpci_alloc_virtqueues(device_t dev, int flags, int nvqs,
if (nvqs <= 0)
return (EINVAL);
sc->vtpci_vqs = malloc(nvqs * sizeof(struct vtpci_virtqueue),
sc->vtpci_vqs = mallocarray(nvqs, sizeof(struct vtpci_virtqueue),
M_DEVBUF, M_NOWAIT | M_ZERO);
if (sc->vtpci_vqs == NULL)
return (ENOMEM);
@ -927,7 +927,7 @@ vtpci_alloc_intr_resources(struct vtpci_softc *sc)
/* Subtract one for the configuration changed interrupt. */
nvq_intrs = sc->vtpci_nmsix_resources - 1;
intr = sc->vtpci_msix_vq_interrupts = malloc(nvq_intrs *
intr = sc->vtpci_msix_vq_interrupts = mallocarray(nvq_intrs,
sizeof(struct vtpci_interrupt), M_DEVBUF, M_NOWAIT | M_ZERO);
if (sc->vtpci_msix_vq_interrupts == NULL)
return (ENOMEM);

12
sys/dev/vmware/vmxnet3/if_vmx.c
View File

@ -959,7 +959,7 @@ vmxnet3_init_rxq(struct vmxnet3_softc *sc, int q)
rxr = &rxq->vxrxq_cmd_ring[i];
rxr->vxrxr_rid = i;
rxr->vxrxr_ndesc = sc->vmx_nrxdescs;
rxr->vxrxr_rxbuf = malloc(rxr->vxrxr_ndesc *
rxr->vxrxr_rxbuf = mallocarray(rxr->vxrxr_ndesc,
sizeof(struct vmxnet3_rxbuf), M_DEVBUF, M_NOWAIT | M_ZERO);
if (rxr->vxrxr_rxbuf == NULL)
return (ENOMEM);
@ -987,7 +987,7 @@ vmxnet3_init_txq(struct vmxnet3_softc *sc, int q)
txq->vxtxq_id = q;
txr->vxtxr_ndesc = sc->vmx_ntxdescs;
txr->vxtxr_txbuf = malloc(txr->vxtxr_ndesc *
txr->vxtxr_txbuf = mallocarray(txr->vxtxr_ndesc,
sizeof(struct vmxnet3_txbuf), M_DEVBUF, M_NOWAIT | M_ZERO);
if (txr->vxtxr_txbuf == NULL)
return (ENOMEM);
@ -1023,10 +1023,10 @@ vmxnet3_alloc_rxtx_queues(struct vmxnet3_softc *sc)
sc->vmx_max_ntxqueues = 1;
}
sc->vmx_rxq = malloc(sizeof(struct vmxnet3_rxqueue) *
sc->vmx_max_nrxqueues, M_DEVBUF, M_NOWAIT | M_ZERO);
sc->vmx_txq = malloc(sizeof(struct vmxnet3_txqueue) *
sc->vmx_max_ntxqueues, M_DEVBUF, M_NOWAIT | M_ZERO);
sc->vmx_rxq = mallocarray(sc->vmx_max_nrxqueues,
sizeof(struct vmxnet3_rxqueue), M_DEVBUF, M_NOWAIT | M_ZERO);
sc->vmx_txq = mallocarray(sc->vmx_max_ntxqueues,
sizeof(struct vmxnet3_txqueue), M_DEVBUF, M_NOWAIT | M_ZERO);
if (sc->vmx_rxq == NULL || sc->vmx_txq == NULL)
return (ENOMEM);

2
sys/dev/vnic/nicvf_queues.c
View File

@ -1104,7 +1104,7 @@ nicvf_init_snd_queue(struct nicvf *nic, struct snd_queue *sq, int q_len,
}
/* Allocate send buffers array */
sq->snd_buff = malloc(sizeof(*sq->snd_buff) * q_len, M_NICVF,
sq->snd_buff = mallocarray(q_len, sizeof(*sq->snd_buff), M_NICVF,
(M_NOWAIT | M_ZERO));
if (sq->snd_buff == NULL) {
device_printf(nic->dev,

6
sys/dev/xen/blkback/blkback.c
View File

@ -3166,7 +3166,7 @@ xbb_alloc_requests(struct xbb_softc *xbb)
/*
* Allocate request book keeping datastructures.
*/
xbb->requests = malloc(xbb->max_requests * sizeof(*xbb->requests),
xbb->requests = mallocarray(xbb->max_requests, sizeof(*xbb->requests),
M_XENBLOCKBACK, M_NOWAIT|M_ZERO);
if (xbb->requests == NULL) {
xenbus_dev_fatal(xbb->dev, ENOMEM,
@ -3194,7 +3194,7 @@ xbb_alloc_request_lists(struct xbb_softc *xbb)
* If no requests can be merged, we need 1 request list per
* in flight request.
*/
xbb->request_lists = malloc(xbb->max_requests *
xbb->request_lists = mallocarray(xbb->max_requests,
sizeof(*xbb->request_lists), M_XENBLOCKBACK, M_NOWAIT|M_ZERO);
if (xbb->request_lists == NULL) {
xenbus_dev_fatal(xbb->dev, ENOMEM,
@ -3222,7 +3222,7 @@ xbb_alloc_request_lists(struct xbb_softc *xbb)
}
#endif /* XBB_USE_BOUNCE_BUFFERS */
reqlist->gnt_handles = malloc(xbb->max_reqlist_segments *
reqlist->gnt_handles = mallocarray(xbb->max_reqlist_segments,
sizeof(*reqlist->gnt_handles),
M_XENBLOCKBACK, M_NOWAIT|M_ZERO);
if (reqlist->gnt_handles == NULL) {

9
sys/dev/xen/blkfront/blkfront.c
View File

@ -1306,8 +1306,8 @@ xbd_connect(struct xbd_softc *sc)
}
/* Per-transaction data allocation. */
sc->xbd_shadow = malloc(sizeof(*sc->xbd_shadow) * sc->xbd_max_requests,
M_XENBLOCKFRONT, M_NOWAIT|M_ZERO);
sc->xbd_shadow = mallocarray(sc->xbd_max_requests,
sizeof(*sc->xbd_shadow), M_XENBLOCKFRONT, M_NOWAIT|M_ZERO);
if (sc->xbd_shadow == NULL) {
bus_dma_tag_destroy(sc->xbd_io_dmat);
xenbus_dev_fatal(sc->xbd_dev, ENOMEM,
@ -1320,9 +1320,8 @@ xbd_connect(struct xbd_softc *sc)
void * indirectpages;
cm = &sc->xbd_shadow[i];
cm->cm_sg_refs = malloc(
sizeof(grant_ref_t) * sc->xbd_max_request_segments,
M_XENBLOCKFRONT, M_NOWAIT);
cm->cm_sg_refs = mallocarray(sc->xbd_max_request_segments,
sizeof(grant_ref_t), M_XENBLOCKFRONT, M_NOWAIT);
if (cm->cm_sg_refs == NULL)
break;
cm->cm_id = i;