malloc 835 arch/i386/i386/bios.c hw_vendor = malloc(infolen, M_DEVBUF, M_NOWAIT);
malloc 852 arch/i386/i386/bios.c hw_prod = malloc(infolen, M_DEVBUF, M_NOWAIT);
malloc 864 arch/i386/i386/bios.c hw_ver = malloc(infolen, M_DEVBUF, M_NOWAIT);
malloc 874 arch/i386/i386/bios.c hw_serial = malloc(infolen, M_DEVBUF, M_NOWAIT);
malloc 897 arch/i386/i386/bios.c hw_uuid = malloc(SMBIOS_UUID_REPLEN, M_DEVBUF,
malloc 860 arch/i386/i386/esm.c es = malloc(sizeof(struct esm_sensor), M_DEVBUF, M_NOWAIT);
malloc 876 arch/i386/i386/esm.c s = malloc(sizeof(struct ksensor) * nsensors, M_DEVBUF,
malloc 895 arch/i386/i386/esm.c s = malloc(sizeof(struct ksensor) * nsensors, M_DEVBUF,
malloc 922 arch/i386/i386/esm.c s = malloc(sizeof(struct ksensor), M_DEVBUF, M_NOWAIT);
malloc 555 arch/i386/i386/i686_mem.c sc->mr_desc = malloc(nmdesc * sizeof(struct mem_range_desc),
malloc 340 arch/i386/i386/ioapic.c sc->sc_pins = malloc(sizeof(struct ioapic_pin) * sc->sc_apic_sz,
malloc 648 arch/i386/i386/ioapic.c ih = malloc(sizeof *ih, M_DEVBUF, cold ? M_NOWAIT : M_WAITOK);
malloc 104 arch/i386/i386/k6_mem.c sc->mr_desc = malloc(sc->mr_ndesc * sizeof(struct mem_range_desc),
malloc 3669 arch/i386/i386/machdep.c if ((mapstore = malloc(mapsize, M_DEVBUF,
malloc 187 arch/i386/i386/mem.c malloc(PAGE_SIZE, M_TEMP, M_WAITOK);
malloc 297 arch/i386/i386/mem.c malloc(nd * sizeof(struct mem_range_desc),
malloc 311 arch/i386/i386/mem.c md = malloc(sizeof(struct mem_range_desc), M_MEMDESC, M_WAITOK);
malloc 621 arch/i386/i386/mpbios.c mp_busses = malloc(sizeof(struct mp_bus) * mp_nbus,
malloc 624 arch/i386/i386/mpbios.c mp_intrs = malloc(sizeof(struct mp_intr_map) * intr_cnt,
malloc 405 arch/i386/i386/powernow-k7.c cstate = malloc(sizeof(struct k7pnow_cpu_state), M_DEVBUF, M_NOWAIT);
malloc 458 arch/i386/i386/powernow-k8.c cstate = malloc(sizeof(struct k8pnow_cpu_state), M_DEVBUF, M_NOWAIT);
malloc 115 arch/i386/i386/sys_machdep.c cp = malloc(ua.num * sizeof(union descriptor), M_TEMP, M_WAITOK);
malloc 177 arch/i386/i386/sys_machdep.c descv = malloc(sizeof (*descv) * ua.num, M_TEMP, M_NOWAIT);
malloc 110 arch/i386/i386/via.c if ((vc3_sc = malloc(sizeof(*vc3_sc), M_DEVBUF, M_NOWAIT)) == NULL)
malloc 145 arch/i386/i386/via.c ses = sc->sc_sessions = malloc(sizeof(*ses), M_DEVBUF,
malloc 161 arch/i386/i386/via.c ses = malloc((sesn + 1) * sizeof(*ses), M_DEVBUF,
malloc 241 arch/i386/i386/via.c swd->sw_ictx = malloc(axf->ctxsize, M_CRYPTO_DATA,
malloc 248 arch/i386/i386/via.c swd->sw_octx = malloc(axf->ctxsize, M_CRYPTO_DATA,
malloc 367 arch/i386/i386/via.c sc->op_buf = malloc(crd->crd_len, M_DEVBUF, M_NOWAIT);
malloc 311 arch/i386/isa/ahc_isa.c malloc(sizeof(struct ahc_isa_slot), M_DEVBUF, M_NOWAIT);
malloc 516 arch/i386/isa/isa_machdep.c ih = malloc(sizeof *ih, M_DEVBUF, cold ? M_NOWAIT : M_WAITOK);
malloc 712 arch/i386/isa/isa_machdep.c if ((cookiestore = malloc(cookiesize, M_DEVBUF,
malloc 116 arch/i386/pci/amd756.c ph = malloc(sizeof(*ph), M_DEVBUF, M_NOWAIT);
malloc 359 arch/i386/pci/glxsb.c ses = malloc((sesn + 1) * sizeof(*ses), M_DEVBUF, M_NOWAIT);
malloc 418 arch/i386/pci/glxsb.c swd->sw_ictx = malloc(axf->ctxsize, M_CRYPTO_DATA,
malloc 425 arch/i386/pci/glxsb.c swd->sw_octx = malloc(axf->ctxsize, M_CRYPTO_DATA,
malloc 133 arch/i386/pci/opti82c558.c ph = malloc(sizeof(*ph), M_DEVBUF, M_NOWAIT);
malloc 121 arch/i386/pci/opti82c700.c ph = malloc(sizeof(*ph), M_DEVBUF, M_NOWAIT);
malloc 309 arch/i386/pci/pci_intr_fixup.c if ((l = malloc(sizeof(*l), M_DEVBUF, M_NOWAIT)) == NULL)
malloc 296 arch/i386/pci/pcibios.c malloc(pirh->tablesize - sizeof(*pirh), M_DEVBUF, M_NOWAIT);
malloc 318 arch/i386/pci/pcibios.c pcibios_pir_table = malloc(pcibios_pir_table_nentries *
malloc 113 arch/i386/pci/piix.c ph = malloc(sizeof(*ph), M_DEVBUF, M_NOWAIT);
malloc 73 arch/i386/pci/rccosb4.c ph = malloc(sizeof(*ph), M_DEVBUF, M_NOWAIT);
malloc 149 arch/i386/pci/via8231.c ph = malloc(sizeof(*ph), M_DEVBUF, M_NOWAIT);
malloc 272 arch/i386/stand/installboot/installboot.c ph = malloc(phsize);
malloc 407 arch/i386/stand/installboot/installboot.c if ((buf = malloc(fs->fs_bsize)) == NULL)
malloc 77 compat/common/compat_dir.c buf = malloc(buflen, M_TEMP, M_WAITOK);
malloc 73 compat/common/compat_util.c buf = (char *) malloc(MAXPATHLEN, M_TEMP, M_WAITOK);
malloc 389 compat/common/vfs_syscalls_43.c dirbuf = (caddr_t)malloc(nbytes, M_TEMP, M_WAITOK);
malloc 844 compat/hpux/hpux_compat.c memp = (caddr_t)malloc((u_long)size, M_IOCTLOPS, M_WAITOK);
malloc 630 compat/ibcs2/ibcs2_exec.c xs = (struct xseg *)malloc(xep->xe_segsize, M_TEMP, M_WAITOK);
malloc 1155 compat/linux/linux_socket.c kosa = (struct osockaddr *) malloc(alloclen, M_TEMP, M_WAITOK);
malloc 108 compat/osf1/osf1_exec.c emul_arg = malloc(sizeof *emul_arg, M_TEMP, M_WAITOK);
malloc 100 compat/osf1/osf1_generic.c oio = malloc(osize, M_TEMP, M_WAITOK);
malloc 101 compat/osf1/osf1_generic.c nio = malloc(nsize, M_TEMP, M_WAITOK);
malloc 190 compat/osf1/osf1_generic.c oio = malloc(osize, M_TEMP, M_WAITOK);
malloc 191 compat/osf1/osf1_generic.c nio = malloc(nsize, M_TEMP, M_WAITOK);
malloc 222 compat/svr4/svr4_net.c st = malloc(sizeof(struct svr4_strm), M_NETADDR, M_WAITOK);
malloc 152 compat/svr4/svr4_socket.c e = malloc(sizeof(*e), M_TEMP, M_WAITOK);
malloc 531 compat/svr4/svr4_stat.c sut = malloc(sizeof(*sut), M_TEMP, M_WAITOK);
malloc 159 compat/svr4/svr4_stream.c ptr = (u_char *) malloc(len, M_TEMP, M_WAITOK);
malloc 196 compat/svr4/svr4_stream.c ptr = (u_char *)malloc(len, M_TEMP, M_WAITOK);
malloc 225 crypto/crypto.c crypto_drivers = malloc(crypto_drivers_num *
malloc 256 crypto/crypto.c newdrv = malloc(2 * crypto_drivers_num *
malloc 328 crypto/cryptodev.c cse->uio.uio_iov[0].iov_base = malloc(cop->len, M_XDATA, M_WAITOK);
malloc 531 crypto/cryptodev.c krp = malloc(sizeof *krp, M_XDATA, M_WAITOK);
malloc 551 crypto/cryptodev.c krp->krp_param[i].crp_p = malloc(size, M_XDATA, M_WAITOK);
malloc 556 crypto/cryptosoft.c swd = malloc(swcr_sesnum * sizeof(struct swcr_data *),
malloc 643 crypto/cryptosoft.c (*swd)->sw_ictx = malloc(axf->ctxsize, M_CRYPTO_DATA,
malloc 650 crypto/cryptosoft.c (*swd)->sw_octx = malloc(axf->ctxsize, M_CRYPTO_DATA,
malloc 687 crypto/cryptosoft.c (*swd)->sw_ictx = malloc(axf->ctxsize, M_CRYPTO_DATA,
malloc 695 crypto/cryptosoft.c (*swd)->sw_octx = malloc(cri->cri_klen / 8, M_CRYPTO_DATA,
malloc 718 crypto/cryptosoft.c (*swd)->sw_ictx = malloc(axf->ctxsize, M_CRYPTO_DATA,
malloc 171 crypto/deflate.c ptr = malloc(type *size, M_CRYPTO_DATA, M_NOWAIT);
malloc 71 crypto/skipjack.c u_int8_t * table = (u_int8_t *) malloc(0x100, M_CRYPTO_DATA,
malloc 377 dev/acpi/acpi.c sc->sc_note = malloc(sizeof(struct klist), M_DEVBUF, M_NOWAIT);
malloc 581 dev/acpi/acpi.c ac = malloc(sizeof(struct acpi_ac), M_DEVBUF, M_WAITOK);
malloc 587 dev/acpi/acpi.c bat = malloc(sizeof(struct acpi_bat), M_DEVBUF,
malloc 596 dev/acpi/acpi.c sc->sc_thread = malloc(sizeof(struct acpi_thread), M_DEVBUF, M_WAITOK);
malloc 719 dev/acpi/acpi.c entry = malloc(len + sizeof(struct acpi_q), M_DEVBUF, M_NOWAIT);
malloc 746 dev/acpi/acpi.c *dsdt = malloc(len + sizeof(struct acpi_q), M_DEVBUF, M_NOWAIT);
malloc 1059 dev/acpi/acpi.c sc->gpe_table = malloc(sc->sc_lastgpe * sizeof(struct gpe_block),
malloc 184 dev/acpi/acpicpu.c cx = malloc(sizeof(struct acpi_cstate), M_DEVBUF, M_WAITOK);
malloc 457 dev/acpi/acpicpu.c sc->sc_pss = malloc(res.length * sizeof *sc->sc_pss, M_DEVBUF,
malloc 512 dev/acpi/acpidebug.c tmpstr = malloc(16 * 6 + 1, M_DEVBUF, M_WAITOK);
malloc 288 dev/acpi/acpidock.c n = malloc(sizeof(struct aml_nodelist), M_DEVBUF, M_WAITOK);
malloc 216 dev/acpi/acpimadt.c mp_intrs = malloc(nlapic_nmis * sizeof (struct mp_intr_map), M_DEVBUF, M_NOWAIT);
malloc 240 dev/acpi/acpimadt.c map = malloc(sizeof (struct mp_intr_map), M_DEVBUF, M_NOWAIT);
malloc 296 dev/acpi/acpimadt.c map = malloc(sizeof (struct mp_intr_map), M_DEVBUF, M_NOWAIT);
malloc 217 dev/acpi/acpiprt.c map = malloc(sizeof (struct mp_intr_map), M_DEVBUF, M_NOWAIT);
malloc 422 dev/acpi/dsdt.c sptr = malloc(size+sizeof(*sptr), M_DEVBUF, M_WAITOK);
malloc 102 dev/ata/atascsi.c as = malloc(sizeof(struct atascsi), M_DEVBUF, M_WAITOK);
malloc 125 dev/ata/atascsi.c as->as_ports = malloc(sizeof(struct ata_port *) * aaa->aaa_nports,
malloc 171 dev/ata/atascsi.c ap = malloc(sizeof(struct ata_port), M_DEVBUF, M_WAITOK);
malloc 214 dev/ata/atascsi.c xa->data = malloc(512, M_TEMP, nosleep ? M_NOWAIT : M_WAITOK);
malloc 840 dev/ata/wd.c lp = malloc(sizeof(*lp), M_TEMP, M_WAITOK);
malloc 546 dev/audio.c r->start = malloc(bufsize, M_DEVBUF, M_WAITOK);
malloc 2914 dev/audio.c ma = malloc(sizeof (struct mixer_asyncs),
malloc 428 dev/cardbus/cardbus.c tuple = malloc(2048, M_TEMP, M_NOWAIT);
malloc 489 dev/cardbus/cardbus.c (cardbus_devfunc_t)malloc(sizeof(struct cardbus_devfunc),
malloc 134 dev/cardbus/cardbus_exrom.c image = malloc(sizeof(*image), M_DEVBUF, M_NOWAIT);
malloc 218 dev/cardbus/cardslot.c if ((ce = (struct cardslot_event *)malloc(sizeof(struct cardslot_event),
malloc 212 dev/cardbus/rbus.c if ((rb = (rbus_tag_t)malloc(sizeof(struct rbustag), M_DEVBUF,
malloc 241 dev/ccd.c ccd_softc = (struct ccd_softc *)malloc(num * sizeof(struct ccd_softc),
malloc 243 dev/ccd.c ccddevs = (struct ccddevice *)malloc(num * sizeof(struct ccddevice),
malloc 294 dev/ccd.c cs->sc_cinfo = malloc(cs->sc_nccdisks * sizeof(struct ccdcinfo),
malloc 323 dev/ccd.c ci->ci_path = malloc(ci->ci_pathlen, M_DEVBUF, M_WAITOK);
malloc 482 dev/ccd.c cs->sc_itable = (struct ccdiinfo *)malloc(size, M_DEVBUF, M_WAITOK);
malloc 495 dev/ccd.c ii->ii_index = malloc(sizeof(int), M_DEVBUF, M_WAITOK);
malloc 516 dev/ccd.c ii->ii_index = malloc((sizeof(int) * cs->sc_nccdisks),
malloc 730 dev/ccd.c cbpp = malloc(2 * cs->sc_nccdisks * sizeof(struct ccdbuf *), M_DEVBUF,
malloc 1073 dev/ccd.c cpp = malloc(ccio->ccio_ndisks * sizeof(char *),
malloc 1075 dev/ccd.c vpp = malloc(ccio->ccio_ndisks * sizeof(struct vnode *),
malloc 780 dev/eisa/aha1742.c ecb = (struct ahb_ecb *) malloc(sizeof(struct ahb_ecb),
malloc 45 dev/firmload.c path = malloc(MAXPATHLEN, M_TEMP, M_NOWAIT);
malloc 70 dev/firmload.c ptr = malloc(va.va_size, M_DEVBUF, M_NOWAIT);
malloc 356 dev/i2o/iop.c im = malloc(sizeof(*im) * sc->sc_maxib, M_DEVBUF, M_NOWAIT);
malloc 470 dev/i2o/iop.c iop_systab = malloc(i, M_DEVBUF, M_NOWAIT);
malloc 684 dev/i2o/iop.c sc->sc_tidmap = malloc(sc->sc_nlctent * sizeof(struct iop_tidmap),
malloc 1086 dev/i2o/iop.c hrt = (struct i2o_hrt *)malloc(size, M_DEVBUF, M_NOWAIT);
malloc 1152 dev/i2o/iop.c lct = (struct i2o_lct *)malloc(esize, M_DEVBUF, M_WAITOK);
malloc 1164 dev/i2o/iop.c lct = (struct i2o_lct *)malloc(size, M_DEVBUF, M_WAITOK);
malloc 1202 dev/i2o/iop.c if ((pgop = malloc(sizeof(*pgop), M_DEVBUF, M_WAITOK)) == NULL) {
malloc 1206 dev/i2o/iop.c if ((rf = malloc(sizeof(*rf), M_DEVBUF, M_WAITOK)) == NULL) {
malloc 2318 dev/i2o/iop.c sc->sc_ptb = malloc(IOP_MAX_XFER * IOP_MAX_MSG_XFERS, M_DEVBUF,
malloc 2438 dev/i2o/iop.c mf = malloc(IOP_MAX_MSG_SIZE, M_DEVBUF, M_WAITOK);
malloc 211 dev/i2o/iopsp.c sc->sc_targetmap = malloc(size, M_DEVBUF, M_NOWAIT);
malloc 263 dev/i2o/iopsp.c if (!(tidmap = malloc(size, M_DEVBUF, M_NOWAIT)))
malloc 424 dev/ic/aac.c co = (struct aac_container *)malloc(sizeof *co, M_DEVBUF,
malloc 1210 dev/ic/aac.c fm = malloc(sizeof(struct aac_fibmap), M_DEVBUF, M_NOWAIT);
malloc 1561 dev/ic/aac.c sc->aac_commands = malloc(AAC_MAX_FIBS * sizeof(struct aac_command),
malloc 717 dev/ic/ac97.c if (!(as = malloc(sizeof(struct ac97_softc), M_DEVBUF, M_NOWAIT)))
malloc 1711 dev/ic/acx.c wn = malloc(sizeof(struct acx_node), M_DEVBUF, M_NOWAIT);
malloc 221 dev/ic/adw.c malloc(sizeof(ADW_CARRIER) * ADW_MAX_CARRIER, M_DEVBUF,
malloc 2821 dev/ic/aic79xx.c tstate = malloc(sizeof(*tstate), M_DEVBUF, M_NOWAIT);
malloc 5263 dev/ic/aic79xx.c ahd->seep_config = malloc(sizeof(*ahd->seep_config),
malloc 5986 dev/ic/aic79xx.c hscb_map = malloc(sizeof(*hscb_map), M_DEVBUF, M_NOWAIT);
malloc 6016 dev/ic/aic79xx.c sg_map = malloc(sizeof(*sg_map), M_DEVBUF, M_NOWAIT);
malloc 6050 dev/ic/aic79xx.c sense_map = malloc(sizeof(*sense_map), M_DEVBUF, M_NOWAIT);
malloc 6088 dev/ic/aic79xx.c next_scb = (struct scb *)malloc(sizeof(*next_scb),
malloc 6094 dev/ic/aic79xx.c pdata = malloc(sizeof(*pdata), M_DEVBUF, M_NOWAIT);
malloc 6193 dev/ic/aic79xx.c ahd->saved_stack = malloc(ahd->stack_size * sizeof(uint16_t),
malloc 8608 dev/ic/aic79xx.c ahd->critical_sections = malloc(cs_count, M_DEVBUF, M_NOWAIT);
malloc 9611 dev/ic/aic79xx.c lstate = malloc(sizeof(*lstate), M_DEVBUF, M_NOWAIT);
malloc 611 dev/ic/aic79xx_openbsd.c ahd->platform_data = malloc(sizeof(struct ahd_platform_data),
malloc 1647 dev/ic/aic7xxx.c tstate = (struct ahc_tmode_tstate*)malloc(sizeof(*tstate),
malloc 3892 dev/ic/aic7xxx.c ahc->scb_data = malloc(sizeof(*ahc->scb_data),
malloc 4257 dev/ic/aic7xxx.c (struct scb *)malloc(sizeof(struct scb) * AHC_SCB_MAX_ALLOC,
malloc 4394 dev/ic/aic7xxx.c sg_map = malloc(sizeof(*sg_map), M_DEVBUF, M_NOWAIT);
malloc 4422 dev/ic/aic7xxx.c malloc(sizeof(*pdata), M_DEVBUF, M_NOWAIT);
malloc 6261 dev/ic/aic7xxx.c ahc->critical_sections = malloc(cs_count, M_DEVBUF, M_NOWAIT);
malloc 6880 dev/ic/aic7xxx.c lstate = malloc(sizeof(*lstate), M_DEVBUF, M_NOWAIT);
malloc 701 dev/ic/aic7xxx_openbsd.c ahc->platform_data = malloc(sizeof(struct ahc_platform_data),
malloc 236 dev/ic/ami.c am = malloc(sizeof(struct ami_mem), M_DEVBUF, M_NOWAIT);
malloc 306 dev/ic/ami.c sc->sc_ccbs = malloc(sizeof(struct ami_ccb) * nccbs,
malloc 567 dev/ic/ami.c rsc = malloc(sizeof(struct ami_rawsoftc) * sc->sc_channels,
malloc 1872 dev/ic/ami.c p = malloc(sizeof *p, M_DEVBUF, M_NOWAIT);
malloc 1876 dev/ic/ami.c plist = malloc(AMI_BIG_MAX_PDRIVES, M_DEVBUF, M_NOWAIT);
malloc 1953 dev/ic/ami.c plist = malloc(AMI_BIG_MAX_PDRIVES, M_DEVBUF, M_NOWAIT);
malloc 2028 dev/ic/ami.c plist = malloc(AMI_BIG_MAX_PDRIVES, M_DEVBUF, M_NOWAIT);
malloc 2128 dev/ic/ami.c p = malloc(sizeof *p, M_DEVBUF, M_NOWAIT);
malloc 2251 dev/ic/ami.c p = malloc(sizeof *p, M_DEVBUF, M_NOWAIT);
malloc 2449 dev/ic/ami.c sc->sc_sensors = malloc(sizeof(struct ksensor) * sc->sc_nunits,
malloc 2473 dev/ic/ami.c sc->sc_bd = malloc(sizeof(*sc->sc_bd), M_DEVBUF, M_WAITOK);
malloc 176 dev/ic/ar5xxx.c if ((hal = malloc(sizeof(struct ath_hal),
malloc 399 dev/ic/ar5xxx.c if ((all_channels = malloc(sizeof(HAL_CHANNEL) * max_channels,
malloc 1500 dev/ic/ar5xxx.c if ((hal->ah_rf_banks = malloc(hal->ah_rf_banks_size,
malloc 1616 dev/ic/ath.c bf = malloc(bsize, M_DEVBUF, M_NOWAIT);
malloc 1732 dev/ic/ath.c malloc(sizeof(struct ath_node), M_DEVBUF, M_NOWAIT);
malloc 3033 dev/ic/ath.c chans = malloc(IEEE80211_CHAN_MAX * sizeof(HAL_CHANNEL),
malloc 419 dev/ic/atw.c sc->sc_srom = malloc(sc->sc_sromsz, M_DEVBUF, M_NOWAIT);
malloc 1960 dev/ic/awi.c bp = malloc(sizeof(struct awi_bss), M_DEVBUF, M_NOWAIT);
malloc 275 dev/ic/awi_wep.c sc->sc_wep_ctx = malloc(ctxlen, M_DEVBUF, M_NOWAIT);
malloc 216 dev/ic/bt463.c data = malloc(sizeof *data, M_DEVBUF, M_WAITOK);
malloc 160 dev/ic/bt485.c data = malloc(sizeof *data, M_DEVBUF, M_WAITOK);
malloc 227 dev/ic/cac.c sc->sc_dinfos = malloc(cinfo.num_drvs * sizeof(struct cac_drive_info),
malloc 352 dev/ic/ciss.c if (!(sc->sc_lds = malloc(sc->maxunits * sizeof(*sc->sc_lds),
malloc 424 dev/ic/ciss.c sc->sensors = malloc(sizeof(struct ksensor) * sc->maxunits,
malloc 1335 dev/ic/ciss.c ldp = malloc(sizeof(*ldp) + (k-1), M_DEVBUF, M_NOWAIT);
malloc 333 dev/ic/cy.c cy->cy_ibuf = malloc(IBUF_SIZE, M_DEVBUF, M_NOWAIT);
malloc 1478 dev/ic/dc.c m = malloc(sizeof(struct dc_mediainfo), M_DEVBUF, M_NOWAIT);
malloc 1527 dev/ic/dc.c m = malloc(sizeof(struct dc_mediainfo), M_DEVBUF, M_NOWAIT);
malloc 1554 dev/ic/dc.c m = malloc(sizeof(struct dc_mediainfo), M_DEVBUF, M_NOWAIT);
malloc 1582 dev/ic/dc.c sc->dc_srom = malloc(size, M_DEVBUF, M_NOWAIT);
malloc 493 dev/ic/gdt_common.c gdt->sc_raw_link = malloc(gdt->sc_bus_cnt * sizeof (struct scsi_link),
malloc 764 dev/ic/i82365.c pe = malloc(sizeof(*pe), M_TEMP, M_NOWAIT);
malloc 327 dev/ic/i82596.c padbuf = malloc(ETHER_MIN_LEN - ETHER_CRC_LEN, M_DEVBUF,
malloc 1998 dev/ic/i82596.c malloc(size, M_IFMADDR, M_WAITOK);
malloc 162 dev/ic/ibm561.c data = malloc(sizeof *data, M_DEVBUF, M_WAITOK);
malloc 1647 dev/ic/if_wi.c wreq = malloc(sizeof *wreq, M_DEVBUF, M_WAITOK);
malloc 1705 dev/ic/if_wi.c wreq = malloc(sizeof *wreq, M_DEVBUF, M_WAITOK);
malloc 1773 dev/ic/if_wi.c wreq = malloc(sizeof *wreq, M_DEVBUF, M_WAITOK);
malloc 1790 dev/ic/if_wi.c wreq = malloc(sizeof *wreq, M_DEVBUF, M_WAITOK);
malloc 1803 dev/ic/if_wi.c wreq = malloc(sizeof *wreq, M_DEVBUF, M_WAITOK);
malloc 1811 dev/ic/if_wi.c nwidp = malloc(sizeof *nwidp, M_DEVBUF, M_WAITOK);
malloc 1823 dev/ic/if_wi.c nwidp = malloc(sizeof *nwidp, M_DEVBUF, M_WAITOK);
malloc 1871 dev/ic/if_wi.c wreq = malloc(sizeof *wreq, M_DEVBUF, M_WAITOK);
malloc 1881 dev/ic/if_wi.c wreq = malloc(sizeof *wreq, M_DEVBUF, M_WAITOK);
malloc 1894 dev/ic/if_wi.c wreq = malloc(sizeof *wreq, M_DEVBUF, M_WAITOK);
malloc 1917 dev/ic/if_wi.c wreq = malloc(sizeof *wreq, M_DEVBUF, M_WAITOK);
malloc 1954 dev/ic/if_wi.c wreq = malloc(sizeof *wreq, M_DEVBUF, M_WAITOK);
malloc 1981 dev/ic/if_wi.c nr = malloc(sizeof *nr, M_DEVBUF, M_WAITOK);
malloc 2029 dev/ic/if_wi.c wreq = malloc(sizeof *wreq, M_DEVBUF, M_WAITOK);
malloc 601 dev/ic/malo.c ring->data = malloc(count * sizeof (struct malo_rx_data), M_DEVBUF,
malloc 761 dev/ic/malo.c ring->data = malloc(count * sizeof(struct malo_tx_data), M_DEVBUF,
malloc 1215 dev/ic/malo.c wn = malloc(sizeof(struct malo_node), M_DEVBUF, M_NOWAIT);
malloc 164 dev/ic/mfi.c sc->sc_ccb = malloc(sizeof(struct mfi_ccb) * sc->sc_max_cmds,
malloc 253 dev/ic/mfi.c mm = malloc(sizeof(struct mfi_mem), M_DEVBUF, M_NOWAIT);
malloc 1284 dev/ic/mfi.c cfg = malloc(sizeof *cfg, M_DEVBUF, M_WAITOK);
malloc 1402 dev/ic/mfi.c pd = malloc(sizeof *pd, M_DEVBUF, M_WAITOK);
malloc 1405 dev/ic/mfi.c cfg = malloc(sizeof *cfg, M_DEVBUF, M_WAITOK);
malloc 1413 dev/ic/mfi.c cfg = malloc(size, M_DEVBUF, M_WAITOK);
malloc 1564 dev/ic/mfi.c pd = malloc(MFI_PD_LIST_SIZE, M_DEVBUF, M_WAITOK);
malloc 1621 dev/ic/mfi.c pd = malloc(MFI_PD_LIST_SIZE, M_DEVBUF, M_WAITOK);
malloc 1696 dev/ic/mfi.c pd = malloc(sizeof *pd, M_DEVBUF, M_WAITOK);
malloc 1699 dev/ic/mfi.c cfg = malloc(sizeof *cfg, M_DEVBUF, M_WAITOK);
malloc 1707 dev/ic/mfi.c cfg = malloc(size, M_DEVBUF, M_WAITOK);
malloc 1796 dev/ic/mfi.c sc->sc_sensors = malloc(sizeof(struct ksensor) * sc->sc_ld_cnt,
malloc 111 dev/ic/mk48txx.c handle = malloc(sz, M_DEVBUF, M_NOWAIT);
malloc 344 dev/ic/mpi.c physdisk_pg = malloc(pagelen, M_TEMP, M_WAITOK|M_CANFAIL);
malloc 736 dev/ic/mpi.c mdm = malloc(sizeof(struct mpi_dmamem), M_DEVBUF, M_NOWAIT);
malloc 800 dev/ic/mpi.c sc->sc_ccbs = malloc(sizeof(struct mpi_ccb) * sc->sc_maxcmds,
malloc 894 dev/ic/mpi.c sc->sc_rcbs = malloc(MPI_REPLY_COUNT * sizeof(struct mpi_rcb),
malloc 2154 dev/ic/mpi.c vol_page = malloc(pagelen, M_TEMP, M_WAITOK|M_CANFAIL);
malloc 204 dev/ic/ncr53c9x.c sc->sc_omess = malloc(NCR_MAX_MSG_LEN, M_DEVBUF, M_NOWAIT);
malloc 207 dev/ic/ncr53c9x.c sc->sc_imess = malloc(NCR_MAX_MSG_LEN+1, M_DEVBUF, M_NOWAIT);
malloc 813 dev/ic/ncr53c9x.c if ((li = malloc(sizeof(*li), M_DEVBUF, M_NOWAIT)) == NULL) {
malloc 952 dev/ic/ncr53c9x.c if ((li = malloc(sizeof(*li), M_DEVBUF, M_NOWAIT)) == NULL) {
malloc 273 dev/ic/oosiop.c cb = malloc(sizeof(struct oosiop_cb) * ncb, M_DEVBUF, M_NOWAIT);
malloc 280 dev/ic/osiop.c acb = malloc(sizeof(struct osiop_acb) * OSIOP_NACB,
malloc 277 dev/ic/pckbc.c t->t_slotdata[slot] = malloc(sizeof(struct pckbc_slotdata),
malloc 91 dev/ic/pdqvar.h #define PDQ_OS_MEMALLOC(n) malloc(n, M_DEVBUF, M_NOWAIT)
malloc 1815 dev/ic/pgt.c pin = malloc(sizeof(*pin), M_DEVBUF, M_NOWAIT);
malloc 1905 dev/ic/pgt.c freqs = malloc(j, M_DEVBUF, M_WAITOK);
malloc 2287 dev/ic/pgt.c wreq = malloc(sizeof(*wreq), M_DEVBUF, M_WAITOK);
malloc 2291 dev/ic/pgt.c pob = malloc(sizeof(*pob) +
malloc 2322 dev/ic/pgt.c nr = malloc(sizeof(*nr), M_DEVBUF, M_WAITOK);
malloc 3201 dev/ic/pgt.c pd = malloc(sizeof(*pd), M_DEVBUF, M_WAITOK);
malloc 388 dev/ic/rt2560.c ring->data = malloc(count * sizeof (struct rt2560_tx_data), M_DEVBUF,
malloc 534 dev/ic/rt2560.c ring->data = malloc(count * sizeof (struct rt2560_rx_data), M_DEVBUF,
malloc 650 dev/ic/rt2560.c rn = malloc(sizeof (struct rt2560_node), M_DEVBUF, M_NOWAIT);
malloc 421 dev/ic/rt2661.c ring->data = malloc(count * sizeof (struct rt2661_tx_data), M_DEVBUF,
malloc 564 dev/ic/rt2661.c ring->data = malloc(count * sizeof (struct rt2661_rx_data), M_DEVBUF,
malloc 677 dev/ic/rt2661.c rn = malloc(sizeof (struct rt2661_node), M_DEVBUF, M_NOWAIT);
malloc 667 dev/ic/rtw.c sr->sr_content = malloc(sr->sr_size, M_DEVBUF, M_NOWAIT);
malloc 3705 dev/ic/rtw.c tsb->tsb_desc = malloc(qlen * sizeof(*tsb->tsb_desc), M_DEVBUF,
malloc 404 dev/ic/sili.c sc->sc_ports = malloc(sizeof(struct sili_port) * sc->sc_nports,
malloc 463 dev/ic/sili.c sp->sp_ccbs = malloc(sizeof(struct sili_ccb) * SILI_MAX_CMDS,
malloc 559 dev/ic/sili.c sdm = malloc(sizeof(struct sili_dmamem), M_DEVBUF, M_WAITOK);
malloc 1396 dev/ic/siop.c malloc(sizeof(struct siop_target),
malloc 1429 dev/ic/siop.c malloc(sizeof(struct siop_lun), M_DEVBUF,
malloc 1797 dev/ic/siop.c newcbd = malloc(sizeof(struct siop_cbd), M_DEVBUF, M_NOWAIT);
malloc 1806 dev/ic/siop.c newcbd->cmds = malloc(sizeof(struct siop_cmd) * SIOP_NCMDPB,
malloc 1961 dev/ic/siop.c lunsw = malloc(sizeof(struct siop_lunsw), M_DEVBUF, M_NOWAIT);
malloc 135 dev/ic/sti.c scr = malloc(sizeof(struct sti_screen), M_DEVBUF, M_NOWAIT);
malloc 334 dev/ic/sti.c malloc(dd->dd_stimemreq, M_DEVBUF, M_NOWAIT);
malloc 605 dev/ic/sti.c scr->scr_romfont = malloc(size, M_DEVBUF, M_NOWAIT);
malloc 710 dev/ic/tcic2.c pe = malloc(sizeof(*pe), M_TEMP, M_NOWAIT);
malloc 2427 dev/ic/trm.c pDCB = (struct trm_dcb *)malloc(sizeof(struct trm_dcb), M_DEVBUF, M_NOWAIT);
malloc 242 dev/ic/uha.c mscp = (struct uha_mscp *) malloc(sizeof(struct uha_mscp),
malloc 532 dev/ic/vga.c vc = malloc(sizeof(struct vga_config), M_DEVBUF, M_NOWAIT);
malloc 669 dev/ic/vga.c malloc(type->ncols * type->nrows * 2, M_DEVBUF, M_WAITOK);
malloc 672 dev/ic/vga.c scr = malloc(sizeof(struct vgascreen), M_DEVBUF, M_WAITOK);
malloc 680 dev/ic/vga.c scr->pcs.mem = malloc(type->ncols * type->nrows * 2,
malloc 890 dev/ic/vga.c f = malloc(sizeof(struct vgafont), M_DEVBUF, M_WAITOK);
malloc 180 dev/ic/wdc.c wdc_log_buf = malloc(wdc_log_cap, M_DEVBUF, M_NOWAIT);
malloc 264 dev/ic/wdc.c retbuf = malloc(tocopy, M_TEMP, M_NOWAIT);
malloc 2122 dev/ic/wdc.c wi = malloc(sizeof(struct wdc_ioctl), M_TEMP, M_WAITOK);
malloc 266 dev/ic/z8530tty.c zst->zst_rbuf = malloc(zstty_rbuf_size * sizeof(zst->zst_rbuf[0]),
malloc 950 dev/ipmi.c buf = malloc(*txlen, M_DEVBUF, M_NOWAIT|M_CANFAIL);
malloc 979 dev/ipmi.c buf = malloc(*txlen, M_DEVBUF, M_NOWAIT|M_CANFAIL);
malloc 1046 dev/ipmi.c buf = malloc(maxlen + 3, M_DEVBUF, M_NOWAIT|M_CANFAIL);
malloc 1145 dev/ipmi.c psdr = malloc(sdrlen, M_DEVBUF, M_NOWAIT|M_CANFAIL);
malloc 1487 dev/ipmi.c psensor = malloc(sizeof(struct ipmi_sensor), M_DEVBUF,
malloc 1711 dev/ipmi.c sc->sc_thread = malloc(sizeof(struct ipmi_thread), M_DEVBUF,
malloc 520 dev/isa/ega.c dc = malloc(sizeof(struct ega_config),
malloc 626 dev/isa/ega.c malloc(type->ncols * type->nrows * 2, M_DEVBUF, M_WAITOK);
malloc 629 dev/isa/ega.c scr = malloc(sizeof(struct egascreen), M_DEVBUF, M_WAITOK);
malloc 637 dev/isa/ega.c scr->pcs.mem = malloc(type->ncols * type->nrows * 2,
malloc 843 dev/isa/ega.c f = malloc(sizeof(struct egafont), M_DEVBUF, M_WAITOK);
malloc 85 dev/isa/elink.c er = (struct elink_done_reset *)malloc(sizeof(struct elink_done_reset),
malloc 1061 dev/isa/fd.c bp = (struct buf *)malloc(sizeof(struct buf), M_TEMP, M_NOWAIT);
malloc 1630 dev/isa/gus.c sc->sc_deintr_buf = malloc(blocksize/2, M_DEVBUF, M_WAITOK);
malloc 485 dev/isa/if_eg.c sc->eg_inbuf = malloc(EG_BUFLEN, M_TEMP, M_NOWAIT);
malloc 489 dev/isa/if_eg.c sc->eg_outbuf = malloc(EG_BUFLEN, M_TEMP, M_NOWAIT);
malloc 171 dev/isa/if_ep_isa.c malloc(sizeof(struct ep_isa_done_probe), M_DEVBUF, M_NOWAIT);
malloc 337 dev/isa/if_le_isa.c sc->sc_mem = malloc(16384, M_DEVBUF, M_NOWAIT);
malloc 104 dev/isa/if_le_isapnp.c sc->sc_mem = malloc(16384, M_DEVBUF, M_NOWAIT);
malloc 695 dev/isa/isadma.c m = malloc(sizeof(*m), pool, flags);
malloc 165 dev/isa/isavar.h # define ISAPNP_MALLOC(a) malloc(a, M_DEVBUF, M_WAITOK)
malloc 631 dev/isa/mcd.c lp = malloc(sizeof(*lp), M_TEMP, M_WAITOK);
malloc 275 dev/isa/pcdisplay.c dc = malloc(sizeof(struct pcdisplay_config),
malloc 151 dev/isa/pckbc_isa.c t = malloc(sizeof(struct pckbc_internal), M_DEVBUF, M_WAITOK);
malloc 627 dev/isa/seagate.c scb = (struct sea_scb *) malloc(sizeof(struct sea_scb),
malloc 433 dev/isa/spkr.c spkr_inbuf = malloc(DEV_BSIZE, M_DEVBUF, M_WAITOK);
malloc 174 dev/isa/wdc_isa.c sc->wdc_channel.ch_queue = malloc(sizeof(struct channel_queue),
malloc 145 dev/isa/wdc_isapnp.c sc->wdc_channel.ch_queue = malloc(sizeof(struct channel_queue),
malloc 561 dev/isa/wds.c scb = (struct wds_scb *) malloc(sizeof(struct wds_scb),
malloc 135 dev/ksyms.c ksym_head = malloc(ksym_head_size, M_DEVBUF, M_NOWAIT);
malloc 233 dev/microcode/aic7xxx/aicasm.c (path_entry_t)malloc(sizeof(*include_dir));
malloc 504 dev/microcode/aic7xxx/aicasm.c new_patch = (patch_t *)malloc(sizeof(*new_patch));
malloc 557 dev/microcode/aic7xxx/aicasm.c func_values = (int *)malloc(func_count * sizeof(int));
malloc 741 dev/microcode/aic7xxx/aicasm.c new_instr = (struct instruction *)malloc(sizeof(struct instruction));
malloc 755 dev/microcode/aic7xxx/aicasm.c new_cs= (critical_section_t *)malloc(sizeof(critical_section_t));
malloc 769 dev/microcode/aic7xxx/aicasm.c new_scope = (scope_t *)malloc(sizeof(scope_t));
malloc 1442 dev/microcode/aic7xxx/aicasm_gram.y (struct reg_info *)malloc(sizeof(struct reg_info));
malloc 1463 dev/microcode/aic7xxx/aicasm_gram.y (struct alias_info *)malloc(sizeof(struct alias_info));
malloc 1476 dev/microcode/aic7xxx/aicasm_gram.y (struct field_info *)malloc(sizeof(struct field_info));
malloc 1487 dev/microcode/aic7xxx/aicasm_gram.y (struct const_info *)malloc(sizeof(struct const_info));
malloc 1497 dev/microcode/aic7xxx/aicasm_gram.y (struct label_info *)malloc(sizeof(struct label_info));
malloc 1507 dev/microcode/aic7xxx/aicasm_gram.y (struct cond_info *)malloc(sizeof(struct cond_info));
malloc 1517 dev/microcode/aic7xxx/aicasm_gram.y (struct macro_info *)malloc(sizeof(struct macro_info));
malloc 1548 dev/microcode/aic7xxx/aicasm_gram.y marg = (struct macro_arg *)malloc(sizeof(*marg));
malloc 74 dev/microcode/aic7xxx/aicasm_symbol.c new_symbol = (symbol_t *)malloc(sizeof(symbol_t));
malloc 227 dev/microcode/aic7xxx/aicasm_symbol.c newnode = (symbol_node_t *)malloc(sizeof(symbol_node_t));
malloc 85 dev/microcode/bnx/build.c bf = (struct bnx_firmware_header *)malloc(sizeof *bf);
malloc 41 dev/microcode/kue/build.c kf = (struct kue_firmware *)malloc(len);
malloc 419 dev/microcode/ncr53cxxx/ncr53cxxx.c tokens[ntokens].name = malloc (len);
malloc 499 dev/microcode/ncr53cxxx/ncr53cxxx.c symbols[nsymbols].name = malloc (len);
malloc 534 dev/microcode/ncr53cxxx/ncr53cxxx.c script_name = malloc (len);
malloc 669 dev/microcode/ncr53cxxx/ncr53cxxx.c p->next = (struct patchlist *) malloc (sizeof (struct patchlist));
malloc 684 dev/microcode/ncr53cxxx/ncr53cxxx.c p = (struct patchlist *) malloc (sizeof (struct patchlist));
malloc 689 dev/microcode/ncr53cxxx/ncr53cxxx.c symbols[nsymbols].name = malloc (len);
malloc 1151 dev/microcode/ncr53cxxx/ncr53cxxx.c fn = malloc (len);
malloc 586 dev/microcode/siop/ncr53cxxx.c tokens[ntokens].name = malloc (len);
malloc 666 dev/microcode/siop/ncr53cxxx.c symbols[nsymbols].name = malloc (len);
malloc 678 dev/microcode/siop/ncr53cxxx.c p = (struct patchlist *) malloc (sizeof (struct patchlist));
malloc 715 dev/microcode/siop/ncr53cxxx.c script_name = malloc (len);
malloc 846 dev/microcode/siop/ncr53cxxx.c p->next = (struct patchlist *) malloc (sizeof (struct patchlist));
malloc 861 dev/microcode/siop/ncr53cxxx.c p = (struct patchlist *) malloc (sizeof (struct patchlist));
malloc 866 dev/microcode/siop/ncr53cxxx.c symbols[nsymbols].name = malloc (len);
malloc 1491 dev/microcode/siop/ncr53cxxx.c fn = malloc (len);
malloc 45 dev/microcode/tigon/build.c tf = (struct tigon_firmware *)malloc(len);
malloc 50 dev/microcode/yds/build.c yf = (struct yds_firmware *)malloc(len);
malloc 182 dev/midisyn.c ms->voices = malloc(ms->nvoice * sizeof (struct voice),
malloc 375 dev/pci/agp.c gatt = malloc(sizeof(*gatt), M_DEVBUF, M_NOWAIT);
malloc 477 dev/pci/agp.c mem = malloc(sizeof *mem, M_DEVBUF, M_WAITOK);
malloc 544 dev/pci/agp.c segs = malloc(nseg * sizeof *segs, M_DEVBUF, M_WAITOK);
malloc 85 dev/pci/agp_ali.c asc = malloc(sizeof *asc, M_DEVBUF, M_NOWAIT);
malloc 107 dev/pci/agp_amd.c gatt = malloc(sizeof(struct agp_amd_gatt), M_DEVBUF, M_NOWAIT);
malloc 165 dev/pci/agp_amd.c asc = malloc(sizeof *asc, M_DEVBUF, M_NOWAIT);
malloc 119 dev/pci/agp_i810.c isc = malloc(sizeof *isc, M_DEVBUF, M_NOWAIT);
malloc 196 dev/pci/agp_i810.c gatt = malloc(sizeof(struct agp_gatt), M_DEVBUF, M_NOWAIT);
malloc 683 dev/pci/agp_i810.c mem = malloc(sizeof *mem, M_DEVBUF, M_WAITOK);
malloc 694 dev/pci/agp_i810.c mem->am_dmaseg = malloc(sizeof *mem->am_dmaseg, M_DEVBUF,
malloc 85 dev/pci/agp_intel.c isc = malloc(sizeof *isc, M_DEVBUF, M_NOWAIT);
malloc 84 dev/pci/agp_sis.c ssc = malloc(sizeof *ssc, M_DEVBUF, M_NOWAIT);
malloc 83 dev/pci/agp_via.c asc = malloc(sizeof *asc, M_DEVBUF, M_NOWAIT);
malloc 758 dev/pci/ahc_pci.c bd = malloc(sizeof (struct ahc_pci_busdata), M_DEVBUF, M_NOWAIT);
malloc 970 dev/pci/ahc_pci.c ahc->seep_config = malloc(sizeof(*ahc->seep_config),
malloc 827 dev/pci/ahci.c ap = malloc(sizeof(struct ahci_port), M_DEVBUF, M_NOWAIT);
malloc 901 dev/pci/ahci.c ap->ap_ccbs = malloc(sizeof(struct ahci_ccb) * sc->sc_ncmds, M_DEVBUF,
malloc 2033 dev/pci/ahci.c adm = malloc(sizeof(struct ahci_dmamem), M_DEVBUF, M_NOWAIT);
malloc 1059 dev/pci/arc.c sysinfo = malloc(sizeof(struct arc_fw_sysinfo), M_TEMP, M_WAITOK);
malloc 1088 dev/pci/arc.c sysinfo = malloc(sizeof(struct arc_fw_sysinfo), M_TEMP, M_WAITOK);
malloc 1089 dev/pci/arc.c volinfo = malloc(sizeof(struct arc_fw_volinfo), M_TEMP, M_WAITOK);
malloc 1136 dev/pci/arc.c sysinfo = malloc(sizeof(struct arc_fw_sysinfo), M_TEMP, M_WAITOK);
malloc 1186 dev/pci/arc.c volinfo = malloc(sizeof(struct arc_fw_volinfo), M_TEMP, M_WAITOK);
malloc 1268 dev/pci/arc.c volinfo = malloc(sizeof(struct arc_fw_volinfo), M_TEMP, M_WAITOK);
malloc 1269 dev/pci/arc.c raidinfo = malloc(sizeof(struct arc_fw_raidinfo), M_TEMP, M_WAITOK);
malloc 1270 dev/pci/arc.c diskinfo = malloc(sizeof(struct arc_fw_diskinfo), M_TEMP, M_WAITOK);
malloc 1381 dev/pci/arc.c wbuf = malloc(wlen, M_TEMP, M_WAITOK);
malloc 1384 dev/pci/arc.c rbuf = malloc(rlen, M_TEMP, M_WAITOK);
malloc 1552 dev/pci/arc.c sc->sc_sensors = malloc(sizeof(struct ksensor) * sc->sc_nsensors,
malloc 1727 dev/pci/arc.c adm = malloc(sizeof(struct arc_dmamem), M_DEVBUF, M_NOWAIT);
malloc 1785 dev/pci/arc.c sc->sc_ccbs = malloc(sizeof(struct arc_ccb) * sc->sc_req_count,
malloc 1069 dev/pci/auich.c p = malloc(sizeof(*p), pool, flags);
malloc 614 dev/pci/auixp.c dma = malloc(sizeof(*dma), pool, flags);
malloc 784 dev/pci/auixp.c dma = malloc(sizeof(*dma), M_DEVBUF, M_NOWAIT);
malloc 1304 dev/pci/auixp.c sc->savemem = (u_int16_t *)malloc(len, M_DEVBUF, M_NOWAIT | M_ZERO);
malloc 1177 dev/pci/autri.c p = malloc(sizeof(*p), pool, flags);
malloc 708 dev/pci/auvia.c p = malloc(sizeof(*p), pool, flags);
malloc 790 dev/pci/azalia.c az->unsolq = malloc(sizeof(rirb_entry_t) * UNSOLQ_SIZE,
malloc 1137 dev/pci/azalia.c this->w = malloc(sizeof(widget_t) * this->wend, M_DEVBUF, M_NOWAIT);
malloc 1274 dev/pci/azalia.c this->formats = malloc(sizeof(struct audio_format) *
malloc 1683 dev/pci/azalia.c this->connections = malloc(sizeof(nid_t) * (length + 3),
malloc 394 dev/pci/azalia_codec.c this->mixers = malloc(sizeof(mixer_item_t) * this->maxmixers,
malloc 769 dev/pci/azalia_codec.c newbuf = malloc(sizeof(mixer_item_t) * newmax, M_DEVBUF, M_NOWAIT);
malloc 1577 dev/pci/azalia_codec.c this->mixers = malloc(sizeof(mixer_item_t) * this->nmixers,
malloc 1828 dev/pci/azalia_codec.c this->mixers = malloc(sizeof(mixer_item_t) * this->nmixers,
malloc 2094 dev/pci/azalia_codec.c this->mixers = malloc(sizeof(mixer_item_t) * this->nmixers,
malloc 2248 dev/pci/azalia_codec.c this->mixers = malloc(sizeof(mixer_item_t) * this->nmixers,
malloc 2379 dev/pci/azalia_codec.c this->mixers = malloc(sizeof(mixer_item_t) * this->nmixers,
malloc 2498 dev/pci/azalia_codec.c this->mixers = malloc(sizeof(mixer_item_t) * this->nmixers,
malloc 2626 dev/pci/azalia_codec.c this->mixers = malloc(sizeof(mixer_item_t) * this->nmixers,
malloc 1112 dev/pci/cmpci.c n = malloc(sizeof(struct cmpci_dmanode), type, flags);
malloc 1422 dev/pci/cs4280.c q = malloc(size, pool, flags);
malloc 1425 dev/pci/cs4280.c p = malloc(sizeof(*p), pool, flags);
malloc 1359 dev/pci/cs4281.c p = malloc(sizeof(*p), pool, flags);
malloc 1535 dev/pci/cs4281.c p->dum = malloc(size, pool, flags);
malloc 391 dev/pci/cz.c cz->cz_ports = malloc(sizeof(struct cztty_softc) * cz->cz_nchannels,
malloc 1617 dev/pci/eap.c p = malloc(sizeof(*p), pool, flags);
malloc 293 dev/pci/emuxki.c if ((mem = malloc(sizeof(*mem), type, flags)) == NULL)
malloc 301 dev/pci/emuxki.c mem->segs = malloc(mem->nsegs * sizeof(*(mem->segs)), type, flags);
malloc 973 dev/pci/emuxki.c if ((mem = malloc(sizeof(*mem), type, flags)) == NULL)
malloc 1129 dev/pci/emuxki.c chan = malloc(sizeof(struct emuxki_channel), M_DEVBUF, M_WAITOK);
malloc 1481 dev/pci/emuxki.c if (!(voice = malloc(sizeof(*voice), M_DEVBUF, M_WAITOK)))
malloc 496 dev/pci/esa.c p = malloc(sizeof(*p), type, flags);
malloc 1075 dev/pci/esa.c sc->savemem = (u_int16_t *)malloc(len, M_DEVBUF, M_NOWAIT);
malloc 1543 dev/pci/eso.c if ((ed = malloc(size, type, flags)) == NULL)
malloc 717 dev/pci/fms.c p = malloc(sizeof(*p), pool, flags);
malloc 164 dev/pci/fmsradio.c r = malloc(sizeof(struct fmsradio_if), M_DEVBUF, M_NOWAIT);
malloc 1828 dev/pci/hifn7751.c ses = sc->sc_sessions = (struct hifn_session *)malloc(
malloc 1844 dev/pci/hifn7751.c ses = (struct hifn_session *)malloc((sesn + 1) *
malloc 1961 dev/pci/hifn7751.c cmd = (struct hifn_command *)malloc(sizeof(struct hifn_command),
malloc 675 dev/pci/if_bge.c entry = malloc(sizeof(struct bge_jpool_entry),
malloc 1046 dev/pci/if_bge.c dma = malloc(sizeof(*dma), M_DEVBUF, M_NOWAIT);
malloc 1872 dev/pci/if_bnx.c buf = malloc(len32, M_DEVBUF, M_NOWAIT);
malloc 397 dev/pci/if_dc_pci.c sc->dc_pnic_rx_buf = malloc(ETHER_MAX_DIX_LEN * 5, M_DEVBUF,
malloc 1845 dev/pci/if_em.c (struct em_buffer *) malloc(sizeof(struct em_buffer) *
malloc 2283 dev/pci/if_em.c (struct em_buffer *) malloc(sizeof(struct em_buffer) *
malloc 1158 dev/pci/if_ixgb.c (struct ixgb_buffer *) malloc(sizeof(struct ixgb_buffer) *
malloc 1529 dev/pci/if_ixgb.c (struct ixgb_buffer *) malloc(sizeof(struct ixgb_buffer) *
malloc 805 dev/pci/if_lge.c entry = malloc(sizeof(struct lge_jpool_entry),
malloc 486 dev/pci/if_msk.c entry = malloc(sizeof(*entry), M_DEVBUF, M_NOWAIT);
malloc 620 dev/pci/if_msk.c entry = malloc(sizeof(struct sk_jpool_entry),
malloc 425 dev/pci/if_myx.c fw = malloc(fwlen, M_DEVBUF, M_WAIT);
malloc 1103 dev/pci/if_myx.c malloc(sc->sc_rxbufsize, M_DEVBUF, M_WAITOK);
malloc 1105 dev/pci/if_myx.c malloc(sc->sc_rxbufdescsize, M_DEVBUF, M_WAITOK);
malloc 1107 dev/pci/if_myx.c malloc(sc->sc_rxbufsize, M_DEVBUF, M_WAITOK);
malloc 1109 dev/pci/if_myx.c malloc(sc->sc_rxbufdescsize, M_DEVBUF, M_WAITOK);
malloc 1169 dev/pci/if_nge.c entry = malloc(sizeof(struct nge_jpool_entry),
malloc 1453 dev/pci/if_nxe.c ni = malloc(sizeof(struct nxe_info), M_NOWAIT, M_TEMP);
malloc 1500 dev/pci/if_nxe.c nu = malloc(sizeof(struct nxe_userinfo), M_NOWAIT, M_TEMP);
malloc 1685 dev/pci/if_nxe.c nr = malloc(sizeof(struct nxe_ring), M_DEVBUF, M_WAITOK);
malloc 1762 dev/pci/if_nxe.c npl = malloc(sizeof(struct nxe_pkt_list), M_DEVBUF, M_WAITOK);
malloc 1765 dev/pci/if_nxe.c pkt = malloc(sizeof(struct nxe_pkt) * npkts, M_DEVBUF, M_WAITOK);
malloc 1834 dev/pci/if_nxe.c ndm = malloc(sizeof(struct nxe_dmamem), M_DEVBUF, M_WAITOK);
malloc 147 dev/pci/if_san_common.c card=malloc(sizeof(sdla_t), M_DEVBUF, M_NOWAIT);
malloc 350 dev/pci/if_san_common.c data = malloc(dump.length, M_DEVBUF, M_NOWAIT);
malloc 346 dev/pci/if_san_xilinx.c sc = malloc(sizeof(xilinx_softc_t), M_DEVBUF, M_NOWAIT);
malloc 2393 dev/pci/if_san_xilinx.c buf = malloc(sizeof(*buf) * MAX_RX_BUF, M_DEVBUF, M_NOWAIT);
malloc 399 dev/pci/if_sandrv.c tmp_hw_probe = malloc(sizeof(sdla_hw_probe_t), M_DEVBUF, M_NOWAIT);
malloc 584 dev/pci/if_sandrv.c new_hwcard = malloc(sizeof(sdlahw_card_t), M_DEVBUF, M_NOWAIT);
malloc 670 dev/pci/if_sandrv.c new_hw = malloc(sizeof(sdlahw_t), M_DEVBUF, M_NOWAIT);
malloc 616 dev/pci/if_sk.c entry = malloc(sizeof(*entry), M_DEVBUF, M_NOWAIT);
malloc 748 dev/pci/if_sk.c entry = malloc(sizeof(struct sk_jpool_entry),
malloc 946 dev/pci/if_ste.c sc->ste_ldata_ptr = malloc(sizeof(struct ste_list_data) + 8,
malloc 1840 dev/pci/if_tht.c tdm = malloc(sizeof(struct tht_dmamem), M_DEVBUF, M_WAITOK);
malloc 1896 dev/pci/if_tht.c tpl->tpl_pkts = malloc(sizeof(struct tht_pkt) * npkts, M_DEVBUF,
malloc 641 dev/pci/if_ti.c entry = malloc(sizeof(struct ti_jpool_entry),
malloc 1063 dev/pci/if_ti.c entry = malloc(sizeof(*entry), M_DEVBUF, M_NOWAIT);
malloc 1189 dev/pci/if_ti.c mc = malloc(sizeof(struct ti_mc_entry), M_DEVBUF, M_NOWAIT);
malloc 783 dev/pci/if_txp.c sd = (struct txp_swdesc *)malloc(sizeof(struct txp_swdesc),
malloc 1065 dev/pci/if_txp.c sd = (struct txp_swdesc *)malloc(sizeof(struct txp_swdesc),
malloc 1683 dev/pci/if_txp.c *rspp = (struct txp_rsp_desc *)malloc(
malloc 505 dev/pci/if_vic.c sc->sc_rxbuf = malloc(sizeof(struct vic_rxbuf) * sc->sc_nrxbuf,
malloc 512 dev/pci/if_vic.c sc->sc_txbuf = malloc(sizeof(struct vic_txbuf) * sc->sc_ntxbuf,
malloc 870 dev/pci/if_vr.c (u_int8_t *)malloc(MCLBYTES, M_DEVBUF, M_NOWAIT);
malloc 650 dev/pci/if_wpi.c ring->data = malloc(count * sizeof (struct wpi_tx_data), M_DEVBUF,
malloc 740 dev/pci/if_wpi.c wn = malloc(sizeof (struct wpi_node), M_DEVBUF, M_NOWAIT);
malloc 954 dev/pci/ips.c if ((ccb = malloc(n * sizeof(*ccb), M_DEVBUF, M_NOWAIT)) == NULL)
malloc 544 dev/pci/ises.c malloc(sizeof (struct ises_cmd), M_DEVBUF, M_NOWAIT);
malloc 969 dev/pci/ises.c malloc(sizeof(struct ises_session), M_DEVBUF, M_NOWAIT);
malloc 989 dev/pci/ises.c malloc(i + sizeof(struct ises_session), M_DEVBUF,
malloc 1174 dev/pci/ises.c q = (struct ises_q *)malloc(sizeof(struct ises_q), M_DEVBUF, M_NOWAIT);
malloc 470 dev/pci/isp_pci.c isp->isp_param = malloc(sizeof (sdparam), M_DEVBUF, M_NOWAIT);
malloc 482 dev/pci/isp_pci.c isp->isp_param = malloc(sizeof (sdparam), M_DEVBUF, M_NOWAIT);
malloc 494 dev/pci/isp_pci.c isp->isp_param = malloc(2 * sizeof (sdparam),
malloc 507 dev/pci/isp_pci.c isp->isp_param = malloc(2 * sizeof (sdparam),
malloc 522 dev/pci/isp_pci.c isp->isp_param = malloc(sizeof (sdparam), M_DEVBUF, M_NOWAIT);
malloc 534 dev/pci/isp_pci.c isp->isp_param = malloc(2 * sizeof (sdparam),
malloc 549 dev/pci/isp_pci.c isp->isp_param = malloc(sizeof (fcparam), M_DEVBUF, M_NOWAIT);
malloc 572 dev/pci/isp_pci.c isp->isp_param = malloc(sizeof (fcparam), M_DEVBUF, M_NOWAIT);
malloc 605 dev/pci/isp_pci.c isp->isp_param = malloc(sizeof (fcparam), M_DEVBUF, M_NOWAIT);
malloc 971 dev/pci/isp_pci.c isp->isp_xflist = (XS_T **) malloc(len, M_DEVBUF, M_WAITOK);
malloc 978 dev/pci/isp_pci.c pcs->pci_xfer_dmap = (bus_dmamap_t *) malloc(len, M_DEVBUF, M_WAITOK);
malloc 299 dev/pci/lofn.c q = (struct lofn_q *)malloc(sizeof(*q), M_DEVBUF, M_NOWAIT);
malloc 119 dev/pci/musycc.c sc->mc_groups = (struct musycc_group *)malloc(sc->mc_ngroups *
malloc 1656 dev/pci/musycc.c cc = malloc(sizeof(*cc), M_DEVBUF, M_NOWAIT);
malloc 1871 dev/pci/noct.c q = (struct noct_workq *)malloc(sizeof(struct noct_workq),
malloc 434 dev/pci/nofn.c q = (struct nofn_pk_q *)malloc(sizeof(*q), M_DEVBUF, M_NOWAIT);
malloc 1626 dev/pci/pccbb.c malloc(sizeof(struct pccbb_intrhand_list), M_DEVBUF, M_WAITOK);
malloc 2878 dev/pci/pccbb.c if ((elem = malloc(sizeof(struct pccbb_win_chain), M_DEVBUF,
malloc 339 dev/pci/pci.c if (!(pd = malloc(sizeof *pd, M_DEVBUF,
malloc 1845 dev/pci/pciide.c malloc(sizeof(struct channel_queue), M_DEVBUF, M_NOWAIT);
malloc 3283 dev/pci/pciide.c malloc(sizeof(struct channel_queue), M_DEVBUF, M_NOWAIT);
malloc 3648 dev/pci/pciide.c malloc(sizeof(struct channel_queue), M_DEVBUF, M_NOWAIT);
malloc 3799 dev/pci/pciide.c sc->sc_cookie = malloc(sizeof(struct pciide_satalink), M_DEVBUF,
malloc 4077 dev/pci/pciide.c sc->sc_cookie = malloc(sizeof(struct pciide_satalink), M_DEVBUF,
malloc 4261 dev/pci/pciide.c malloc(sizeof(struct channel_queue), M_DEVBUF, M_NOWAIT);
malloc 4410 dev/pci/pciide.c sc->sc_cookie = malloc(sizeof(struct pciide_cy), M_DEVBUF, M_NOWAIT);
malloc 4462 dev/pci/pciide.c malloc(sizeof(struct channel_queue), M_DEVBUF, M_NOWAIT);
malloc 4667 dev/pci/pciide.c sc->sc_cookie = malloc(sizeof(struct pciide_sis), M_DEVBUF, M_NOWAIT);
malloc 6340 dev/pci/pciide.c sc->sc_cookie = malloc(sizeof(struct pciide_pdcsata), M_DEVBUF,
malloc 6483 dev/pci/pciide.c malloc(sizeof(struct channel_queue), M_DEVBUF, M_NOWAIT);
malloc 7267 dev/pci/pciide.c sc->sc_cookie = malloc(sizeof(struct pciide_svwsata), M_DEVBUF,
malloc 1325 dev/pci/safe.c ses = sc->sc_sessions = (struct safe_session *)malloc(
malloc 1341 dev/pci/safe.c ses = (struct safe_session *)malloc((sesn + 1) *
malloc 1814 dev/pci/safe.c q = (struct safe_pkq *)malloc(sizeof(*q), M_DEVBUF, M_NOWAIT);
malloc 1440 dev/pci/sv.c p = malloc(sizeof(*p), pool, flags);
malloc 432 dev/pci/tga.c malloc(sizeof(struct tga_devconfig), M_DEVBUF, M_NOWAIT);
malloc 232 dev/pci/ubsec.c q = (struct ubsec_q *)malloc(sizeof(struct ubsec_q),
malloc 588 dev/pci/ubsec.c ses = sc->sc_sessions = (struct ubsec_session *)malloc(
malloc 604 dev/pci/ubsec.c ses = (struct ubsec_session *)malloc((sesn + 1) *
malloc 1808 dev/pci/ubsec.c me = (struct ubsec_q2_modexp *)malloc(sizeof *me, M_DEVBUF, M_NOWAIT);
malloc 2007 dev/pci/ubsec.c me = (struct ubsec_q2_modexp *)malloc(sizeof *me, M_DEVBUF, M_NOWAIT);
malloc 2237 dev/pci/ubsec.c rp = (struct ubsec_q2_rsapriv *)malloc(sizeof *rp, M_DEVBUF, M_NOWAIT);
malloc 1702 dev/pci/yds.c p = malloc(sizeof(*p), pool, flags);
malloc 365 dev/pckbc/pckbd.c sc->id = malloc(sizeof(struct pckbd_internal),
malloc 225 dev/pcmcia/cfxga.c cfe = (struct pcmcia_config_entry *)malloc(sizeof *cfe,
malloc 444 dev/pcmcia/cfxga.c scr = malloc(sizeof *scr, M_DEVBUF, cold ? M_NOWAIT : M_WAITOK);
malloc 509 dev/pcmcia/cfxga.c scr->scr_mem = malloc(scrsize, M_DEVBUF, cold ? M_NOWAIT : M_WAITOK);
malloc 280 dev/pcmcia/if_malo.c sc->sc_cmd = malloc(MALO_CMD_BUFFER_SIZE, M_DEVBUF, M_NOWAIT);
malloc 283 dev/pcmcia/if_malo.c sc->sc_data = malloc(MCLBYTES, M_DEVBUF, M_NOWAIT);
malloc 382 dev/pcmcia/if_malo.c if ((nr = malloc(sizeof(*nr), M_DEVBUF, M_WAITOK)) == NULL)
malloc 252 dev/pcmcia/if_xe.c malloc(sizeof *cfe, M_DEVBUF, M_NOWAIT);
malloc 203 dev/pcmcia/pcmcia.c pf = malloc(sizeof *pf, M_DEVBUF, M_NOWAIT);
malloc 847 dev/pcmcia/pcmcia_cis.c state->pf = malloc(sizeof(*state->pf), M_DEVBUF,
malloc 888 dev/pcmcia/pcmcia_cis.c state->pf = malloc(sizeof(*state->pf),
malloc 973 dev/pcmcia/pcmcia_cis.c malloc(sizeof(*cfe), M_DEVBUF, M_NOWAIT);
malloc 266 dev/pcmcia/pcmcia_cis_quirks.c cfe = malloc(sizeof(*cfe), M_DEVBUF, M_NOWAIT);
malloc 273 dev/pcmcia/pcmcia_cis_quirks.c pf = malloc(sizeof(*pf), M_DEVBUF, M_NOWAIT);
malloc 279 dev/pcmcia/pcmcia_cis_quirks.c cfe = malloc(sizeof(*cfe), M_DEVBUF, M_NOWAIT);
malloc 355 dev/pcmcia/wdc_pcmcia.c sc->wdc_channel.ch_queue = malloc(sizeof(struct channel_queue),
malloc 49 dev/raidframe/rf_debugMem.h _p_ = _cast_ malloc((u_long)_size_, M_RAIDFRAME, M_WAITOK); \
malloc 166 dev/raidframe/rf_diskqueue.c dqd->bp = (struct buf *) malloc(sizeof(struct buf), M_RAIDFRAME,
malloc 167 dev/raidframe/rf_engine.c malloc(numraid * sizeof(void *),
malloc 392 dev/raidframe/rf_openbsdkintf.c malloc(num * sizeof(struct raid_softc), M_RAIDFRAME, M_NOWAIT);
malloc 401 dev/raidframe/rf_openbsdkintf.c malloc(num * sizeof(struct raid_softc *), M_RAIDFRAME,
malloc 410 dev/raidframe/rf_openbsdkintf.c raidrootdev = (struct device *)malloc(num * sizeof(struct device),
malloc 1652 dev/raidframe/rf_openbsdkintf.c cf = malloc(sizeof(struct cfdata), M_RAIDFRAME, M_NOWAIT);
malloc 2806 dev/raidframe/rf_openbsdkintf.c malloc(sizeof(RF_ComponentLabel_t), M_RAIDFRAME,
malloc 2830 dev/raidframe/rf_openbsdkintf.c malloc(sizeof(RF_AutoConfig_t),
malloc 2932 dev/raidframe/rf_openbsdkintf.c malloc(sizeof(RF_ConfigSet_t), M_RAIDFRAME,
malloc 2957 dev/raidframe/rf_openbsdkintf.c malloc(sizeof(RF_ConfigSet_t),
malloc 3427 dev/raidframe/rf_openbsdkintf.c config = (RF_Config_t *)malloc(sizeof(RF_Config_t), M_RAIDFRAME,
malloc 63 dev/raidframe/rf_shutdown.c ent = (RF_ShutdownList_t *) malloc(sizeof(RF_ShutdownList_t),
malloc 150 dev/ramdisk.c sc = malloc(sizeof(*sc), M_DEVBUF, M_WAITOK);
malloc 409 dev/ramdisk.c lp = malloc(sizeof(*lp), M_TEMP, M_WAITOK);
malloc 1140 dev/rasops/rasops.c f = malloc(sizeof(struct rotatedfont), M_DEVBUF, M_WAITOK);
malloc 192 dev/sbus/bpp.c dsc->sc_buf = malloc(dsc->sc_bufsz, M_DEVBUF, M_NOWAIT);
malloc 1424 dev/sbus/cs4231.c p = (struct cs_dma *)malloc(sizeof(struct cs_dma), pool, flags);
malloc 282 dev/sbus/dma_sbus.c sbt = malloc(sizeof(*sbt), M_DEVBUF, M_NOWAIT);
malloc 206 dev/sbus/esp_sbus.c lsc = malloc(sizeof (struct lsi64854_softc), M_DEVBUF, M_NOWAIT);
malloc 383 dev/sbus/isp_sbus.c isp->isp_xflist = (XS_T **) malloc(n, M_DEVBUF, M_WAITOK);
malloc 390 dev/sbus/isp_sbus.c sbc->sbus_dmamap = (bus_dmamap_t *) malloc(n, M_DEVBUF, M_WAITOK);
malloc 134 dev/sbus/lebuffer.c sbt = malloc(sizeof(*sbt), M_DEVBUF, M_NOWAIT);
malloc 820 dev/sbus/magma.c mp->mp_rbuf = malloc(MTTY_RBUF_SIZE, M_DEVBUF, M_NOWAIT);
malloc 1547 dev/sbus/magma.c buffer = malloc(buflen, M_DEVBUF, M_WAITOK);
malloc 195 dev/sbus/qec.c sbt = malloc(sizeof(*sbt), M_DEVBUF, M_NOWAIT);
malloc 316 dev/sbus/spif.c sp->sp_rbuf = malloc(STTY_RBUF_SIZE, M_DEVBUF, M_NOWAIT);
malloc 158 dev/sdmmc/sbt.c sc->sc_buf = malloc(SBT_PKT_BUFSIZ, M_DEVBUF,
malloc 692 dev/sdmmc/sdmmc.c data = malloc(ucmd->c_datalen, M_TEMP,
malloc 614 dev/sdmmc/sdmmc_io.c ih = malloc(sizeof *ih, M_DEVBUF, M_WAITOK | M_CANFAIL);
malloc 619 dev/sdmmc/sdmmc_io.c ih->ih_name = malloc(strlen(name), M_DEVBUF, M_WAITOK | M_CANFAIL);
malloc 198 dev/sdmmc/sdmmc_scsi.c scbus->sc_ccbs = malloc(sizeof(struct sdmmc_ccb) * nccbs,
malloc 190 dev/sequencer.c sc->devs = malloc(nmidi * sizeof(struct midi_dev *),
malloc 1044 dev/sequencer.c md = malloc(sizeof *md, M_DEVBUF, M_WAITOK);
malloc 250 dev/softraid.c sd->sd_ccb = malloc(sizeof(struct sr_ccb) *
malloc 344 dev/softraid.c sd->sd_wu = malloc(sizeof(struct sr_workunit) * no_wu,
malloc 769 dev/softraid.c dt = malloc(bc->bc_dev_list_len, M_DEVBUF, M_WAITOK);
malloc 776 dev/softraid.c sd = malloc(sizeof(struct sr_discipline), M_DEVBUF, M_WAITOK);
malloc 787 dev/softraid.c sd->sd_meta = malloc(SR_META_SIZE * 512 , M_DEVBUF, M_WAITOK);
malloc 791 dev/softraid.c sd->sd_vol.sv_chunks = malloc(sizeof(struct sr_chunk *) * no_chunk,
malloc 1031 dev/softraid.c ch_entry = malloc(sizeof(struct sr_chunk), M_DEVBUF, M_WAITOK);
malloc 1115 dev/softraid.c m = malloc(sz , M_DEVBUF, M_WAITOK);
malloc 1797 dev/softraid.c m = malloc(sz , M_DEVBUF, M_WAITOK);
malloc 2111 dev/softraid.c mle = malloc(sizeof(*mle), M_DEVBUF, M_WAITOK);
malloc 2113 dev/softraid.c mle->sml_metadata = malloc(sz, M_DEVBUF,
malloc 2137 dev/softraid.c dt = malloc(BIOC_CRMAXLEN, M_DEVBUF, M_WAITOK);
malloc 2916 dev/softraid.c uio = malloc(sizeof(*uio), M_DEVBUF, M_WAITOK);
malloc 2918 dev/softraid.c uio->uio_iov = malloc(sizeof(*uio->uio_iov), M_DEVBUF, M_WAITOK);
malloc 1047 dev/systrace.c kaddr = malloc(inj->stri_len, M_XDATA, M_WAITOK);
malloc 1385 dev/systrace.c malloc(sizeof(struct systrace_replace) + len, M_XDATA, M_WAITOK);
malloc 1682 dev/systrace.c pol->sysent = (u_char *)malloc(maxents * sizeof(u_char),
malloc 1119 dev/usb/ehci.c xfer = malloc(sizeof(struct ehci_xfer), M_USB, M_NOWAIT);
malloc 98 dev/usb/hid.c s = malloc(sizeof *s, M_TEMP, M_WAITOK);
malloc 301 dev/usb/hid.c hi = malloc(sizeof *hi, M_TEMP, M_WAITOK);
malloc 479 dev/usb/if_kue.c sc->kue_mcfilters = malloc(KUE_MCFILTCNT(sc) * ETHER_ADDR_LEN,
malloc 979 dev/usb/if_wi_usb.c sc->wi_usb_txmem[nmem] = malloc(len, M_DEVBUF, M_WAITOK);
malloc 1825 dev/usb/if_wi_usb.c wi_thread_info = malloc(sizeof(*wi_thread_info), M_DEVBUF, M_WAITOK);
malloc 477 dev/usb/if_zyd.c sc->ibuf = malloc(isize, M_USBDEV, M_NOWAIT);
malloc 648 dev/usb/if_zyd.c zn = malloc(sizeof (struct zyd_node), M_DEVBUF, M_NOWAIT);
malloc 922 dev/usb/ohci.c xfer = malloc(sizeof(struct ohci_xfer), M_USB, M_NOWAIT);
malloc 618 dev/usb/uaudio.c nmc = malloc(len, M_USBDEV, M_NOWAIT);
malloc 1311 dev/usb/uaudio.c tml = malloc(TERMINAL_LIST_SIZE(len), M_TEMP, M_NOWAIT);
malloc 1345 dev/usb/uaudio.c tml = malloc(TERMINAL_LIST_SIZE(it->output->size + 1),
malloc 1367 dev/usb/uaudio.c it->output = malloc(TERMINAL_LIST_SIZE(1), M_TEMP, M_NOWAIT);
malloc 1379 dev/usb/uaudio.c it->inputs = malloc(sizeof(struct terminal_list *), M_TEMP, M_NOWAIT);
malloc 1384 dev/usb/uaudio.c tml = malloc(TERMINAL_LIST_SIZE(1), M_TEMP, M_NOWAIT);
malloc 1398 dev/usb/uaudio.c it->inputs = malloc(sizeof(struct terminal_list *), M_TEMP, M_NOWAIT);
malloc 1407 dev/usb/uaudio.c it->inputs = malloc(sizeof(struct terminal_list *), M_TEMP, M_NOWAIT);
malloc 1419 dev/usb/uaudio.c it->inputs = malloc(sizeof(struct terminal_list *)
malloc 1434 dev/usb/uaudio.c it->inputs = malloc(sizeof(struct terminal_list *)
malloc 1449 dev/usb/uaudio.c it->inputs = malloc(sizeof(struct terminal_list *)
malloc 1464 dev/usb/uaudio.c it->inputs = malloc(sizeof(struct terminal_list *)
malloc 1501 dev/usb/uaudio.c nai = malloc(len, M_USBDEV, M_NOWAIT);
malloc 1833 dev/usb/uaudio.c iot = malloc(sizeof(struct io_terminal) * 256, M_TEMP, M_NOWAIT);
malloc 656 dev/usb/ubsa.c sc->sc_intr_buf = malloc(sc->sc_isize, M_USBDEV, M_WAITOK);
malloc 720 dev/usb/ubt.c sc->sc_evt_buf = malloc(UBT_BUFSIZ_EVENT, M_USBDEV, M_NOWAIT);
malloc 284 dev/usb/ucycom.c sc->sc_obuf = malloc(sc->sc_olen, M_USBDEV, M_WAITOK);
malloc 287 dev/usb/ucycom.c sc->sc_ibuf = malloc(sc->sc_ilen, M_USBDEV, M_WAITOK);
malloc 344 dev/usb/ugen.c sce->ibuf = malloc(isize, M_USBDEV, M_WAITOK);
malloc 373 dev/usb/ugen.c sce->ibuf = malloc(isize * UGEN_NISOFRAMES,
malloc 973 dev/usb/ugen.c cdesc = malloc(len, M_TEMP, M_WAITOK);
malloc 984 dev/usb/ugen.c cdesc = malloc(len, M_TEMP, M_WAITOK);
malloc 1242 dev/usb/ugen.c ptr = malloc(len, M_TEMP, M_WAITOK);
malloc 579 dev/usb/uhci.c stds = malloc(sizeof(uhci_soft_td_t *) * n, M_TEMP,
malloc 617 dev/usb/uhci.c xfer = malloc(sizeof(struct uhci_xfer), M_USB, M_NOWAIT);
malloc 2535 dev/usb/uhci.c iso->stds = malloc(UHCI_VFRAMELIST_COUNT * sizeof (uhci_soft_td_t *),
malloc 2785 dev/usb/uhci.c malloc(npoll * sizeof(uhci_soft_qh_t *), M_USBHC, M_WAITOK);
malloc 275 dev/usb/uhid.c sc->sc_obuf = malloc(sc->sc_osize, M_USBDEV, M_WAITOK);
malloc 234 dev/usb/uhidev.c desc = malloc(size, M_USBDEV, M_NOWAIT);
malloc 261 dev/usb/uhidev.c sc->sc_subdevs = malloc(nrepid * sizeof(struct device *),
malloc 488 dev/usb/uhidev.c sc->sc_ibuf = malloc(sc->sc_isize, M_USBDEV, M_WAITOK);
malloc 619 dev/usb/uhidev.c buf = malloc(len + 1, M_TEMP, M_WAITOK);
malloc 206 dev/usb/uhub.c hub = malloc(sizeof(*hub) + (nports-1) * sizeof(struct usbd_port),
malloc 284 dev/usb/uhub.c tts = malloc((UHUB_IS_SINGLE_TT(sc) ? 1 : nports) *
malloc 158 dev/usb/umass_scsi.c scbus = malloc(sizeof(struct umass_scsi_softc), M_DEVBUF, M_WAITOK);
malloc 571 dev/usb/umct.c sc->sc_intr_buf = malloc(sc->sc_isize, M_USBDEV, M_WAITOK);
malloc 475 dev/usb/umidi.c sc->sc_endpoints = malloc(sizeof(*sc->sc_out_ep)*
malloc 618 dev/usb/umidi.c sc->sc_endpoints = malloc(sizeof(struct umidi_endpoint)*
malloc 662 dev/usb/umidi.c sc->sc_endpoints = p = malloc(sizeof(struct umidi_endpoint) * num_ep,
malloc 754 dev/usb/umidi.c malloc(sizeof(*sc->sc_out_jacks)*(sc->sc_in_num_jacks+
malloc 996 dev/usb/umidi.c sc->sc_mididevs = malloc(sizeof(*sc->sc_mididevs)*nmidi,
malloc 701 dev/usb/uplcom.c sc->sc_intr_buf = malloc(sc->sc_isize, M_USBDEV, M_WAITOK);
malloc 509 dev/usb/urio.c ptr = malloc(len, M_TEMP, M_WAITOK);
malloc 533 dev/usb/usb.c ptr = malloc(len, M_TEMP, M_WAITOK);
malloc 754 dev/usb/usb.c ueq = malloc(sizeof *ueq, M_USBDEV, M_WAITOK);
malloc 138 dev/usb/usb_mem.c p = malloc(sizeof *p, M_USB, M_NOWAIT);
malloc 328 dev/usb/usb_subr.c devinfop = malloc(DEVINFOSIZE, M_TEMP, M_WAITOK);
malloc 486 dev/usb/usb_subr.c ifc->endpoints = malloc(nendpt * sizeof(struct usbd_endpoint),
malloc 638 dev/usb/usb_subr.c cdp = malloc(len, M_USB, M_NOWAIT);
malloc 739 dev/usb/usb_subr.c dev->ifaces = malloc(nifc * sizeof(struct usbd_interface),
malloc 775 dev/usb/usb_subr.c p = malloc(dev->bus->pipe_size, M_USB, M_NOWAIT);
malloc 850 dev/usb/usb_subr.c dev->subdevs = malloc(2 * sizeof dv, M_USB, M_NOWAIT);
malloc 881 dev/usb/usb_subr.c ifaces = malloc(nifaces * sizeof(usbd_interface_handle),
malloc 890 dev/usb/usb_subr.c dev->subdevs = malloc(len, M_USB, M_NOWAIT);
malloc 932 dev/usb/usb_subr.c dev->subdevs = malloc(2 * sizeof dv, M_USB, M_NOWAIT);
malloc 977 dev/usb/usb_subr.c dev = malloc(sizeof *dev, M_USB, M_NOWAIT);
malloc 396 dev/usb/usbdi_util.c *descp = malloc(*sizep, mem, M_NOWAIT);
malloc 83 dev/usb/usbf_subr.c p = malloc(newsize, M_USB, M_NOWAIT);
malloc 154 dev/usb/usbf_subr.c dev = malloc(sizeof(*dev), M_USB, M_NOWAIT);
malloc 274 dev/usb/usbf_subr.c devinfo = malloc(len, M_USB, M_NOWAIT);
malloc 400 dev/usb/usbf_subr.c uc = malloc(sizeof *uc, M_USB, M_NOWAIT);
malloc 404 dev/usb/usbf_subr.c cd = malloc(sizeof *cd, M_USB, M_NOWAIT);
malloc 478 dev/usb/usbf_subr.c ui = malloc(sizeof *ui, M_USB, M_NOWAIT);
malloc 482 dev/usb/usbf_subr.c id = malloc(sizeof *id, M_USB, M_NOWAIT);
malloc 521 dev/usb/usbf_subr.c ue = malloc(sizeof *ue, M_USB, M_NOWAIT);
malloc 525 dev/usb/usbf_subr.c ed = malloc(sizeof *ed, M_USB, M_NOWAIT);
malloc 660 dev/usb/usbf_subr.c p = malloc(dev->bus->pipe_size, M_USB, M_NOWAIT);
malloc 365 dev/usb/uscanner.c sc->sc_bulkin_buffer = malloc(USCANNER_BUFFERSIZE, M_USBDEV, M_WAITOK);
malloc 366 dev/usb/uscanner.c sc->sc_bulkout_buffer = malloc(USCANNER_BUFFERSIZE, M_USBDEV, M_WAITOK);
malloc 293 dev/usb/uts.c sc->sc_ibuf = malloc(sc->sc_isize, M_USBDEV, M_WAITOK);
malloc 741 dev/usb/uvscom.c sc->sc_intr_buf = malloc(sc->sc_isize, M_USBDEV, M_WAITOK);
malloc 286 dev/vesa/vesabios.c (uint16_t *)malloc(sizeof(uint16_t)*nrastermodes,
malloc 201 dev/vnd.c mem = malloc(size, M_DEVBUF, M_NOWAIT);
malloc 790 dev/vnd.c vnd->sc_keyctx = malloc(sizeof(*vnd->sc_keyctx), M_DEVBUF,
malloc 949 dev/vnd.c tmpbuf = malloc(DEV_BSIZE, M_TEMP, M_WAITOK);
malloc 281 dev/wscons/wsdisplay.c scr = malloc(sizeof(struct wsscreen), M_DEVBUF, M_NOWAIT);
malloc 293 dev/wscons/wsdisplay.c dconf = malloc(sizeof(struct wsscreen_internal),
malloc 1287 dev/wscons/wsdisplay.c buf = malloc(fontsz, M_DEVBUF, M_WAITOK);
malloc 3211 dev/wscons/wsdisplay.c if ((Copybuffer = (char *)malloc(size, M_DEVBUF, M_NOWAIT)) == NULL) {
malloc 107 dev/wscons/wsdisplay_compat_usl.c sd = malloc(sizeof(struct usl_syncdata), M_DEVBUF, M_NOWAIT);
malloc 119 dev/wscons/wsemul_dumb.c edp = malloc(sizeof *edp, M_DEVBUF, M_WAITOK);
malloc 219 dev/wscons/wsemul_sun.c edp = malloc(sizeof *edp, M_DEVBUF, M_NOWAIT);
malloc 206 dev/wscons/wsemul_vt100.c edp = malloc(sizeof *edp, M_DEVBUF, M_NOWAIT);
malloc 216 dev/wscons/wsemul_vt100.c edp->tabs = malloc(edp->ncols, M_DEVBUF, M_NOWAIT);
malloc 217 dev/wscons/wsemul_vt100.c edp->dblwid = malloc(edp->nrows, M_DEVBUF, M_NOWAIT);
malloc 221 dev/wscons/wsemul_vt100.c edp->dcsarg = malloc(DCS_MAXLEN, M_DEVBUF, M_NOWAIT);
malloc 222 dev/wscons/wsemul_vt100.c edp->isolatin1tab = malloc(128 * sizeof(int), M_DEVBUF, M_NOWAIT);
malloc 223 dev/wscons/wsemul_vt100.c edp->decgraphtab = malloc(128 * sizeof(int), M_DEVBUF, M_NOWAIT);
malloc 224 dev/wscons/wsemul_vt100.c edp->dectechtab = malloc(128 * sizeof(int), M_DEVBUF, M_NOWAIT);
malloc 225 dev/wscons/wsemul_vt100.c edp->nrctab = malloc(128 * sizeof(int), M_DEVBUF, M_NOWAIT);
malloc 106 dev/wscons/wsevent.c ev->q = malloc((u_long)WSEVENT_QSIZE * sizeof(struct wscons_event),
malloc 387 dev/wscons/wskbd.c sc->id = malloc(sizeof(struct wskbd_internal),
malloc 1084 dev/wscons/wskbd.c buf = malloc(len, M_TEMP, M_WAITOK);
malloc 403 dev/wscons/wskbdutil.c *map = malloc(newlen*sizeof(struct wscons_keymap),
malloc 144 dev/wscons/wsmux.c malloc((n + 1) * sizeof (*wsmuxdevs), M_DEVBUF, M_NOWAIT);
malloc 592 dev/wscons/wsmux.c sc = malloc(sizeof *sc, M_DEVBUF, M_NOWAIT);
malloc 306 dev/wsfont/wsfont.c newfont = malloc(sizeof *font, M_DEVBUF, M_WAITOK);
malloc 315 dev/wsfont/wsfont.c newbits = malloc(newstride * font->fontwidth * font->numchars,
malloc 354 isofs/cd9660/cd9660_vfsops.c isomp = malloc(sizeof *isomp, M_ISOFSMNT, M_WAITOK);
malloc 201 isofs/udf/udf_subr.c ump->um_vat = malloc(sizeof(struct unode), M_UDFMOUNT, M_WAITOK);
malloc 559 isofs/udf/udf_vfsops.c up->u_fentry = malloc(size, M_UDFFENTRY, M_NOWAIT);
malloc 696 isofs/udf/udf_vfsops.c ump->um_stbl = malloc(letoh32(pms->st_size), M_UDFMOUNT, M_NOWAIT);
malloc 620 isofs/udf/udf_vnops.c ds->buf = malloc(ds->ump->um_bsize, M_UDFFID, M_WAITOK);
malloc 395 kern/exec_elf.c ph = malloc(phsize, M_TEMP, M_WAITOK);
malloc 569 kern/exec_elf.c ph = malloc(phsize, M_TEMP, M_WAITOK);
malloc 740 kern/exec_elf.c ap = malloc(sizeof(struct elf_args), M_TEMP, M_WAITOK);
malloc 872 kern/exec_elf.c hph = malloc(phsize, M_TEMP, M_WAITOK);
malloc 883 kern/exec_elf.c np = malloc(ph->p_filesz, M_TEMP, M_WAITOK);
malloc 210 kern/exec_script.c *tmpsap = malloc(shellnamelen + 1, M_EXEC, M_WAITOK);
malloc 213 kern/exec_script.c *tmpsap = malloc(shellarglen + 1, M_EXEC, M_WAITOK);
malloc 216 kern/exec_script.c *tmpsap = malloc(MAXPATHLEN, M_EXEC, M_WAITOK);
malloc 101 kern/exec_subr.c nvcp = malloc(evsp->evs_cnt * sizeof(struct exec_vmcmd), M_EXEC,
malloc 737 kern/kern_descrip.c newofile = malloc(nfiles * OFILESIZE, M_FILEDESC, M_WAITOK);
malloc 755 kern/kern_descrip.c newhimap = malloc(NDHISLOTS(nfiles) * sizeof(u_int),
malloc 757 kern/kern_descrip.c newlomap = malloc(NDLOSLOTS(nfiles) * sizeof(u_int),
malloc 918 kern/kern_descrip.c newfdp->fd_ofiles = malloc(i * OFILESIZE, M_FILEDESC, M_WAITOK);
malloc 927 kern/kern_descrip.c newfdp->fd_himap = malloc(NDHISLOTS(i) * sizeof(u_int),
malloc 929 kern/kern_descrip.c newfdp->fd_lomap = malloc(NDLOSLOTS(i) * sizeof(u_int),
malloc 929 kern/kern_event.c list = malloc(size * sizeof(struct klist *), M_TEMP, M_WAITOK);
malloc 296 kern/kern_exec.c pack.ep_hdr = malloc(exec_maxhdrsz, M_EXEC, M_WAITOK);
malloc 404 kern/kern_fork.c p2->p_ptstat = malloc(sizeof(*p2->p_ptstat),
malloc 148 kern/kern_kthread.c kq = malloc(sizeof *kq, M_TEMP, M_NOWAIT);
malloc 114 kern/kern_ktrace.c ktp = malloc(len, M_TEMP, M_WAITOK);
malloc 196 kern/kern_ktrace.c ktp = malloc(buflen, M_TEMP, M_WAITOK);
malloc 603 kern/kern_malloc.c memall = malloc(totlen + M_LAST, M_SYSCTL, M_WAITOK);
malloc 188 kern/kern_sensors.c st = malloc(sizeof(struct sensor_task), M_DEVBUF, M_NOWAIT);
malloc 169 kern/kern_subr.c hashtbl = malloc(hashsize * sizeof(*hashtbl), type, flags);
malloc 195 kern/kern_subr.c hdp = (struct hook_desc *)malloc(sizeof (*hdp), M_DEVBUF, M_NOWAIT);
malloc 271 kern/kern_subr.c malloc(sizeof(*ndp), M_DEVBUF, M_NOWAIT);
malloc 995 kern/kern_sysctl.c eproc = malloc(sizeof(struct eproc), M_TEMP, M_WAITOK);
malloc 1003 kern/kern_sysctl.c kproc2 = malloc(sizeof(struct kinfo_proc2), M_TEMP, M_WAITOK);
malloc 1407 kern/kern_sysctl.c buf = malloc(PAGE_SIZE, M_TEMP, M_WAITOK);
malloc 1579 kern/kern_sysctl.c diskstats = malloc(disk_count * sizeof(struct diskstats),
malloc 1581 kern/kern_sysctl.c disknames = malloc(tlen, M_SYSCTL, M_WAITOK);
malloc 1695 kern/kern_sysctl.c buf = malloc(min(tsize, buflen), M_TEMP, M_WAITOK);
malloc 1794 kern/kern_sysctl.c usd = malloc(sizeof(*usd), M_TEMP, M_WAITOK);
malloc 1816 kern/kern_sysctl.c us = malloc(sizeof(*us), M_TEMP, M_WAITOK);
malloc 475 kern/kern_tc.c choices = malloc(maxlen, M_TEMP, M_WAITOK);
malloc 87 kern/kern_workq.c wq = malloc(sizeof(*wq), M_DEVBUF, M_NOWAIT);
malloc 414 kern/subr_autoconf.c dev = (struct device *)malloc(ca->ca_devsize, M_DEVBUF, M_NOWAIT);
malloc 454 kern/subr_autoconf.c nsp = malloc(new * sizeof(void *), M_DEVBUF, M_NOWAIT);
malloc 664 kern/subr_autoconf.c if ((dc = malloc(sizeof(*dc), M_DEVBUF, M_NOWAIT)) == NULL)
malloc 728 kern/subr_disk.c diskp->dk_label = malloc(sizeof(struct disklabel), M_DEVBUF, M_NOWAIT);
malloc 914 kern/subr_disk.c bq = malloc(sizeof(*bq), M_DEVBUF, M_NOWAIT);
malloc 66 kern/subr_extent.c #define malloc(s, t, flags) malloc(s)
malloc 70 kern/subr_extent.c #define pool_get(pool, flags) malloc((pool)->pr_size, 0, 0)
malloc 216 kern/subr_extent.c ex = (struct extent *)malloc(sizeof(struct extent),
malloc 503 kern/subr_pool.c (pp->pr_log = malloc(pool_logsize * sizeof(struct pool_log),
malloc 485 kern/subr_userconf.c lk = l = (int *)malloc(sizeof(int) * i,
malloc 202 kern/sys_generic.c iov = needfree = malloc(iovlen, M_IOV, M_WAITOK);
malloc 238 kern/sys_generic.c ktriov = malloc(iovlen, M_TEMP, M_WAITOK);
malloc 404 kern/sys_generic.c iov = needfree = malloc(iovlen, M_IOV, M_WAITOK);
malloc 440 kern/sys_generic.c ktriov = malloc(iovlen, M_TEMP, M_WAITOK);
malloc 521 kern/sys_generic.c memp = (caddr_t)malloc((u_long)size, M_IOCTLOPS, M_WAITOK);
malloc 642 kern/sys_generic.c mbits = malloc(ni * 6, M_TEMP, M_WAITOK);
malloc 884 kern/sys_generic.c pl = (struct pollfd *) malloc(sz, M_TEMP, M_WAITOK);
malloc 237 kern/sys_process.c t->p_ptstat = malloc(sizeof(*t->p_ptstat),
malloc 416 kern/sys_process.c t->p_ptstat = malloc(sizeof(*t->p_ptstat),
malloc 446 kern/sys_process.c regs = malloc(sizeof(*regs), M_TEMP, M_WAITOK);
malloc 458 kern/sys_process.c regs = malloc(sizeof(*regs), M_TEMP, M_WAITOK);
malloc 471 kern/sys_process.c fpregs = malloc(sizeof(*fpregs), M_TEMP, M_WAITOK);
malloc 485 kern/sys_process.c fpregs = malloc(sizeof(*fpregs), M_TEMP, M_WAITOK);
malloc 499 kern/sys_process.c xmmregs = malloc(sizeof(*xmmregs), M_TEMP, M_WAITOK);
malloc 513 kern/sys_process.c xmmregs = malloc(sizeof(*xmmregs), M_TEMP, M_WAITOK);
malloc 74 kern/sysv_sem.c sema = malloc(seminfo.semmni * sizeof(struct semid_ds *),
malloc 77 kern/sysv_sem.c semseqs = malloc(seminfo.semmni * sizeof(unsigned short),
malloc 418 kern/sysv_sem.c semaptr_new->sem_base = malloc(nsems * sizeof(struct sem),
malloc 537 kern/sysv_sem.c sops = malloc(nsops * sizeof(struct sembuf), M_SEM, M_WAITOK);
malloc 853 kern/sysv_sem.c sema_new = malloc(val * sizeof(struct semid_ds *),
malloc 859 kern/sysv_sem.c newseqs = malloc(val * sizeof(unsigned short), M_SEM, M_WAITOK);
malloc 232 kern/sysv_shm.c shmmap_h = malloc(size, M_SHM, M_WAITOK);
malloc 502 kern/sysv_shm.c vm2->vm_shm = malloc(size, M_SHM, M_WAITOK);
malloc 537 kern/sysv_shm.c shmsegs = malloc(shminfo.shmmni * sizeof(struct shmid_ds *),
malloc 540 kern/sysv_shm.c shmseqs = malloc(shminfo.shmmni * sizeof(unsigned short),
malloc 603 kern/sysv_shm.c newsegs = malloc(val * sizeof(struct shmid_ds *),
malloc 611 kern/sysv_shm.c newseqs = malloc(val * sizeof(unsigned short), M_SHM, M_WAITOK);
malloc 1496 kern/tty.c stime = malloc(sizeof(*stime), M_TEMP, M_WAITOK);
malloc 2282 kern/tty.c ttystats = malloc(tty_count * sizeof(struct itty),
malloc 90 kern/tty_nmea.c np = malloc(sizeof(struct nmea), M_DEVBUF, M_WAITOK);
malloc 157 kern/tty_pty.c pt = malloc(nelem * sizeof(struct pt_softc *), M_DEVBUF, M_WAITOK);
malloc 67 kern/tty_subr.c clp->c_cs = malloc(size, M_TTYS, M_WAITOK);
malloc 71 kern/tty_subr.c clp->c_cq = malloc(QMEM(size), M_TTYS, M_WAITOK);
malloc 266 kern/uipc_mbuf2.c t = malloc(len + sizeof(struct m_tag), M_PACKET_TAGS, wait);
malloc 426 kern/uipc_syscalls.c iov = malloc(sizeof(struct iovec) * msg.msg_iovlen,
malloc 514 kern/uipc_syscalls.c ktriov = malloc(iovlen, M_TEMP, M_WAITOK);
malloc 597 kern/uipc_syscalls.c iov = malloc(sizeof(struct iovec) * msg.msg_iovlen,
malloc 661 kern/uipc_syscalls.c ktriov = malloc(iovlen, M_TEMP, M_WAITOK);
malloc 354 kern/uipc_usrreq.c unp = malloc(sizeof(*unp), M_PCB, M_NOWAIT);
malloc 624 kern/uipc_usrreq.c fdp = malloc(nfds * sizeof(int), M_TEMP, M_WAITOK);
malloc 896 kern/uipc_usrreq.c extra_ref = malloc(nfiles * sizeof(struct file *), M_FILE, M_WAITOK);
malloc 493 kern/vfs_bio.c xbpp = malloc((howmany + 1) * sizeof(struct buf *), M_TEMP, M_NOWAIT);
malloc 233 kern/vfs_cluster.c buflist = malloc(sizeof(struct buf *) * (len + 1) + sizeof(*buflist),
malloc 126 kern/vfs_getcwd.c dirbuf = malloc(dirbuflen, M_TEMP, M_WAITOK);
malloc 426 kern/vfs_getcwd.c path = malloc(len, M_TEMP, M_WAITOK);
malloc 119 kern/vfs_init.c opv_desc_vector = malloc(vfs_opv_numops * sizeof(PFI),
malloc 202 kern/vfs_subr.c mp = malloc(sizeof(struct mount), M_MOUNT, M_WAITOK);
malloc 1290 kern/vfs_subr.c tmpvfsp = malloc(sizeof(*tmpvfsp), M_TEMP, M_WAITOK);
malloc 1431 kern/vfs_subr.c np = (struct netcred *)malloc(i, M_NETADDR, M_WAITOK);
malloc 240 kern/vfs_syscalls.c mp = (struct mount *)malloc((u_long)sizeof(struct mount),
malloc 113 miscfs/portal/portal_vfsops.c fmp = (struct portalmount *) malloc(sizeof(struct portalmount),
malloc 215 miscfs/portal/portal_vnops.c pt->pt_arg = malloc(size+1, M_TEMP, M_WAITOK);
malloc 73 miscfs/procfs/procfs_cmdline.c arg = malloc(PAGE_SIZE, M_TEMP, M_WAITOK);
malloc 157 miscfs/procfs/procfs_status.c ps = malloc(len, M_TEMP, M_WAITOK);
malloc 98 miscfs/procfs/procfs_vfsops.c pmnt = (struct procfsmount *) malloc(sizeof(struct procfsmount),
malloc 63 miscfs/specfs/spec_subr.c cip = malloc(sizeof(struct cloneinfo), M_TEMP, M_WAITOK);
malloc 305 msdosfs/msdosfs_vfsops.c pmp = malloc(sizeof *pmp, M_MSDOSFSMNT, M_WAITOK);
malloc 503 msdosfs/msdosfs_vfsops.c pmp->pm_inusemap = malloc(bmapsiz * sizeof(*pmp->pm_inusemap),
malloc 917 net/bpf.c fcode = (struct bpf_insn *)malloc(size, M_DEVBUF, M_WAITOK);
malloc 1324 net/bpf.c d->bd_fbuf = (caddr_t)malloc(d->bd_bufsize, M_DEVBUF, M_NOWAIT);
malloc 1327 net/bpf.c d->bd_sbuf = (caddr_t)malloc(d->bd_bufsize, M_DEVBUF, M_NOWAIT);
malloc 1371 net/bpf.c bp = (struct bpf_if *)malloc(sizeof(*bp), M_DEVBUF, M_DONTWAIT);
malloc 1488 net/bpf.c if ((bd = malloc(sizeof(*bd), M_DEVBUF, M_NOWAIT)) != NULL) {
malloc 1943 net/bridgestp.c bs = (struct bstp_state *)malloc(sizeof(*bs), M_DEVBUF, M_WAITOK);
malloc 2008 net/bridgestp.c bp = (struct bstp_port *)malloc(sizeof(*bp), M_DEVBUF, M_NOWAIT);
malloc 237 net/if.c q = (caddr_t)malloc(n, M_IFADDR, M_WAITOK);
malloc 248 net/if.c q = (caddr_t)malloc(n, M_IFADDR, M_WAITOK);
malloc 314 net/if.c ifa = (struct ifaddr *)malloc(ifasize, M_IFADDR, M_WAITOK);
malloc 402 net/if.c ifp->if_addrhooks = malloc(sizeof(*ifp->if_addrhooks),
malloc 407 net/if.c ifp->if_linkstatehooks = malloc(sizeof(*ifp->if_linkstatehooks),
malloc 412 net/if.c ifp->if_detachhooks = malloc(sizeof(*ifp->if_detachhooks),
malloc 433 net/if.c ifp->if_addrhooks = malloc(sizeof(*ifp->if_addrhooks),
malloc 438 net/if.c ifp->if_linkstatehooks = malloc(sizeof(*ifp->if_linkstatehooks),
malloc 443 net/if.c ifp->if_detachhooks = malloc(sizeof(*ifp->if_detachhooks),
malloc 813 net/if.c ifq->ifq_congestion = malloc(sizeof(struct timeout), M_TEMP, M_NOWAIT);
malloc 1597 net/if.c if ((ifg = (struct ifg_group *)malloc(sizeof(struct ifg_group),
malloc 1631 net/if.c if ((ifgl = (struct ifg_list *)malloc(sizeof(struct ifg_list), M_TEMP,
malloc 1635 net/if.c if ((ifgm = (struct ifg_member *)malloc(sizeof(struct ifg_member),
malloc 192 net/if_bridge.c sc = malloc(sizeof(*sc), M_DEVBUF, M_NOWAIT);
malloc 377 net/if_bridge.c p = (struct bridge_iflist *)malloc(
malloc 438 net/if_bridge.c p = (struct bridge_iflist *)malloc(
malloc 809 net/if_bridge.c malloc(sizeof(*breq), M_DEVBUF, M_NOWAIT)) == NULL)
malloc 1691 net/if_bridge.c p = (struct bridge_rtnode *)malloc(
malloc 1731 net/if_bridge.c p = (struct bridge_rtnode *)malloc(
malloc 1753 net/if_bridge.c p = (struct bridge_rtnode *)malloc(
malloc 2163 net/if_bridge.c n = (struct brl_node *)malloc(sizeof(struct brl_node), M_DEVBUF, M_NOWAIT);
malloc 1055 net/if_ethersubr.c enm = (struct ether_multi *)malloc(sizeof(*enm), M_IFMADDR, M_NOWAIT);
malloc 98 net/if_faith.c ifp = malloc(sizeof(*ifp), M_DEVBUF, M_NOWAIT);
malloc 95 net/if_gif.c sc = malloc(sizeof(*sc), M_DEVBUF, M_NOWAIT);
malloc 488 net/if_gif.c sa = (struct sockaddr *)malloc(src->sa_len, M_IFADDR, M_WAITOK);
malloc 494 net/if_gif.c sa = (struct sockaddr *)malloc(dst->sa_len, M_IFADDR, M_WAITOK);
malloc 135 net/if_gre.c sc = malloc(sizeof(*sc), M_DEVBUF, M_NOWAIT);
malloc 144 net/if_media.c entry = malloc(sizeof(*entry), M_IFADDR, M_NOWAIT);
malloc 324 net/if_media.c int *kptr = (int *)malloc(minwords * sizeof(int),
malloc 110 net/if_pflog.c if ((pflogif = malloc(sizeof(*pflogif), M_DEVBUF, M_NOWAIT)) == NULL)
malloc 127 net/if_pfsync.c if ((pfsyncif = malloc(sizeof(*pfsyncif), M_DEVBUF, M_NOWAIT)) == NULL)
malloc 236 net/if_ppp.c sc = malloc(sizeof(*sc), M_DEVBUF, M_NOWAIT);
malloc 574 net/if_pppoe.c sc->sc_hunique = malloc(hunique_len, M_DEVBUF,
malloc 616 net/if_pppoe.c sc->sc_hunique = malloc(hunique_len, M_DEVBUF,
malloc 648 net/if_pppoe.c sc->sc_ac_cookie = malloc(ac_cookie_len, M_DEVBUF,
malloc 879 net/if_pppoe.c char *p = malloc(len + 1, M_DEVBUF, M_WAITOK);
malloc 892 net/if_pppoe.c char *p = malloc(len + 1, M_DEVBUF, M_WAITOK);
malloc 209 net/if_sl.c sc = malloc(sizeof(*sc), M_DEVBUF, M_NOWAIT);
malloc 2014 net/if_spppsubr.c buf = r = malloc (len, M_TEMP, M_NOWAIT);
malloc 2594 net/if_spppsubr.c buf = r = malloc ((len < 6? 6: len), M_TEMP, M_NOWAIT);
malloc 147 net/if_trunk.c if ((tr = malloc(sizeof(struct trunk_softc),
malloc 323 net/if_trunk.c if ((tp = malloc(sizeof(struct trunk_port),
malloc 759 net/if_trunk.c if ((mc = (struct trunk_mc *)malloc(sizeof(struct trunk_mc),
malloc 1325 net/if_trunk.c if ((lb = (struct trunk_lb *)malloc(sizeof(struct trunk_lb),
malloc 169 net/if_tun.c tp = malloc(sizeof(*tp), M_DEVBUF, M_NOWAIT);
malloc 121 net/if_vlan.c ifv = malloc(sizeof(*ifv), M_DEVBUF, M_NOWAIT);
malloc 94 net/pf_if.c pfi_buffer = malloc(pfi_buffer_max * sizeof(*pfi_buffer),
malloc 113 net/pf_if.c if ((kif = malloc(sizeof(*kif), PFI_MTYPE, M_DONTWAIT)) == NULL)
malloc 525 net/pf_if.c p = malloc(new_max * sizeof(*pfi_buffer), PFI_MTYPE,
malloc 382 net/pf_ioctl.c tag = (struct pf_tagname *)malloc(sizeof(struct pf_tagname),
malloc 949 net/pf_ioctl.c malloc(sizeof(caddr_t) *
malloc 1706 net/pf_ioctl.c pstore = malloc(sizeof(*pstore), M_TEMP, M_WAITOK);
malloc 2550 net/pf_ioctl.c ioe = (struct pfioc_trans_e *)malloc(sizeof(*ioe),
malloc 2552 net/pf_ioctl.c table = (struct pfr_table *)malloc(sizeof(*table),
malloc 2619 net/pf_ioctl.c ioe = (struct pfioc_trans_e *)malloc(sizeof(*ioe),
malloc 2621 net/pf_ioctl.c table = (struct pfr_table *)malloc(sizeof(*table),
malloc 2683 net/pf_ioctl.c ioe = (struct pfioc_trans_e *)malloc(sizeof(*ioe),
malloc 2685 net/pf_ioctl.c table = (struct pfr_table *)malloc(sizeof(*table),
malloc 2801 net/pf_ioctl.c pstore = malloc(sizeof(*pstore), M_TEMP, M_WAITOK);
malloc 57 net/pf_osfp.c # define pool_get(pool, flags) malloc(*(pool))
malloc 62 net/pf_ruleset.c #define rs_malloc(x) malloc(x, M_TEMP, M_WAITOK)
malloc 73 net/pf_ruleset.c # define rs_malloc(x) malloc(x)
malloc 180 net/pfkey.c if (!(message = malloc((unsigned long) mbuf->m_pkthdr.len,
malloc 203 net/pfkey.c if (!(socket->so_pcb = malloc(sizeof(struct rawcb),
malloc 315 net/pfkey.c if (!(protosw = malloc(j * sizeof(struct protosw),
malloc 334 net/pfkey.c if (!(protosw = malloc(sizeof(struct protosw), M_PFKEY,
malloc 153 net/pfkeyv2.c if (!(pfkeyv2_socket = malloc(sizeof(struct pfkeyv2_socket),
malloc 221 net/pfkeyv2.c if (!(buffer = malloc(j + sizeof(struct sadb_msg), M_PFKEY,
malloc 383 net/pfkeyv2.c if (!(p = malloc(i, M_PFKEY, M_DONTWAIT))) {
malloc 598 net/pfkeyv2.c if (!(p = malloc(i, M_PFKEY, M_DONTWAIT))) {
malloc 875 net/pfkeyv2.c if (!(freeme = malloc(sizeof(struct sadb_msg) + len, M_PFKEY,
malloc 940 net/pfkeyv2.c if (!(freeme = malloc(sizeof(struct sadb_sa), M_PFKEY,
malloc 1318 net/pfkeyv2.c if (!(freeme = malloc(i, M_PFKEY, M_DONTWAIT))) {
malloc 1338 net/pfkeyv2.c if (!(freeme = malloc(i, M_PFKEY, M_DONTWAIT))) {
malloc 1361 net/pfkeyv2.c if (!(freeme = malloc(i, M_PFKEY, M_DONTWAIT))) {
malloc 1898 net/pfkeyv2.c if (!(p = malloc(i, M_PFKEY, M_DONTWAIT))) {
malloc 2167 net/pfkeyv2.c if (!(p = malloc(i, M_PFKEY, M_DONTWAIT))) {
malloc 2362 net/pfkeyv2.c if (!(p = malloc(i, M_PFKEY, M_DONTWAIT))) {
malloc 132 net/radix.h #define R_Malloc(p, t, n) (p = (t) malloc((unsigned long)(n), M_RTABLE, M_DONTWAIT))
malloc 177 net/route.c if ((p = malloc(sizeof(void *) * (rtafidx_max + 1), M_RTABLE,
malloc 224 net/route.c if ((p = malloc(newlen, M_RTABLE, M_NOWAIT)) == NULL)
malloc 1318 net/route.c label = (struct rt_label *)malloc(sizeof(struct rt_label),
malloc 627 net/rtsock.c rw->w_tmem = malloc(len, M_RTABLE, M_NOWAIT);
malloc 377 net80211/ieee80211_crypto.c ctx = malloc(sizeof(struct rc4_ctx), M_DEVBUF, M_NOWAIT);
malloc 170 netatalk/at_control.c aa0 = malloc(sizeof(struct at_ifaddr), M_IFADDR, M_WAITOK);
malloc 437 netbt/hci_event.c memo = malloc(sizeof(struct hci_memo),
malloc 891 netbt/hci_link.c link = malloc(sizeof *link, M_BLUETOOTH, M_NOWAIT);
malloc 353 netbt/hci_socket.c pcb = malloc(sizeof *pcb, M_PCB, M_NOWAIT);
malloc 70 netbt/l2cap_upper.c chan = malloc(sizeof(struct l2cap_channel), M_BLUETOOTH,
malloc 177 netbt/rfcomm_session.c rs = malloc(sizeof(*rs), M_BLUETOOTH, M_NOWAIT);
malloc 1107 netbt/rfcomm_session.c data = malloc(len, M_BLUETOOTH, M_NOWAIT);
malloc 72 netbt/rfcomm_upper.c dlc = malloc(sizeof(struct rfcomm_dlc), M_BLUETOOTH, M_NOWAIT);
malloc 69 netbt/sco_upper.c pcb = malloc(sizeof(struct sco_pcb), M_BLUETOOTH, M_NOWAIT);
malloc 71 netinet/igmp.c rti = (struct router_info *)malloc(sizeof(struct router_info),
malloc 94 netinet/igmp.c rti = (struct router_info *)malloc(sizeof(struct router_info),
malloc 277 netinet/in.c malloc(sizeof *ia, M_IFADDR, M_WAITOK);
malloc 965 netinet/in.c inm = (struct in_multi *)malloc(sizeof(*inm),
malloc 835 netinet/ip_carp.c sc = malloc(sizeof(*sc), M_DEVBUF, M_NOWAIT);
malloc 1219 netinet/ip_mroute.c rt = (struct mfc *)malloc(sizeof(*rt), M_MRTABLE,
malloc 1455 netinet/ip_mroute.c rte = (struct rtdetq *)malloc(sizeof(*rte),
malloc 1494 netinet/ip_mroute.c rt = (struct mfc *)malloc(sizeof(*rt),
malloc 2463 netinet/ip_mroute.c x = (struct bw_meter *)malloc(sizeof(*x), M_BWMETER, M_NOWAIT);
malloc 1714 netinet/ip_output.c imo = (struct ip_moptions *)malloc(sizeof(*imo), M_IPMOPTS,
malloc 1066 netinet/tcp_subr.c tdbp->tdb_amxkey = malloc(ii->ii_authkeylen, M_XDATA, M_DONTWAIT);
malloc 288 netinet6/frag6.c q6 = (struct ip6q *)malloc(sizeof(struct ip6q), M_FTABLE,
malloc 381 netinet6/frag6.c ip6af = (struct ip6asfrag *)malloc(sizeof(struct ip6asfrag), M_FTABLE,
malloc 265 netinet6/icmp6.c mc = malloc(sizeof(*mc), M_PCB, M_NOWAIT);
malloc 910 netinet6/in6.c ia = (struct in6_ifaddr *) malloc(sizeof(*ia), M_IFADDR,
malloc 1745 netinet6/in6.c mk = malloc(sizeof(*mk), M_IPMADDR, M_WAITOK);
malloc 1804 netinet6/in6.c malloc(sizeof(*in6m), M_IPMADDR, M_NOWAIT);
malloc 1902 netinet6/in6.c imm = malloc(sizeof(*imm), M_IPMADDR, M_NOWAIT);
malloc 2624 netinet6/in6.c ext = (struct in6_ifextra *)malloc(sizeof(*ext), M_IFADDR, M_WAITOK);
malloc 2627 netinet6/in6.c ext->in6_ifstat = (struct in6_ifstat *)malloc(sizeof(struct in6_ifstat),
malloc 2632 netinet6/in6.c (struct icmp6_ifstat *)malloc(sizeof(struct icmp6_ifstat),
malloc 867 netinet6/ip6_mroute.c rt = (struct mf6c *)malloc(sizeof(*rt), M_MRTABLE,
malloc 1092 netinet6/ip6_mroute.c rte = (struct rtdetq *)malloc(sizeof(*rte), M_MRTABLE,
malloc 1130 netinet6/ip6_mroute.c rt = (struct mf6c *)malloc(sizeof(*rt), M_MRTABLE,
malloc 2033 netinet6/ip6_output.c opt = malloc(sizeof(*opt), M_IP6OPT, M_WAITOK);
malloc 2084 netinet6/ip6_output.c *pktopt = malloc(sizeof(struct ip6_pktopts), M_IP6OPT,
malloc 2247 netinet6/ip6_output.c dst->type = malloc(hlen, M_IP6OPT, canwait);\
malloc 2263 netinet6/ip6_output.c dst->ip6po_pktinfo = malloc(sizeof(*dst->ip6po_pktinfo),
malloc 2270 netinet6/ip6_output.c dst->ip6po_nexthop = malloc(src->ip6po_nexthop->sa_len,
malloc 2303 netinet6/ip6_output.c dst = malloc(sizeof(*dst), M_IP6OPT, canwait);
malloc 2353 netinet6/ip6_output.c malloc(sizeof(*im6o), M_IPMOPTS, M_WAITOK);
malloc 2852 netinet6/ip6_output.c opt->ip6po_pktinfo = malloc(sizeof(*pktinfo),
malloc 2941 netinet6/ip6_output.c opt->ip6po_nexthop = malloc(*buf, M_IP6OPT, M_NOWAIT);
malloc 2976 netinet6/ip6_output.c opt->ip6po_hbh = malloc(hbhlen, M_IP6OPT, M_NOWAIT);
malloc 3039 netinet6/ip6_output.c *newdest = malloc(destlen, M_IP6OPT, M_NOWAIT);
malloc 3080 netinet6/ip6_output.c opt->ip6po_rthdr = malloc(rthlen, M_IP6OPT, M_NOWAIT);
malloc 144 netinet6/nd6.c nd = (struct nd_ifinfo *)malloc(sizeof(*nd), M_IP6NDP, M_WAITOK);
malloc 2004 netinet6/nd6.c p = malloc(*oldlenp, M_TEMP, M_WAITOK);
malloc 1106 netinet6/nd6_nbr.c dp = malloc(sizeof(*dp), M_IP6NDP, M_NOWAIT);
malloc 785 netinet6/nd6_rtr.c n = (struct nd_defrouter *)malloc(sizeof(*n), M_IP6NDP, M_NOWAIT);
malloc 841 netinet6/nd6_rtr.c new = (struct nd_pfxrouter *)malloc(sizeof(*new), M_IP6NDP, M_NOWAIT);
malloc 886 netinet6/nd6_rtr.c new = (struct nd_prefix *)malloc(sizeof(*new), M_IP6NDP, M_NOWAIT);
malloc 148 nfs/nfs_node.c np->n_fhp = malloc(fhsize, M_NFSBIGFH, M_WAITOK);
malloc 220 nfs/nfs_srvcache.c rp = (struct nfsrvcache *)malloc((u_long)sizeof *rp,
malloc 257 nfs/nfs_syscalls.c malloc(sizeof (struct nfssvc_sock), M_NFSSVC, M_WAITOK);
malloc 304 nfs/nfs_syscalls.c malloc(sizeof (struct nfsd), M_NFSD, M_WAITOK);
malloc 646 nfs/nfs_syscalls.c malloc(sizeof (struct nfssvc_sock), M_NFSSVC, M_WAITOK);
malloc 838 nfs/nfs_syscalls.c nmp->nm_authstr = *auth_str = (char *)malloc(RPCAUTH_MAXSIZ, M_TEMP, M_WAITOK);
malloc 907 nfs/nfs_syscalls.c nickp = (u_int32_t *)malloc(2 * NFSX_UNSIGNED, M_TEMP, M_WAITOK);
malloc 974 nfs/nfs_syscalls.c malloc(sizeof (struct nfsuid), M_NFSUID,
malloc 2489 nfs/nfs_vnops.c np->n_fhp =(nfsfh_t *)malloc(fhlen,M_NFSBIGFH,M_WAITOK);
malloc 225 ntfs/ntfs_subr.c alpool = (caddr_t) malloc(len, M_TEMP, M_WAITOK);
malloc 303 ntfs/ntfs_subr.c mfrp = (struct filerec *) malloc(ntfs_bntob(ntmp->ntm_bpmftrec),
malloc 625 ntfs/ntfs_subr.c vap->va_datap = (caddr_t) malloc(vap->va_datalen,
malloc 667 ntfs/ntfs_subr.c cn = (cn_t *) malloc(cnt * sizeof(cn_t), M_NTFSRUN, M_WAITOK);
malloc 668 ntfs/ntfs_subr.c cl = (cn_t *) malloc(cnt * sizeof(cn_t), M_NTFSRUN, M_WAITOK);
malloc 884 ntfs/ntfs_subr.c *attrname = (char *) malloc(namelen, M_TEMP, M_WAITOK);
malloc 959 ntfs/ntfs_subr.c rdbuf = (caddr_t) malloc(blsize, M_TEMP, M_WAITOK);
malloc 1250 ntfs/ntfs_subr.c fp->f_dirblbuf = (caddr_t) malloc(
malloc 1266 ntfs/ntfs_subr.c bmp = (u_int8_t *) malloc(bmvap->va_datalen, M_TEMP, M_WAITOK);
malloc 546 ntfs/ntfs_vfsops.c ntmp = malloc(sizeof *ntmp, M_NTFSMNT, M_WAITOK);
malloc 652 ntfs/ntfs_vfsops.c ntmp->ntm_ad = (struct ntvattrdef *) malloc(
malloc 852 ntfs/ntfs_vfsops.c tmp = (u_int8_t *) malloc(bmsize, M_TEMP, M_WAITOK);
malloc 673 ntfs/ntfs_vnops.c cookies = malloc(ncookies * sizeof(off_t), M_TEMP, M_WAITOK);
malloc 825 scsi/cd.c lp = malloc(sizeof(*lp), M_TEMP, M_WAITOK);
malloc 1272 scsi/cd.c data = malloc(sizeof(*data), M_TEMP, M_NOWAIT);
malloc 1305 scsi/cd.c data = malloc(sizeof(*data), M_TEMP, M_NOWAIT);
malloc 1333 scsi/cd.c data = malloc(sizeof(*data), M_TEMP, M_NOWAIT);
malloc 1402 scsi/cd.c data = malloc(sizeof(*data), M_TEMP, M_NOWAIT);
malloc 1869 scsi/cd.c buf = malloc(sizeof(*buf), M_TEMP, M_WAITOK);
malloc 1925 scsi/cd.c buf = malloc(sizeof(*buf), M_TEMP, M_WAITOK);
malloc 569 scsi/ch.c data = (caddr_t)malloc(1024, M_DEVBUF, M_WAITOK);
malloc 589 scsi/ch.c data = (caddr_t)malloc(size, M_DEVBUF, M_WAITOK);
malloc 609 scsi/ch.c user_data = malloc(udsize, M_DEVBUF, M_WAITOK);
malloc 677 scsi/ch.c data = malloc(sizeof(*data), M_TEMP, M_NOWAIT);
malloc 288 scsi/safte.c sc->sc_encbuf = malloc(sc->sc_encbuflen, M_DEVBUF, M_NOWAIT);
malloc 295 scsi/safte.c sc->sc_sensors = malloc(sc->sc_nsensors * sizeof(struct safte_sensor),
malloc 564 scsi/safte.c op = malloc(sizeof(struct safte_slotop), M_TEMP, 0);
malloc 118 scsi/scsi_ioctl.c si = malloc(sizeof(struct scsi_ioctl), M_TEMP, M_WAITOK);
malloc 166 scsi/scsiconf.c sb->sc_link = malloc(nbytes, M_DEVBUF, M_NOWAIT);
malloc 171 scsi/scsiconf.c sb->sc_link[i] = malloc(nbytes, M_DEVBUF, M_NOWAIT);
malloc 306 scsi/scsiconf.c report = malloc(sizeof(*report), M_TEMP, M_WAITOK);
malloc 708 scsi/scsiconf.c sc_link = malloc(sizeof(*sc_link), M_DEVBUF, M_NOWAIT);
malloc 861 scsi/sd.c lp = malloc(sizeof(*lp), M_TEMP, M_WAITOK);
malloc 1329 scsi/sd.c buf = malloc(sizeof(*buf), M_TEMP, M_NOWAIT);
malloc 274 scsi/ses.c buf = malloc(SES_BUFLEN, M_DEVBUF, M_NOWAIT);
malloc 344 scsi/ses.c sc->sc_buf = malloc(sc->sc_buflen, M_DEVBUF, M_NOWAIT);
malloc 430 scsi/ses.c slot = malloc(sizeof(struct ses_slot),
malloc 463 scsi/ses.c sensor = malloc(sizeof(struct ses_sensor), M_DEVBUF,
malloc 1342 scsi/st.c data = malloc(sizeof(*data), M_TEMP, M_NOWAIT);
malloc 1400 scsi/st.c inbuf = malloc(sizeof(*inbuf), M_TEMP, M_NOWAIT);
malloc 1403 scsi/st.c outbuf = malloc(sizeof(*outbuf), M_TEMP, M_NOWAIT);
malloc 2004 scsi/st.c buf = malloc(1024, M_TEMP, M_NOWAIT);
malloc 398 sys/malloc.h (space) = (cast)malloc((u_long)(size), type, flags)
malloc 407 sys/malloc.h (space) = (cast)malloc(kbp_size, type, flags); \
malloc 439 sys/malloc.h extern void *malloc(unsigned long size, int type, int flags);
malloc 278 sys/mbuf.h (caddr_t)malloc((size), mbtypes[(m)->m_type], (how)); \
malloc 166 ufs/ext2fs/ext2fs_lookup.c cookies = malloc(sizeof (off_t) * ncookies, M_TEMP, M_WAITOK);
malloc 525 ufs/ext2fs/ext2fs_vfsops.c ump = malloc(sizeof *ump, M_UFSMNT, M_WAITOK);
malloc 527 ufs/ext2fs/ext2fs_vfsops.c ump->um_e2fs = malloc(sizeof(struct m_ext2fs), M_UFSMNT, M_WAITOK);
malloc 558 ufs/ext2fs/ext2fs_vfsops.c m_fs->e2fs_gd = malloc(m_fs->e2fs_ngdb * m_fs->e2fs_bsize,
malloc 3357 ufs/ffs/ffs_softdep.c indirdep->ir_saveddata = malloc(bp->b_bcount,
malloc 312 ufs/ffs/ffs_vfsops.c fs->fs_contigdirs=(u_int8_t*)malloc((u_long)fs->fs_ncg,
malloc 790 ufs/ffs/ffs_vfsops.c ump = malloc(sizeof *ump, M_UFSMNT, M_WAITOK);
malloc 792 ufs/ffs/ffs_vfsops.c ump->um_fs = malloc((u_long)fs->fs_sbsize, M_UFSMNT,
malloc 818 ufs/ffs/ffs_vfsops.c space = malloc((u_long)size, M_UFSMNT, M_WAITOK);
malloc 864 ufs/ffs/ffs_vfsops.c fs->fs_contigdirs = (u_int8_t*)malloc((u_long)fs->fs_ncg,
malloc 105 ufs/mfs/mfs_vfsops.c mfsp = malloc(sizeof *mfsp, M_MFSNODE, M_WAITOK);
malloc 208 ufs/mfs/mfs_vfsops.c mfsp = malloc(sizeof *mfsp, M_MFSNODE, M_WAITOK);
malloc 177 ufs/ufs/ufs_dirhash.c dh->dh_hash = malloc(narrays * sizeof(dh->dh_hash[0]),
malloc 179 ufs/ufs/ufs_dirhash.c dh->dh_blkfree = malloc(nblocks * sizeof(dh->dh_blkfree[0]),
malloc 837 ufs/ufs/ufs_quota.c dq = (struct dquot *)malloc(sizeof *dq, M_DQUOT, M_WAITOK);
malloc 204 uvm/uvm_amap.c amap->am_slots = malloc(totalslots * sizeof(int), M_UVMAMAP,
malloc 209 uvm/uvm_amap.c amap->am_bckptr = malloc(totalslots * sizeof(int), M_UVMAMAP, waitf);
malloc 213 uvm/uvm_amap.c amap->am_anon = malloc(totalslots * sizeof(struct vm_anon *),
malloc 376 uvm/uvm_amap.c newppref = malloc(slotalloc *sizeof(int), M_UVMAMAP,
malloc 385 uvm/uvm_amap.c newsl = malloc(slotalloc * sizeof(int), M_UVMAMAP,
malloc 387 uvm/uvm_amap.c newbck = malloc(slotalloc * sizeof(int), M_UVMAMAP,
malloc 389 uvm/uvm_amap.c newover = malloc(slotalloc * sizeof(struct vm_anon *), M_UVMAMAP,
malloc 904 uvm/uvm_amap.c amap->am_ppref = malloc(sizeof(int) * amap->am_maxslot,
malloc 526 uvm/uvm_aobj.c aobj->u_swslots = malloc(pages * sizeof(int),
malloc 164 uvm/uvm_stat.h malloc(sizeof(struct uvm_history_ent) * (N), M_TEMP, \
malloc 347 uvm/uvm_swap.c sdp->swd_decrypt = malloc(SWD_DCRYPT_SIZE(npages), M_VMSWAP, M_WAITOK);
malloc 349 uvm/uvm_swap.c sdp->swd_keys = malloc((npages >> SWD_KEY_SHIFT) * sizeof(struct swap_key),
malloc 773 uvm/uvm_swap.c spp = malloc(sizeof *spp, M_VMSWAP, M_WAITOK);
malloc 802 uvm/uvm_swap.c sdp = malloc(sizeof *sdp, M_VMSWAP, M_WAITOK);
malloc 803 uvm/uvm_swap.c spp = malloc(sizeof *spp, M_VMSWAP, M_WAITOK);
malloc 820 uvm/uvm_swap.c sdp->swd_path = malloc(sdp->swd_pathlen, M_VMSWAP, M_WAITOK);
malloc 2094 uvm/uvm_swap.c sdp = malloc(sizeof(*sdp), M_VMSWAP, M_WAITOK);
malloc 2095 uvm/uvm_swap.c spp = malloc(sizeof(*spp), M_VMSWAP, M_WAITOK);
malloc 2103 uvm/uvm_swap.c sdp->swd_path = malloc(sdp->swd_pathlen, M_VMSWAP, M_WAITOK);
malloc 57 xfs/xfs_common.h #define xfs_alloc(a,t) malloc((a), BUCKETINDEX(a), t, M_WAITOK)
malloc 59 xfs/xfs_common.h #define xfs_alloc(a,t) malloc((a), t, M_WAITOK)
malloc 1665 xfs/xfs_config.h #define isoc_realloc(X, Y) ((X) ? realloc((X), (Y)) : malloc(Y))
malloc 499 xfs/xfs_syscalls-common.c msg = malloc(sizeof(struct xfs_message_symlink), M_TEMP, M_WAITOK);
malloc 204 xfs/xfs_vfsops-common.c data = malloc(MAXPATHLEN, M_TEMP, M_WAITOK);
malloc 209 xfs/xfs_vfsops-common.c path = malloc(MAXPATHLEN, M_TEMP, M_WAITOK);
malloc 934 xfs/xfs_vnodeops-common.c msg = malloc(sizeof(struct xfs_message_symlink), M_TEMP, M_WAITOK);