dev: make some use of mallocarray(9).
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:
parent
a019e26c0f
commit
26c1d774b5
Notes:
svn2git
2020-12-20 02:59:44 +00:00
svn path=/head/; revision=327949
@ -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;
|
||||
|
@ -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)
|
||||
|
@ -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__);
|
||||
|
@ -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;
|
||||
|
@ -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,
|
||||
|
@ -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;
|
||||
|
||||
|
@ -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");
|
||||
|
@ -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");
|
||||
|
@ -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);
|
||||
|
@ -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,
|
||||
|
@ -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) {
|
||||
|
@ -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);
|
||||
|
@ -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. */
|
||||
|
||||
|
@ -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");
|
||||
|
@ -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);
|
||||
|
@ -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",
|
||||
|
@ -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);
|
||||
|
@ -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);
|
||||
|
@ -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;
|
||||
|
@ -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);
|
||||
|
@ -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;
|
||||
|
@ -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");
|
||||
|
@ -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);
|
||||
|
@ -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],
|
||||
|
@ -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;
|
||||
|
@ -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);
|
||||
|
||||
|
@ -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;
|
||||
|
@ -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;
|
||||
|
@ -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");
|
||||
|
@ -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;
|
||||
|
@ -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;
|
||||
|
@ -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;
|
||||
|
@ -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;
|
||||
|
@ -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,
|
||||
|
@ -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 {
|
||||
|
@ -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);
|
||||
|
||||
|
@ -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);
|
||||
|
@ -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);
|
||||
|
||||
|
@ -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);
|
||||
|
@ -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);
|
||||
|
||||
|
@ -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,
|
||||
|
@ -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) {
|
||||
|
@ -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;
|
||||
|
Loading…
Reference in New Issue
Block a user