Page MenuHomeFreeBSD
Files F171340780

D13837.id37750.diff
No OneTemporary
Actions

D13837.id37750.diff
View Options

Index: sys/amd64/amd64/bpf_jit_machdep.c
===================================================================
--- sys/amd64/amd64/bpf_jit_machdep.c
+++ sys/amd64/amd64/bpf_jit_machdep.c
@@ -186,7 +186,7 @@
/* Allocate the reference table for the jumps. */
if (fjmp) {
#ifdef _KERNEL
- stream.refs = malloc((nins + 1) * sizeof(u_int), M_BPFJIT,
+ stream.refs = mallocarray(nins + 1, sizeof(u_int), M_BPFJIT,
M_NOWAIT | M_ZERO);
#else
stream.refs = calloc(nins + 1, sizeof(u_int));
Index: sys/arm/xscale/ixp425/if_npe.c
===================================================================
--- sys/arm/xscale/ixp425/if_npe.c
+++ sys/arm/xscale/ixp425/if_npe.c
@@ -515,7 +515,8 @@
return error;
}
/* XXX M_TEMP */
- dma->buf = malloc(nbuf * sizeof(struct npebuf), M_TEMP, M_NOWAIT | M_ZERO);
+ dma->buf = mallocarray(nbuf, sizeof(struct npebuf), M_TEMP,
+ M_NOWAIT | M_ZERO);
if (dma->buf == NULL) {
device_printf(sc->sc_dev,
"unable to allocate memory for %s s/w buffers\n",
Index: sys/arm64/arm64/busdma_bounce.c
===================================================================
--- sys/arm64/arm64/busdma_bounce.c
+++ sys/arm64/arm64/busdma_bounce.c
@@ -302,8 +302,8 @@
error = 0;
if (dmat->segments == NULL) {
- dmat->segments = (bus_dma_segment_t *)malloc(
- sizeof(bus_dma_segment_t) * dmat->common.nsegments,
+ dmat->segments = (bus_dma_segment_t *)mallocarray(
+ dmat->common.nsegments, sizeof(bus_dma_segment_t)
M_DEVBUF, M_NOWAIT);
if (dmat->segments == NULL) {
CTR3(KTR_BUSDMA, "%s: tag %p error %d",
Index: sys/cam/cam_queue.c
===================================================================
--- sys/cam/cam_queue.c
+++ sys/cam/cam_queue.c
@@ -126,7 +126,7 @@
KASSERT(new_size >= queue->entries, ("camq_resize: "
"New queue size can't accommodate queued entries (%d < %d).",
new_size, queue->entries));
- new_array = (cam_pinfo **)malloc(new_size * sizeof(cam_pinfo *),
+ new_array = (cam_pinfo **)mallocarray(new_size, sizeof(cam_pinfo *),
M_CAMQ, M_NOWAIT);
if (new_array == NULL) {
/* Couldn't satisfy request */
Index: sys/cam/ctl/ctl_frontend.c
===================================================================
--- sys/cam/ctl/ctl_frontend.c
+++ sys/cam/ctl/ctl_frontend.c
@@ -172,8 +172,8 @@
* Initialize the initiator and portname mappings
*/
port->max_initiators = CTL_MAX_INIT_PER_PORT;
- port->wwpn_iid = malloc(sizeof(*port->wwpn_iid) * port->max_initiators,
- M_CTL, M_NOWAIT | M_ZERO);
+ port->wwpn_iid = mallocarray(port->max_initiators,
+ sizeof(*port->wwpn_iid), M_CTL, M_NOWAIT | M_ZERO);
if (port->wwpn_iid == NULL) {
retval = ENOMEM;
goto error;
Index: sys/compat/ndis/subr_ndis.c
===================================================================
--- sys/compat/ndis/subr_ndis.c
+++ sys/compat/ndis/subr_ndis.c
@@ -1351,7 +1351,7 @@
block = (ndis_miniport_block *)adapter;
sc = device_get_softc(block->nmb_physdeviceobj->do_devext);
- sc->ndis_mmaps = malloc(sizeof(bus_dmamap_t) * physmapneeded,
+ sc->ndis_mmaps = mallocarray(physmapneeded, sizeof(bus_dmamap_t),
M_DEVBUF, M_NOWAIT|M_ZERO);
if (sc->ndis_mmaps == NULL)
Index: sys/dev/aacraid/aacraid.c
===================================================================
--- sys/dev/aacraid/aacraid.c
+++ sys/dev/aacraid/aacraid.c
@@ -1458,7 +1458,7 @@
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;
Index: sys/dev/advansys/advansys.c
===================================================================
--- sys/dev/advansys/advansys.c
+++ sys/dev/advansys/advansys.c
@@ -1255,7 +1255,7 @@
* 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)
Index: sys/dev/ath/if_ath_rx_edma.c
===================================================================
--- sys/dev/ath/if_ath_rx_edma.c
+++ sys/dev/ath/if_ath_rx_edma.c
@@ -901,9 +901,8 @@
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__);
Index: sys/dev/beri/virtio/virtio.c
===================================================================
--- sys/dev/beri/virtio/virtio.c
+++ sys/dev/beri/virtio/virtio.c
@@ -250,7 +250,7 @@
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;
Index: sys/dev/bhnd/bcma/bcma_erom.c
===================================================================
--- sys/dev/bhnd/bcma/bcma_erom.c
+++ sys/dev/bhnd/bcma/bcma_erom.c
@@ -400,7 +400,7 @@
}
/* Allocate our output buffer */
- buffer = malloc(sizeof(struct bhnd_core_info) * count, M_BHND,
+ buffer = mallocarray(count, sizeof(struct bhnd_core_info), M_BHND,
M_NOWAIT);
if (buffer == NULL) {
error = ENOMEM;
Index: sys/dev/bhnd/nvram/bhnd_nvram_private.h
===================================================================
--- sys/dev/bhnd/nvram/bhnd_nvram_private.h
+++ sys/dev/bhnd/nvram/bhnd_nvram_private.h
@@ -74,7 +74,7 @@
#define bhnd_nv_toupper(c) toupper(c)
#define bhnd_nv_malloc(size) malloc((size), M_BHND_NVRAM, M_NOWAIT)
-#define bhnd_nv_calloc(n, size) malloc((n) * (size), M_BHND_NVRAM, \
+#define bhnd_nv_calloc(n, size) mallocarray((n), (size), M_BHND_NVRAM, \
M_NOWAIT | M_ZERO)
#define bhnd_nv_reallocf(buf, size) reallocf((buf), (size), M_BHND_NVRAM, \
M_NOWAIT)
Index: sys/dev/bhnd/siba/siba_erom.c
===================================================================
--- sys/dev/bhnd/siba/siba_erom.c
+++ sys/dev/bhnd/siba/siba_erom.c
@@ -445,7 +445,7 @@
sc = (struct siba_erom *)erom;
/* Allocate our core array */
- out = malloc(sizeof(*out) * sc->io.ncores, M_BHND, M_NOWAIT);
+ out = mallocarray(sc->io.ncores, sizeof(*out), M_BHND, M_NOWAIT);
if (out == NULL)
return (ENOMEM);
Index: sys/dev/bnxt/if_bnxt.c
===================================================================
--- sys/dev/bnxt/if_bnxt.c
+++ sys/dev/bnxt/if_bnxt.c
@@ -351,7 +351,7 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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,
Index: sys/dev/bwn/if_bwn.c
===================================================================
--- sys/dev/bwn/if_bwn.c
+++ sys/dev/bwn/if_bwn.c
@@ -2677,8 +2677,8 @@
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;
Index: sys/dev/bwn/if_bwn_phy_lp.c
===================================================================
--- sys/dev/bwn/if_bwn_phy_lp.c
+++ sys/dev/bwn/if_bwn_phy_lp.c
@@ -1127,7 +1127,7 @@
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");
Index: sys/dev/ciss/ciss.c
===================================================================
--- sys/dev/ciss/ciss.c
+++ sys/dev/ciss/ciss.c
@@ -1427,7 +1427,7 @@
}
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 @@
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 @@
}
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 @@
}
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 @@
*/
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");
Index: sys/dev/cxgbe/crypto/t4_crypto.c
===================================================================
--- sys/dev/cxgbe/crypto/t4_crypto.c
+++ sys/dev/cxgbe/crypto/t4_crypto.c
@@ -1900,7 +1900,7 @@
}
}
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);
Index: sys/dev/esp/ncr53c9x.c
===================================================================
--- sys/dev/esp/ncr53c9x.c
+++ sys/dev/esp/ncr53c9x.c
@@ -292,7 +292,7 @@
} 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,
Index: sys/dev/fb/splash.c
===================================================================
--- sys/dev/fb/splash.c
+++ sys/dev/fb/splash.c
@@ -136,8 +136,8 @@
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) {
Index: sys/dev/gpio/gpiobus.c
===================================================================
--- sys/dev/gpio/gpiobus.c
+++ sys/dev/gpio/gpiobus.c
@@ -235,7 +235,7 @@
/* 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 @@
{
/* 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);
Index: sys/dev/if_ndis/if_ndis.c
===================================================================
--- sys/dev/if_ndis/if_ndis.c
+++ sys/dev/if_ndis/if_ndis.c
@@ -665,8 +665,8 @@
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. */
Index: sys/dev/iwi/if_iwi.c
===================================================================
--- sys/dev/iwi/if_iwi.c
+++ sys/dev/iwi/if_iwi.c
@@ -640,7 +640,7 @@
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 @@
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");
Index: sys/dev/kbd/kbd.c
===================================================================
--- sys/dev/kbd/kbd.c
+++ sys/dev/kbd/kbd.c
@@ -94,17 +94,18 @@
{
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);
Index: sys/dev/liquidio/base/lio_request_manager.c
===================================================================
--- sys/dev/liquidio/base/lio_request_manager.c
+++ sys/dev/liquidio/base/lio_request_manager.c
@@ -110,7 +110,7 @@
* 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",
Index: sys/dev/liquidio/lio_main.c
===================================================================
--- sys/dev/liquidio/lio_main.c
+++ sys/dev/liquidio/lio_main.c
@@ -1724,12 +1724,12 @@
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 @@
* 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);
Index: sys/dev/mpr/mpr.c
===================================================================
--- sys/dev/mpr/mpr.c
+++ sys/dev/mpr/mpr.c
@@ -1192,7 +1192,7 @@
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);
Index: sys/dev/mpr/mpr_mapping.c
===================================================================
--- sys/dev/mpr/mpr_mapping.c
+++ sys/dev/mpr/mpr_mapping.c
@@ -2141,27 +2141,27 @@
{
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 @@
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 @@
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 @@
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;
Index: sys/dev/mps/mps.c
===================================================================
--- sys/dev/mps/mps.c
+++ sys/dev/mps/mps.c
@@ -1164,12 +1164,12 @@
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);
Index: sys/dev/mps/mps_mapping.c
===================================================================
--- sys/dev/mps/mps_mapping.c
+++ sys/dev/mps/mps_mapping.c
@@ -1694,27 +1694,27 @@
{
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 @@
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 @@
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;
Index: sys/dev/mpt/mpt_cam.c
===================================================================
--- sys/dev/mpt/mpt_cam.c
+++ sys/dev/mpt/mpt_cam.c
@@ -637,8 +637,8 @@
}
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 @@
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");
Index: sys/dev/mrsas/mrsas.c
===================================================================
--- sys/dev/mrsas/mrsas.c
+++ sys/dev/mrsas/mrsas.c
@@ -2566,7 +2566,8 @@
* 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);
Index: sys/dev/mxge/if_mxge.c
===================================================================
--- sys/dev/mxge/if_mxge.c
+++ sys/dev/mxge/if_mxge.c
@@ -688,7 +688,7 @@
{
void *ptr;
- ptr = malloc(items * size, M_TEMP, M_NOWAIT);
+ ptr = mallocarray(items, size, M_TEMP, M_NOWAIT);
return ptr;
}
@@ -4390,8 +4390,8 @@
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 @@
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 @@
}
}
- 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],
Index: sys/dev/netmap/if_ptnet.c
===================================================================
--- sys/dev/netmap/if_ptnet.c
+++ sys/dev/netmap/if_ptnet.c
@@ -351,7 +351,7 @@
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;
Index: sys/dev/nvme/nvme_ns.c
===================================================================
--- sys/dev/nvme/nvme_ns.c
+++ sys/dev/nvme/nvme_ns.c
@@ -321,7 +321,8 @@
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);
Index: sys/dev/pst/pst-iop.c
===================================================================
--- sys/dev/pst/pst-iop.c
+++ sys/dev/pst/pst-iop.c
@@ -323,7 +323,7 @@
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;
Index: sys/dev/ral/rt2560.c
===================================================================
--- sys/dev/ral/rt2560.c
+++ sys/dev/ral/rt2560.c
@@ -488,7 +488,7 @@
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 @@
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;
Index: sys/dev/ral/rt2661.c
===================================================================
--- sys/dev/ral/rt2661.c
+++ sys/dev/ral/rt2661.c
@@ -497,7 +497,7 @@
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 @@
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");
Index: sys/dev/rp/rp.c
===================================================================
--- sys/dev/rp/rp.c
+++ sys/dev/rp/rp.c
@@ -732,7 +732,8 @@
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;
Index: sys/dev/rp/rp_isa.c
===================================================================
--- sys/dev/rp/rp_isa.c
+++ sys/dev/rp/rp_isa.c
@@ -178,8 +178,10 @@
/* 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;
Index: sys/dev/rp/rp_pci.c
===================================================================
--- sys/dev/rp/rp_pci.c
+++ sys/dev/rp/rp_pci.c
@@ -164,8 +164,10 @@
/* 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;
Index: sys/dev/sound/midi/midi.c
===================================================================
--- sys/dev/sound/midi/midi.c
+++ sys/dev/sound/midi/midi.c
@@ -340,14 +340,15 @@
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;
Index: sys/dev/sound/pci/hda/hdaa.c
===================================================================
--- sys/dev/sound/pci/hda/hdaa.c
+++ sys/dev/sound/pci/hda/hdaa.c
@@ -3034,8 +3034,8 @@
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 @@
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 @@
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 @@
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,
Index: sys/dev/syscons/fire/fire_saver.c
===================================================================
--- sys/dev/syscons/fire/fire_saver.c
+++ sys/dev/syscons/fire/fire_saver.c
@@ -155,7 +155,7 @@
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 {
Index: sys/dev/virtio/console/virtio_console.c
===================================================================
--- sys/dev/virtio/console/virtio_console.c
+++ sys/dev/virtio/console/virtio_console.c
@@ -465,11 +465,11 @@
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);
@@ -488,7 +488,8 @@
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;
@@ -496,7 +497,8 @@
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);
Index: sys/dev/virtio/mmio/virtio_mmio.c
===================================================================
--- sys/dev/virtio/mmio/virtio_mmio.c
+++ sys/dev/virtio/mmio/virtio_mmio.c
@@ -507,7 +507,7 @@
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);
Index: sys/dev/virtio/network/if_vtnet.c
===================================================================
--- sys/dev/virtio/network/if_vtnet.c
+++ sys/dev/virtio/network/if_vtnet.c
@@ -755,9 +755,9 @@
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 @@
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);
Index: sys/dev/virtio/pci/virtio_pci.c
===================================================================
--- sys/dev/virtio/pci/virtio_pci.c
+++ sys/dev/virtio/pci/virtio_pci.c
@@ -491,7 +491,7 @@
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 @@
/* 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);
Index: sys/dev/vmware/vmxnet3/if_vmx.c
===================================================================
--- sys/dev/vmware/vmxnet3/if_vmx.c
+++ sys/dev/vmware/vmxnet3/if_vmx.c
@@ -959,7 +959,7 @@
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 @@
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 @@
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);
Index: sys/dev/vnic/nicvf_queues.c
===================================================================
--- sys/dev/vnic/nicvf_queues.c
+++ sys/dev/vnic/nicvf_queues.c
@@ -1104,7 +1104,7 @@
}
/* 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,
Index: sys/dev/xen/blkback/blkback.c
===================================================================
--- sys/dev/xen/blkback/blkback.c
+++ sys/dev/xen/blkback/blkback.c
@@ -3166,7 +3166,7 @@
/*
* 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 @@
* 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 @@
}
#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) {
Index: sys/dev/xen/blkfront/blkfront.c
===================================================================
--- sys/dev/xen/blkfront/blkfront.c
+++ sys/dev/xen/blkfront/blkfront.c
@@ -1306,8 +1306,8 @@
}
/* 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 @@
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;
Index: sys/fs/nfsclient/nfs_clvnops.c
===================================================================
--- sys/fs/nfsclient/nfs_clvnops.c
+++ sys/fs/nfsclient/nfs_clvnops.c
@@ -2666,7 +2666,7 @@
#define NFS_COMMITBVECSIZ 20
#endif
struct buf *bvec_on_stack[NFS_COMMITBVECSIZ];
- int bvecsize = 0, bveccount;
+ u_int bvecsize = 0, bveccount;
if (called_from_renewthread != 0)
slptimeo = hz;
Index: sys/geom/uzip/g_uzip_zlib.c
===================================================================
--- sys/geom/uzip/g_uzip_zlib.c
+++ sys/geom/uzip/g_uzip_zlib.c
@@ -132,7 +132,7 @@
{
void *ptr;
- ptr = malloc(type * size, M_GEOM_UZIP, M_NOWAIT);
+ ptr = mallocarray(type, size, M_GEOM_UZIP, M_NOWAIT);
return (ptr);
}
Index: sys/gnu/dev/bwn/phy_n/if_bwn_phy_n_core.c
===================================================================
--- sys/gnu/dev/bwn/phy_n/if_bwn_phy_n_core.c
+++ sys/gnu/dev/bwn/phy_n/if_bwn_phy_n_core.c
@@ -1620,7 +1620,7 @@
uint16_t i;
uint32_t *data;
- data = malloc(len * sizeof(uint32_t), M_DEVBUF, M_NOWAIT | M_ZERO);
+ data = mallocarray(len, sizeof(uint32_t), M_DEVBUF, M_NOWAIT | M_ZERO);
if (!data) {
BWN_ERRPRINTF(mac->mac_sc, "allocation for samples loading failed\n");
return -ENOMEM;
@@ -1663,7 +1663,8 @@
len = bw << 1;
}
- samples = malloc(len * sizeof(struct bwn_c32), M_DEVBUF, M_NOWAIT | M_ZERO);
+ samples = mallocarray(len, sizeof(struct bwn_c32), M_DEVBUF,
+ M_NOWAIT | M_ZERO);
if (!samples) {
BWN_ERRPRINTF(mac->mac_sc, "allocation for samples generation failed\n");
return 0;
Index: sys/i386/i386/bpf_jit_machdep.c
===================================================================
--- sys/i386/i386/bpf_jit_machdep.c
+++ sys/i386/i386/bpf_jit_machdep.c
@@ -185,7 +185,7 @@
/* Allocate the reference table for the jumps. */
if (fjmp) {
#ifdef _KERNEL
- stream.refs = malloc((nins + 1) * sizeof(u_int), M_BPFJIT,
+ stream.refs = mallocarray(nins + 1, sizeof(u_int), M_BPFJIT,
M_NOWAIT | M_ZERO);
#else
stream.refs = calloc(nins + 1, sizeof(u_int));
Index: sys/i386/i386/k6_mem.c
===================================================================
--- sys/i386/i386/k6_mem.c
+++ sys/i386/i386/k6_mem.c
@@ -107,7 +107,7 @@
sc->mr_cap = 0;
sc->mr_ndesc = 2; /* XXX (BFF) For now, we only have one msr for this */
- sc->mr_desc = malloc(sc->mr_ndesc * sizeof(struct mem_range_desc),
+ sc->mr_desc = mallocarray(sc->mr_ndesc, sizeof(struct mem_range_desc),
M_MEMDESC, M_NOWAIT | M_ZERO);
if (sc->mr_desc == NULL)
panic("k6_mrinit: malloc returns NULL");
Index: sys/kern/init_main.c
===================================================================
--- sys/kern/init_main.c
+++ sys/kern/init_main.c
@@ -160,7 +160,7 @@
count += newsysinit_end - newsysinit;
else
count += sysinit_end - sysinit;
- newset = malloc(count * sizeof(*sipp), M_TEMP, M_NOWAIT);
+ newset = mallocarray(count, sizeof(*sipp), M_TEMP, M_NOWAIT);
if (newset == NULL)
panic("cannot malloc for sysinit");
xipp = newset;
Index: sys/kern/kern_cpu.c
===================================================================
--- sys/kern/kern_cpu.c
+++ sys/kern/kern_cpu.c
@@ -444,7 +444,7 @@
* match of settings against each level.
*/
count = CF_MAX_LEVELS;
- levels = malloc(count * sizeof(*levels), M_TEMP, M_NOWAIT);
+ levels = mallocarray(count, sizeof(*levels), M_TEMP, M_NOWAIT);
if (levels == NULL)
return (ENOMEM);
error = CPUFREQ_LEVELS(sc->dev, levels, &count);
@@ -969,7 +969,7 @@
/* Get settings from the device and generate the output string. */
set_count = MAX_SETTINGS;
- sets = malloc(set_count * sizeof(*sets), M_TEMP, M_NOWAIT);
+ sets = mallocarray(set_count, sizeof(*sets), M_TEMP, M_NOWAIT);
if (sets == NULL) {
sbuf_delete(&sb);
return (ENOMEM);
Index: sys/kern/kern_ctf.c
===================================================================
--- sys/kern/kern_ctf.c
+++ sys/kern/kern_ctf.c
@@ -45,7 +45,7 @@
{
void *ptr;
- ptr = malloc(items * size, M_TEMP, M_NOWAIT);
+ ptr = mallocarray(items, size, M_TEMP, M_NOWAIT);
return ptr;
}
Index: sys/kern/kern_pmc.c
===================================================================
--- sys/kern/kern_pmc.c
+++ sys/kern/kern_pmc.c
@@ -338,7 +338,8 @@
"range.\n", pmc_softevents);
pmc_softevents = PMC_EV_DYN_COUNT;
}
- pmc_softs = malloc(pmc_softevents * sizeof(struct pmc_soft *), M_PMCHOOKS, M_NOWAIT|M_ZERO);
+ pmc_softs = mallocarray(pmc_softevents, sizeof(struct pmc_soft *),
+ M_PMCHOOKS, M_NOWAIT|M_ZERO);
KASSERT(pmc_softs != NULL, ("cannot allocate soft events table"));
}
Index: sys/kern/subr_bus.c
===================================================================
--- sys/kern/subr_bus.c
+++ sys/kern/subr_bus.c
@@ -1464,7 +1464,7 @@
device_t *list;
count = devclass_get_count(dc);
- list = malloc(count * sizeof(device_t), M_TEMP, M_NOWAIT|M_ZERO);
+ list = mallocarray(count, sizeof(device_t), M_TEMP, M_NOWAIT|M_ZERO);
if (!list)
return (ENOMEM);
@@ -1680,7 +1680,7 @@
oldlist = dc->devices;
newsize = roundup((unit + 1), MINALLOCSIZE / sizeof(device_t));
- newlist = malloc(sizeof(device_t) * newsize, M_BUS, M_NOWAIT);
+ newlist = mallocarray(newsize, sizeof(device_t), M_BUS, M_NOWAIT);
if (!newlist)
return (ENOMEM);
if (oldlist != NULL)
@@ -2300,7 +2300,7 @@
return (0);
}
- list = malloc(count * sizeof(device_t), M_TEMP, M_NOWAIT|M_ZERO);
+ list = mallocarray(count, sizeof(device_t), M_TEMP, M_NOWAIT|M_ZERO);
if (!list)
return (ENOMEM);
Index: sys/kern/subr_taskqueue.c
===================================================================
--- sys/kern/subr_taskqueue.c
+++ sys/kern/subr_taskqueue.c
@@ -651,8 +651,8 @@
vsnprintf(ktname, sizeof(ktname), name, ap);
tq = *tqp;
- tq->tq_threads = malloc(sizeof(struct thread *) * count, M_TASKQUEUE,
- M_NOWAIT | M_ZERO);
+ tq->tq_threads = mallocarray(count, sizeof(struct thread *),
+ M_TASKQUEUE, M_NOWAIT | M_ZERO);
if (tq->tq_threads == NULL) {
printf("%s: no memory for %s threads\n", __func__, ktname);
return (ENOMEM);
Index: sys/kern/subr_vmem.c
===================================================================
--- sys/kern/subr_vmem.c
+++ sys/kern/subr_vmem.c
@@ -686,7 +686,7 @@
MPASS(newhashsize > 0);
- newhashlist = malloc(sizeof(struct vmem_hashlist) * newhashsize,
+ newhashlist = mallocarray(newhashsize, sizeof(struct vmem_hashlist),
M_VMEM, M_NOWAIT);
if (newhashlist == NULL)
return ENOMEM;
Index: sys/libkern/arc4random.c
===================================================================
--- sys/libkern/arc4random.c
+++ sys/libkern/arc4random.c
@@ -120,7 +120,7 @@
{
struct chacha20_s *chacha20;
- chacha20inst = malloc((mp_maxid + 1) * sizeof(struct chacha20_s),
+ chacha20inst = mallocarray(mp_maxid + 1, sizeof(struct chacha20_s),
M_CHACHA20RANDOM, M_NOWAIT | M_ZERO);
KASSERT(chacha20inst != NULL, ("chacha20_init: memory allocation error"));
Index: sys/mips/mips/busdma_machdep.c
===================================================================
--- sys/mips/mips/busdma_machdep.c
+++ sys/mips/mips/busdma_machdep.c
@@ -345,7 +345,8 @@
struct sync_list *slist;
bus_dmamap_t map;
- slist = malloc(sizeof(*slist) * dmat->nsegments, M_BUSDMA, M_NOWAIT);
+ slist = mallocarray(dmat->nsegments, sizeof(*slist), M_BUSDMA,
+ M_NOWAIT);
if (slist == NULL)
return (NULL);
map = uma_zalloc_arg(dmamap_zone, dmat, M_NOWAIT);
@@ -527,9 +528,8 @@
int error = 0;
if (dmat->segments == NULL) {
- dmat->segments = (bus_dma_segment_t *)malloc(
- sizeof(bus_dma_segment_t) * dmat->nsegments, M_BUSDMA,
- M_NOWAIT);
+ dmat->segments = (bus_dma_segment_t *)malloc(dmat->nsegments,
+ sizeof(bus_dma_segment_t), M_BUSDMA, M_NOWAIT);
if (dmat->segments == NULL) {
CTR3(KTR_BUSDMA, "%s: tag %p error %d",
__func__, dmat, ENOMEM);
@@ -640,9 +640,8 @@
else
mflags = M_WAITOK;
if (dmat->segments == NULL) {
- dmat->segments = (bus_dma_segment_t *)malloc(
- sizeof(bus_dma_segment_t) * dmat->nsegments, M_BUSDMA,
- mflags);
+ dmat->segments = (bus_dma_segment_t *)malloc(dmat->nsegments,
+ sizeof(bus_dma_segment_t), M_BUSDMA, mflags);
if (dmat->segments == NULL) {
CTR4(KTR_BUSDMA, "%s: tag %p tag flags 0x%x error %d",
__func__, dmat, dmat->flags, ENOMEM);
Index: sys/mips/nlm/dev/sec/nlmrsa.c
===================================================================
--- sys/mips/nlm/dev/sec/nlmrsa.c
+++ sys/mips/nlm/dev/sec/nlmrsa.c
@@ -346,7 +346,7 @@
if (ses == NULL) {
sesn = sc->sc_nsessions;
- ses = malloc((sesn + 1) * sizeof(*ses),
+ ses = mallocarray(sesn + 1, sizeof(*ses),
M_DEVBUF, M_NOWAIT);
if (ses == NULL)
return (ENOMEM);
@@ -528,8 +528,9 @@
goto errout;
}
cmd->rsafn = 0; /* Mod Exp */
- cmd->rsasrc = malloc(
- cmd->rsaopsize * (krp->krp_iparams + krp->krp_oparams),
+ cmd->rsasrc = mallocarray(
+ krp->krp_iparams + krp->krp_oparams,
+ cmd->rsaopsize,
M_DEVBUF,
M_NOWAIT | M_ZERO);
if (cmd->rsasrc == NULL) {
Index: sys/net/if_vlan.c
===================================================================
--- sys/net/if_vlan.c
+++ sys/net/if_vlan.c
@@ -479,7 +479,7 @@
return;
/* M_NOWAIT because we're called with trunk mutex held */
- hash2 = malloc(sizeof(struct ifvlanhead) * n2, M_VLAN, M_NOWAIT);
+ hash2 = mallocarray(n2, sizeof(struct ifvlanhead), M_VLAN, M_NOWAIT);
if (hash2 == NULL) {
printf("%s: out of memory -- hash size not changed\n",
__func__);
Index: sys/net/iflib.c
===================================================================
--- sys/net/iflib.c
+++ sys/net/iflib.c
@@ -1550,15 +1550,15 @@
goto fail;
}
if (!(txq->ift_sds.ifsd_flags =
- (uint8_t *) malloc(sizeof(uint8_t) *
- scctx->isc_ntxd[txq->ift_br_offset], M_IFLIB, M_NOWAIT | M_ZERO))) {
+ (uint8_t *) mallocarray(scctx->isc_ntxd[txq->ift_br_offset],
+ sizeof(uint8_t), M_IFLIB, M_NOWAIT | M_ZERO))) {
device_printf(dev, "Unable to allocate tx_buffer memory\n");
err = ENOMEM;
goto fail;
}
if (!(txq->ift_sds.ifsd_m =
- (struct mbuf **) malloc(sizeof(struct mbuf *) *
- scctx->isc_ntxd[txq->ift_br_offset], M_IFLIB, M_NOWAIT | M_ZERO))) {
+ (struct mbuf **) mallocarray(scctx->isc_ntxd[txq->ift_br_offset],
+ sizeof(struct mbuf *), M_IFLIB, M_NOWAIT | M_ZERO))) {
device_printf(dev, "Unable to allocate tx_buffer memory\n");
err = ENOMEM;
goto fail;
@@ -1570,7 +1570,8 @@
return (0);
if (!(txq->ift_sds.ifsd_map =
- (bus_dmamap_t *) malloc(sizeof(bus_dmamap_t) * scctx->isc_ntxd[txq->ift_br_offset], M_IFLIB, M_NOWAIT | M_ZERO))) {
+ (bus_dmamap_t *) mallocarray(scctx->isc_ntxd[txq->ift_br_offset],
+ sizeof(bus_dmamap_t), M_IFLIB, M_NOWAIT | M_ZERO))) {
device_printf(dev, "Unable to allocate tx_buffer map memory\n");
err = ENOMEM;
goto fail;
@@ -1726,22 +1727,22 @@
goto fail;
}
if (!(fl->ifl_sds.ifsd_flags =
- (uint8_t *) malloc(sizeof(uint8_t) *
- scctx->isc_nrxd[rxq->ifr_fl_offset], M_IFLIB, M_NOWAIT | M_ZERO))) {
+ (uint8_t *) mallocarray(scctx->isc_nrxd[rxq->ifr_fl_offset],
+ sizeof(uint8_t), M_IFLIB, M_NOWAIT | M_ZERO))) {
device_printf(dev, "Unable to allocate tx_buffer memory\n");
err = ENOMEM;
goto fail;
}
if (!(fl->ifl_sds.ifsd_m =
- (struct mbuf **) malloc(sizeof(struct mbuf *) *
- scctx->isc_nrxd[rxq->ifr_fl_offset], M_IFLIB, M_NOWAIT | M_ZERO))) {
+ (struct mbuf **) mallocarray(scctx->isc_nrxd[rxq->ifr_fl_offset],
+ sizeof(struct mbuf *), M_IFLIB, M_NOWAIT | M_ZERO))) {
device_printf(dev, "Unable to allocate tx_buffer memory\n");
err = ENOMEM;
goto fail;
}
if (!(fl->ifl_sds.ifsd_cl =
- (caddr_t *) malloc(sizeof(caddr_t) *
- scctx->isc_nrxd[rxq->ifr_fl_offset], M_IFLIB, M_NOWAIT | M_ZERO))) {
+ (caddr_t *) mallocarray(scctx->isc_nrxd[rxq->ifr_fl_offset],
+ sizeof(caddr_t), M_IFLIB, M_NOWAIT | M_ZERO))) {
device_printf(dev, "Unable to allocate tx_buffer memory\n");
err = ENOMEM;
goto fail;
@@ -1753,7 +1754,8 @@
continue;
if (!(fl->ifl_sds.ifsd_map =
- (bus_dmamap_t *) malloc(sizeof(bus_dmamap_t) * scctx->isc_nrxd[rxq->ifr_fl_offset], M_IFLIB, M_NOWAIT | M_ZERO))) {
+ (bus_dmamap_t *) mallocarray(scctx->isc_nrxd[rxq->ifr_fl_offset],
+ sizeof(bus_dmamap_t), M_IFLIB, M_NOWAIT | M_ZERO))) {
device_printf(dev, "Unable to allocate tx_buffer map memory\n");
err = ENOMEM;
goto fail;
@@ -4745,8 +4747,8 @@
/* Allocate the TX ring struct memory */
if (!(txq =
- (iflib_txq_t) malloc(sizeof(struct iflib_txq) *
- ntxqsets, M_IFLIB, M_NOWAIT | M_ZERO))) {
+ (iflib_txq_t) mallocarray(ntxqsets, sizeof(struct iflib_txq),
+ M_IFLIB, M_NOWAIT | M_ZERO))) {
device_printf(dev, "Unable to allocate TX ring memory\n");
err = ENOMEM;
goto fail;
@@ -4754,8 +4756,8 @@
/* Now allocate the RX */
if (!(rxq =
- (iflib_rxq_t) malloc(sizeof(struct iflib_rxq) *
- nrxqsets, M_IFLIB, M_NOWAIT | M_ZERO))) {
+ (iflib_rxq_t) mallocarray(nrxqsets, sizeof(struct iflib_rxq),
+ M_IFLIB, M_NOWAIT | M_ZERO))) {
device_printf(dev, "Unable to allocate RX ring memory\n");
err = ENOMEM;
goto rx_fail;
@@ -4849,7 +4851,8 @@
}
rxq->ifr_nfl = nfree_lists;
if (!(fl =
- (iflib_fl_t) malloc(sizeof(struct iflib_fl) * nfree_lists, M_IFLIB, M_NOWAIT | M_ZERO))) {
+ (iflib_fl_t) mallocarray(nfree_lists, sizeof(struct iflib_fl),
+ M_IFLIB, M_NOWAIT | M_ZERO))) {
device_printf(dev, "Unable to allocate free list memory\n");
err = ENOMEM;
goto err_tx_desc;
Index: sys/netgraph/ng_bridge.c
===================================================================
--- sys/netgraph/ng_bridge.c
+++ sys/netgraph/ng_bridge.c
@@ -907,7 +907,7 @@
newMask = newNumBuckets - 1;
/* Allocate and initialize new table */
- newTab = malloc(newNumBuckets * sizeof(*newTab),
+ newTab = mallocarray(newNumBuckets, sizeof(*newTab),
M_NETGRAPH_BRIDGE, M_NOWAIT | M_ZERO);
if (newTab == NULL)
return;
Index: sys/netgraph/ng_deflate.c
===================================================================
--- sys/netgraph/ng_deflate.c
+++ sys/netgraph/ng_deflate.c
@@ -427,7 +427,7 @@
z_alloc(void *notused, u_int items, u_int size)
{
- return (malloc(items * size, M_NETGRAPH_DEFLATE, M_NOWAIT));
+ return (mallocarray(items, size, M_NETGRAPH_DEFLATE, M_NOWAIT));
}
static void
Index: sys/netgraph/ng_parse.c
===================================================================
--- sys/netgraph/ng_parse.c
+++ sys/netgraph/ng_parse.c
@@ -1207,7 +1207,8 @@
int align, len, blen, error = 0;
/* Initialize */
- foff = malloc(num * sizeof(*foff), M_NETGRAPH_PARSE, M_NOWAIT | M_ZERO);
+ foff = mallocarray(num, sizeof(*foff), M_NETGRAPH_PARSE,
+ M_NOWAIT | M_ZERO);
if (foff == NULL) {
error = ENOMEM;
goto done;
Index: sys/netinet6/in6_jail.c
===================================================================
--- sys/netinet6/in6_jail.c
+++ sys/netinet6/in6_jail.c
@@ -103,8 +103,8 @@
*/
used = 1;
if (newip6 == NULL) {
- newip6 = malloc(ppr->pr_ip6s * sizeof(*newip6),
- M_PRISON, M_NOWAIT);
+ newip6 = mallocarray(ppr->pr_ip6s,
+ sizeof(*newip6), M_PRISON, M_NOWAIT);
if (newip6 != NULL)
used = 0;
}
Index: sys/powerpc/pseries/phyp_vscsi.c
===================================================================
--- sys/powerpc/pseries/phyp_vscsi.c
+++ sys/powerpc/pseries/phyp_vscsi.c
@@ -336,8 +336,8 @@
mtx_lock(&sc->io_lock);
vscsi_setup_bus(sc);
- sc->xfer = malloc(sizeof(sc->xfer[0])*sc->max_transactions, M_VSCSI,
- M_NOWAIT);
+ sc->xfer = mallocarray(sc->max_transactions, sizeof(sc->xfer[0]),
+ M_VSCSI, M_NOWAIT);
for (i = 0; i < sc->max_transactions; i++) {
xp = &sc->xfer[i];
xp->sc = sc;
Index: sys/x86/cpufreq/est.c
===================================================================
--- sys/x86/cpufreq/est.c
+++ sys/x86/cpufreq/est.c
@@ -1119,7 +1119,7 @@
goto out;
/* Parse settings into our local table format. */
- table = malloc((count + 1) * sizeof(freq_info), M_DEVBUF, M_NOWAIT);
+ table = mallocarray(count + 1, sizeof(freq_info), M_DEVBUF, M_NOWAIT);
if (table == NULL) {
error = ENOMEM;
goto out;

File Metadata

Mime Type
text/plain
Expires
Fri, Sep 11, 1:29 PM (22 h, 41 m)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
38707399
Default Alt Text
D13837.id37750.diff (56 KB)

Event Timeline