GFP_KERNEL 194 arch/x86/kernel/acpi/boot.c pci_mmcfg_config = kmalloc(config_size, GFP_KERNEL);
GFP_KERNEL 22 arch/x86/kernel/acpi/processor.c obj_list = kmalloc(sizeof(struct acpi_object_list), GFP_KERNEL);
GFP_KERNEL 28 arch/x86/kernel/acpi/processor.c obj = kmalloc(sizeof(union acpi_object), GFP_KERNEL);
GFP_KERNEL 35 arch/x86/kernel/acpi/processor.c buf = kmalloc(12, GFP_KERNEL);
GFP_KERNEL 291 arch/x86/kernel/alternative.c smp = kzalloc(sizeof(*smp), GFP_KERNEL);
GFP_KERNEL 355 arch/x86/kernel/amd_iommu.c page = (u64 *)get_zeroed_page(GFP_KERNEL);
GFP_KERNEL 365 arch/x86/kernel/amd_iommu.c page = (u64 *)get_zeroed_page(GFP_KERNEL);
GFP_KERNEL 649 arch/x86/kernel/amd_iommu.c dma_dom = kzalloc(sizeof(struct dma_ops_domain), GFP_KERNEL);
GFP_KERNEL 659 arch/x86/kernel/amd_iommu.c dma_dom->domain.pt_root = (void *)get_zeroed_page(GFP_KERNEL);
GFP_KERNEL 665 arch/x86/kernel/amd_iommu.c GFP_KERNEL);
GFP_KERNEL 694 arch/x86/kernel/amd_iommu.c GFP_KERNEL);
GFP_KERNEL 698 arch/x86/kernel/amd_iommu.c l2_pde = (u64 *)get_zeroed_page(GFP_KERNEL);
GFP_KERNEL 705 arch/x86/kernel/amd_iommu.c dma_dom->pte_pages[i] = (u64 *)get_zeroed_page(GFP_KERNEL);
GFP_KERNEL 416 arch/x86/kernel/amd_iommu_init.c u8 *cmd_buf = (u8 *)__get_free_pages(GFP_KERNEL | __GFP_ZERO,
GFP_KERNEL 445 arch/x86/kernel/amd_iommu_init.c iommu->evt_buf = (u8 *)__get_free_pages(GFP_KERNEL | __GFP_ZERO,
GFP_KERNEL 747 arch/x86/kernel/amd_iommu_init.c iommu = kzalloc(sizeof(struct amd_iommu), GFP_KERNEL);
GFP_KERNEL 901 arch/x86/kernel/amd_iommu_init.c e = kzalloc(sizeof(*e), GFP_KERNEL);
GFP_KERNEL 1062 arch/x86/kernel/amd_iommu_init.c amd_iommu_dev_table = (void *)__get_free_pages(GFP_KERNEL | __GFP_ZERO,
GFP_KERNEL 1071 arch/x86/kernel/amd_iommu_init.c amd_iommu_alias_table = (void *)__get_free_pages(GFP_KERNEL,
GFP_KERNEL 1077 arch/x86/kernel/amd_iommu_init.c amd_iommu_rlookup_table = (void *)__get_free_pages(GFP_KERNEL,
GFP_KERNEL 1086 arch/x86/kernel/amd_iommu_init.c amd_iommu_pd_table = (void *)__get_free_pages(GFP_KERNEL | __GFP_ZERO,
GFP_KERNEL 1092 arch/x86/kernel/amd_iommu_init.c GFP_KERNEL | __GFP_ZERO,
GFP_KERNEL 1553 arch/x86/kernel/apm_32.c as = kmalloc(sizeof(*as), GFP_KERNEL);
GFP_KERNEL 580 arch/x86/kernel/cpu/cpufreq/acpi-cpufreq.c data = kzalloc(sizeof(struct acpi_cpufreq_data), GFP_KERNEL);
GFP_KERNEL 648 arch/x86/kernel/cpu/cpufreq/acpi-cpufreq.c (perf->state_count+1), GFP_KERNEL);
GFP_KERNEL 258 arch/x86/kernel/cpu/cpufreq/e_powersaver.c GFP_KERNEL);
GFP_KERNEL 459 arch/x86/kernel/cpu/cpufreq/gx-suspmod.c params = kzalloc(sizeof(struct gxfreq_params), GFP_KERNEL);
GFP_KERNEL 480 arch/x86/kernel/cpu/cpufreq/longhaul.c longhaul_table = kmalloc((numscales + 1) * sizeof(struct cpufreq_frequency_table), GFP_KERNEL);
GFP_KERNEL 173 arch/x86/kernel/cpu/cpufreq/powernow-k7.c powernow_table = kzalloc((sizeof(struct cpufreq_frequency_table) * (number_scales + 1)), GFP_KERNEL);
GFP_KERNEL 307 arch/x86/kernel/cpu/cpufreq/powernow-k7.c GFP_KERNEL);
GFP_KERNEL 335 arch/x86/kernel/cpu/cpufreq/powernow-k7.c powernow_table = kzalloc((number_scales + 1) * (sizeof(struct cpufreq_frequency_table)), GFP_KERNEL);
GFP_KERNEL 621 arch/x86/kernel/cpu/cpufreq/powernow-k8.c * (data->numps + 1)), GFP_KERNEL);
GFP_KERNEL 777 arch/x86/kernel/cpu/cpufreq/powernow-k8.c * (data->acpi_data.state_count + 1)), GFP_KERNEL);
GFP_KERNEL 1113 arch/x86/kernel/cpu/cpufreq/powernow-k8.c data = kzalloc(sizeof(struct powernow_k8_data), GFP_KERNEL);
GFP_KERNEL 548 arch/x86/kernel/cpu/intel_cacheinfo.c sizeof(struct _cpuid4_info) * num_cache_leaves, GFP_KERNEL);
GFP_KERNEL 856 arch/x86/kernel/cpu/intel_cacheinfo.c kzalloc(sizeof(struct kobject), GFP_KERNEL);
GFP_KERNEL 861 arch/x86/kernel/cpu/intel_cacheinfo.c sizeof(struct _index_kobject ) * num_cache_leaves, GFP_KERNEL);
GFP_KERNEL 583 arch/x86/kernel/cpu/mcheck/mce_64.c cpu_tsc = kmalloc(nr_cpu_ids * sizeof(long), GFP_KERNEL);
GFP_KERNEL 416 arch/x86/kernel/cpu/mcheck/mce_amd_64.c b = kzalloc(sizeof(struct threshold_block), GFP_KERNEL);
GFP_KERNEL 504 arch/x86/kernel/cpu/mcheck/mce_amd_64.c b = kzalloc(sizeof(struct threshold_bank), GFP_KERNEL);
GFP_KERNEL 43 arch/x86/kernel/cpu/mtrr/if.c fcount = kzalloc(max * sizeof *fcount, GFP_KERNEL);
GFP_KERNEL 66 arch/x86/kernel/crash_dump_32.c kdump_buf_page = kmalloc(PAGE_SIZE, GFP_KERNEL);
GFP_KERNEL 239 arch/x86/kernel/ds.c context = kzalloc(sizeof(*context), GFP_KERNEL);
GFP_KERNEL 244 arch/x86/kernel/ds.c context->ds = kzalloc(ds_cfg.sizeof_ds, GFP_KERNEL);
GFP_KERNEL 352 arch/x86/kernel/ds.c buffer = kzalloc(size, GFP_KERNEL);
GFP_KERNEL 131 arch/x86/kernel/i387.c GFP_KERNEL);
GFP_KERNEL 715 arch/x86/kernel/io_apic_32.c irq_cpu_data[i].irq_delta = kzalloc(sizeof(unsigned long) * NR_IRQS, GFP_KERNEL);
GFP_KERNEL 716 arch/x86/kernel/io_apic_32.c irq_cpu_data[i].last_irq = kzalloc(sizeof(unsigned long) * NR_IRQS, GFP_KERNEL);
GFP_KERNEL 2419 arch/x86/kernel/io_apic_32.c mp_ioapic_data[i] = kzalloc(size, GFP_KERNEL);
GFP_KERNEL 475 arch/x86/kernel/io_apic_64.c nr_ioapic_registers[apic], GFP_KERNEL);
GFP_KERNEL 2248 arch/x86/kernel/io_apic_64.c mp_ioapic_data[i] = kzalloc(size, GFP_KERNEL);
GFP_KERNEL 53 arch/x86/kernel/ioport.c unsigned long *bitmap = kmalloc(IO_BITMAP_BYTES, GFP_KERNEL);
GFP_KERNEL 52 arch/x86/kernel/k8.c GFP_KERNEL);
GFP_KERNEL 61 arch/x86/kernel/k8.c flush_words = kmalloc(num_k8_northbridges * sizeof(u32), GFP_KERNEL);
GFP_KERNEL 133 arch/x86/kernel/kdebugfs.c node = kmalloc(sizeof(*node), GFP_KERNEL);
GFP_KERNEL 44 arch/x86/kernel/ldt.c newldt = (void *)__get_free_page(GFP_KERNEL);
GFP_KERNEL 291 arch/x86/kernel/mca_32.c mca_dev = kzalloc(sizeof(struct mca_device), GFP_KERNEL);
GFP_KERNEL 57 arch/x86/kernel/module_64.c return __vmalloc_area(area, GFP_KERNEL, PAGE_KERNEL_EXEC);
GFP_KERNEL 142 arch/x86/kernel/nmi.c prev_nmi_count = kmalloc(nr_cpu_ids * sizeof(int), GFP_KERNEL);
GFP_KERNEL 676 arch/x86/kernel/pci-gart_64.c gatt = (void *)__get_free_pages(GFP_KERNEL | __GFP_ZERO,
GFP_KERNEL 793 arch/x86/kernel/pci-gart_64.c iommu_gart_bitmap = (void *) __get_free_pages(GFP_KERNEL | __GFP_ZERO,
GFP_KERNEL 800 arch/x86/kernel/pci-gart_64.c iommu_leak_tab = (void *)__get_free_pages(GFP_KERNEL|__GFP_ZERO,
GFP_KERNEL 851 arch/x86/kernel/pci-gart_64.c scratch = get_zeroed_page(GFP_KERNEL);
GFP_KERNEL 24 arch/x86/kernel/process.c GFP_KERNEL);
GFP_KERNEL 321 arch/x86/kernel/process_32.c IO_BITMAP_BYTES, GFP_KERNEL);
GFP_KERNEL 344 arch/x86/kernel/process_64.c p->thread.io_bitmap_ptr = kmalloc(IO_BITMAP_BYTES, GFP_KERNEL);
GFP_KERNEL 113 arch/x86/kernel/tce_64.c bmppages = __get_free_pages(GFP_KERNEL, get_order(bitmapsz));
GFP_KERNEL 145 arch/x86/kernel/tce_64.c tbl = kzalloc(sizeof(struct iommu_table), GFP_KERNEL);
GFP_KERNEL 128 arch/x86/kernel/test_nx.c heap = kmalloc(64, GFP_KERNEL);
GFP_KERNEL 594 arch/x86/kernel/tlb_uv.c kmalloc_node(sizeof(struct bau_control), GFP_KERNEL, node);
GFP_KERNEL 599 arch/x86/kernel/tlb_uv.c DEST_Q_SIZE, GFP_KERNEL, node);
GFP_KERNEL 607 arch/x86/kernel/tlb_uv.c kmalloc_node(sizeof(int) * DEST_NUM_RESOURCES, GFP_KERNEL, node);
GFP_KERNEL 656 arch/x86/kernel/tlb_uv.c kmalloc_node(16384, GFP_KERNEL, node);
GFP_KERNEL 696 arch/x86/kernel/tlb_uv.c GFP_KERNEL, node);
GFP_KERNEL 775 arch/x86/kernel/tlb_uv.c kmalloc(nblades * sizeof(struct bau_control *), GFP_KERNEL);
GFP_KERNEL 531 arch/x86/kvm/i8254.c pit = kzalloc(sizeof(struct kvm_pit), GFP_KERNEL);
GFP_KERNEL 434 arch/x86/kvm/i8259.c s = kzalloc(sizeof(struct kvm_pic), GFP_KERNEL);
GFP_KERNEL 1003 arch/x86/kvm/lapic.c apic = kzalloc(sizeof(*apic), GFP_KERNEL);
GFP_KERNEL 1009 arch/x86/kvm/lapic.c apic->regs_page = alloc_page(GFP_KERNEL);
GFP_KERNEL 262 arch/x86/kvm/mmu.c obj = kmem_cache_zalloc(base_cache, GFP_KERNEL);
GFP_KERNEL 284 arch/x86/kvm/mmu.c page = alloc_page(GFP_KERNEL);
GFP_KERNEL 2015 arch/x86/kvm/mmu.c page = alloc_page(GFP_KERNEL | __GFP_DMA32);
GFP_KERNEL 337 arch/x86/kvm/svm.c svm_data = kzalloc(sizeof(struct svm_cpu_data), GFP_KERNEL);
GFP_KERNEL 341 arch/x86/kvm/svm.c svm_data->save_area = alloc_page(GFP_KERNEL);
GFP_KERNEL 425 arch/x86/kvm/svm.c iopm_pages = alloc_pages(GFP_KERNEL, IOPM_ALLOC_ORDER);
GFP_KERNEL 633 arch/x86/kvm/svm.c svm = kmem_cache_zalloc(kvm_vcpu_cache, GFP_KERNEL);
GFP_KERNEL 643 arch/x86/kvm/svm.c page = alloc_page(GFP_KERNEL);
GFP_KERNEL 650 arch/x86/kvm/svm.c msrpm_pages = alloc_pages(GFP_KERNEL, MSRPM_ALLOC_ORDER);
GFP_KERNEL 1211 arch/x86/kvm/vmx.c pages = alloc_pages_node(node, GFP_KERNEL, vmcs_config.order);
GFP_KERNEL 3114 arch/x86/kvm/vmx.c struct vcpu_vmx *vmx = kmem_cache_zalloc(kvm_vcpu_cache, GFP_KERNEL);
GFP_KERNEL 3126 arch/x86/kvm/vmx.c vmx->guest_msrs = kmalloc(PAGE_SIZE, GFP_KERNEL);
GFP_KERNEL 3132 arch/x86/kvm/vmx.c vmx->host_msrs = kmalloc(PAGE_SIZE, GFP_KERNEL);
GFP_KERNEL 3254 arch/x86/kvm/vmx.c vmx_io_bitmap_a = alloc_page(GFP_KERNEL | __GFP_HIGHMEM);
GFP_KERNEL 3258 arch/x86/kvm/vmx.c vmx_io_bitmap_b = alloc_page(GFP_KERNEL | __GFP_HIGHMEM);
GFP_KERNEL 3264 arch/x86/kvm/vmx.c vmx_msr_bitmap = alloc_page(GFP_KERNEL | __GFP_HIGHMEM);
GFP_KERNEL 3877 arch/x86/kvm/x86.c page = alloc_page(GFP_KERNEL | __GFP_ZERO);
GFP_KERNEL 3915 arch/x86/kvm/x86.c struct kvm *kvm = kzalloc(sizeof(struct kvm), GFP_KERNEL);
GFP_KERNEL 653 arch/x86/mach-voyager/voyager_cat.c *modpp = kmalloc(sizeof(voyager_module_t), GFP_KERNEL); /*&voyager_module_storage[cat_count++]; */
GFP_KERNEL 661 arch/x86/mach-voyager/voyager_cat.c (*modpp)->asic = kmalloc(sizeof(voyager_asic_t), GFP_KERNEL); /*&voyager_asic_storage[asic_count]; */
GFP_KERNEL 790 arch/x86/mach-voyager/voyager_cat.c voyager_asic_t *asicp = *asicpp = kzalloc(sizeof(voyager_asic_t), GFP_KERNEL); /*&voyager_asic_storage[asic_count++]; */
GFP_KERNEL 871 arch/x86/mach-voyager/voyager_cat.c kzalloc(sizeof(struct resource), GFP_KERNEL);
GFP_KERNEL 872 arch/x86/mach-voyager/voyager_cat.c res->name = kmalloc(128, GFP_KERNEL);
GFP_KERNEL 112 arch/x86/mm/mmio-mod.c event = kzalloc(sizeof(*headp) + len, GFP_KERNEL);
GFP_KERNEL 282 arch/x86/mm/mmio-mod.c struct remap_trace *trace = kmalloc(sizeof(*trace), GFP_KERNEL);
GFP_KERNEL 468 arch/x86/mm/pageattr.c base = alloc_pages(GFP_KERNEL, 0);
GFP_KERNEL 342 arch/x86/mm/pat.c new = kmalloc(sizeof(struct memtype), GFP_KERNEL);
GFP_KERNEL 603 arch/x86/mm/pat.c print_entry = kmalloc(sizeof(struct memtype), GFP_KERNEL);
GFP_KERNEL 9 arch/x86/mm/pgtable.c return (pte_t *)__get_free_page(GFP_KERNEL|__GFP_REPEAT|__GFP_ZERO);
GFP_KERNEL 17 arch/x86/mm/pgtable.c pte = alloc_pages(GFP_KERNEL|__GFP_HIGHMEM|__GFP_REPEAT|__GFP_ZERO, 0);
GFP_KERNEL 19 arch/x86/mm/pgtable.c pte = alloc_pages(GFP_KERNEL|__GFP_REPEAT|__GFP_ZERO, 0);
GFP_KERNEL 164 arch/x86/mm/pgtable.c pmd_t *pmd = (pmd_t *)get_zeroed_page(GFP_KERNEL|__GFP_REPEAT);
GFP_KERNEL 231 arch/x86/mm/pgtable.c pgd = (pgd_t *)__get_free_page(GFP_KERNEL | __GFP_ZERO);
GFP_KERNEL 180 arch/x86/oprofile/nmi_int.c GFP_KERNEL);
GFP_KERNEL 186 arch/x86/oprofile/nmi_int.c GFP_KERNEL);
GFP_KERNEL 128 arch/x86/pci/acpi.c info.res = kmalloc(size, GFP_KERNEL);
GFP_KERNEL 132 arch/x86/pci/acpi.c info.name = kmalloc(16, GFP_KERNEL);
GFP_KERNEL 184 arch/x86/pci/acpi.c sd = kzalloc(sizeof(*sd), GFP_KERNEL);
GFP_KERNEL 389 arch/x86/pci/common.c sd = kzalloc(sizeof(*sd), GFP_KERNEL);
GFP_KERNEL 559 arch/x86/pci/common.c sd = kzalloc(sizeof(*sd), GFP_KERNEL);
GFP_KERNEL 38 arch/x86/pci/mmconfig-shared.c pci_mmcfg_config = kzalloc(sizeof(pci_mmcfg_config[0]), GFP_KERNEL);
GFP_KERNEL 91 arch/x86/pci/mmconfig-shared.c pci_mmcfg_config = kzalloc(sizeof(pci_mmcfg_config[0]), GFP_KERNEL);
GFP_KERNEL 144 arch/x86/pci/mmconfig-shared.c pci_mmcfg_config_num, GFP_KERNEL);
GFP_KERNEL 221 arch/x86/pci/mmconfig-shared.c pci_mmcfg_config_num, GFP_KERNEL);
GFP_KERNEL 131 arch/x86/pci/mmconfig_64.c pci_mmcfg_config_num, GFP_KERNEL);
GFP_KERNEL 363 arch/x86/pci/pcbios.c page = __get_free_page(GFP_KERNEL);
GFP_KERNEL 392 arch/x86/pci/pcbios.c rt = kmalloc(sizeof(struct irq_routing_table) + opt.size, GFP_KERNEL);
GFP_KERNEL 43 arch/x86/vdso/vma.c vdso_pages = kmalloc(sizeof(struct page *) * npages, GFP_KERNEL);
GFP_KERNEL 48 arch/x86/vdso/vma.c p = alloc_page(GFP_KERNEL);
GFP_KERNEL 65 arch/x86/xen/debugfs.c ret = kmalloc(len, GFP_KERNEL);
GFP_KERNEL 114 arch/x86/xen/debugfs.c struct array_data *data = kmalloc(sizeof(*data), GFP_KERNEL);
GFP_KERNEL 903 arch/x86/xen/enlighten.c user_pgd = (pgd_t *)__get_free_page(GFP_KERNEL | __GFP_ZERO);
GFP_KERNEL 207 arch/x86/xen/mmu.c p = (void *)__get_free_page(GFP_KERNEL | __GFP_NOFAIL);
GFP_KERNEL 101 arch/x86/xen/smp.c resched_name = kasprintf(GFP_KERNEL, "resched%d", cpu);
GFP_KERNEL 112 arch/x86/xen/smp.c callfunc_name = kasprintf(GFP_KERNEL, "callfunc%d", cpu);
GFP_KERNEL 123 arch/x86/xen/smp.c debug_name = kasprintf(GFP_KERNEL, "debug%d", cpu);
GFP_KERNEL 131 arch/x86/xen/smp.c callfunc_name = kasprintf(GFP_KERNEL, "callfuncsingle%d", cpu);
GFP_KERNEL 227 arch/x86/xen/smp.c ctxt = kzalloc(sizeof(*ctxt), GFP_KERNEL);
GFP_KERNEL 344 arch/x86/xen/spinlock.c name = kasprintf(GFP_KERNEL, "spinlock%d", cpu);
GFP_KERNEL 436 arch/x86/xen/time.c name = kasprintf(GFP_KERNEL, "timer%d", cpu);
GFP_KERNEL 1363 block/as-iosched.c ad = kmalloc_node(sizeof(*ad), GFP_KERNEL | __GFP_ZERO, q->node);
GFP_KERNEL 289 block/blk-barrier.c bio = bio_alloc(GFP_KERNEL, 0);
GFP_KERNEL 556 block/blk-core.c struct request_queue *q = blk_alloc_queue_node(GFP_KERNEL, node_id);
GFP_KERNEL 329 block/blk-integrity.c GFP_KERNEL | __GFP_ZERO);
GFP_KERNEL 298 block/blktrace.c msg = kmalloc(count, GFP_KERNEL);
GFP_KERNEL 384 block/blktrace.c bt = kzalloc(sizeof(*bt), GFP_KERNEL);
GFP_KERNEL 116 block/bsg.c bc = kmem_cache_zalloc(bsg_cmd_cachep, GFP_KERNEL);
GFP_KERNEL 179 block/bsg.c rq->cmd = kzalloc(hdr->request_len, GFP_KERNEL);
GFP_KERNEL 264 block/bsg.c rq = blk_get_request(q, rw, GFP_KERNEL);
GFP_KERNEL 277 block/bsg.c next_rq = blk_get_request(q, READ, GFP_KERNEL);
GFP_KERNEL 287 block/bsg.c hdr->din_xfer_len, GFP_KERNEL);
GFP_KERNEL 303 block/bsg.c GFP_KERNEL);
GFP_KERNEL 687 block/bsg.c bd = kzalloc(sizeof(struct bsg_device), GFP_KERNEL);
GFP_KERNEL 1005 block/bsg.c ret = idr_pre_get(&bsg_minor_idr, GFP_KERNEL);
GFP_KERNEL 2214 block/cfq-iosched.c cfqd = kmalloc_node(sizeof(*cfqd), GFP_KERNEL | __GFP_ZERO, q->node);
GFP_KERNEL 337 block/compat_ioctl.c f = karg = kmalloc(sizeof(struct floppy_struct), GFP_KERNEL);
GFP_KERNEL 366 block/compat_ioctl.c f = karg = kmalloc(sizeof(struct floppy_drive_params), GFP_KERNEL);
GFP_KERNEL 398 block/compat_ioctl.c karg = kmalloc(sizeof(struct floppy_drive_struct), GFP_KERNEL);
GFP_KERNEL 403 block/compat_ioctl.c karg = kmalloc(sizeof(struct floppy_fdc_state), GFP_KERNEL);
GFP_KERNEL 408 block/compat_ioctl.c karg = kmalloc(sizeof(struct floppy_write_errors), GFP_KERNEL);
GFP_KERNEL 354 block/deadline-iosched.c dd = kmalloc_node(sizeof(*dd), GFP_KERNEL | __GFP_ZERO, q->node);
GFP_KERNEL 211 block/elevator.c eq = kmalloc_node(sizeof(elevator_t), GFP_KERNEL | __GFP_ZERO, q->node);
GFP_KERNEL 221 block/elevator.c GFP_KERNEL, q->node);
GFP_KERNEL 270 block/genhd.c p = kmalloc(sizeof(struct blk_major_name), GFP_KERNEL);
GFP_KERNEL 386 block/genhd.c if (!idr_pre_get(&ext_devt_idr, GFP_KERNEL))
GFP_KERNEL 657 block/genhd.c iter = kmalloc(sizeof(*iter), GFP_KERNEL);
GFP_KERNEL 912 block/genhd.c new_ptbl = kzalloc_node(size, GFP_KERNEL, disk->node_id);
GFP_KERNEL 1065 block/genhd.c GFP_KERNEL | __GFP_ZERO, node_id);
GFP_KERNEL 149 block/ioctl.c bio = bio_alloc(GFP_KERNEL, 0);
GFP_KERNEL 72 block/noop-iosched.c nd = kmalloc_node(sizeof(*nd), GFP_KERNEL, q->node);
GFP_KERNEL 292 block/scsi_ioctl.c rq = blk_get_request(q, writing ? WRITE : READ, GFP_KERNEL);
GFP_KERNEL 305 block/scsi_ioctl.c iov = kmalloc(size, GFP_KERNEL);
GFP_KERNEL 318 block/scsi_ioctl.c hdr->dxfer_len, GFP_KERNEL);
GFP_KERNEL 322 block/scsi_ioctl.c GFP_KERNEL);
GFP_KERNEL 235 crypto/aead.c inst = kzalloc(sizeof(*inst) + sizeof(*spawn), GFP_KERNEL);
GFP_KERNEL 633 crypto/algapi.c inst = kzalloc(sizeof(*inst) + sizeof(*spawn), GFP_KERNEL);
GFP_KERNEL 104 crypto/algboss.c param = kzalloc(sizeof(*param), GFP_KERNEL);
GFP_KERNEL 230 crypto/algboss.c param = kzalloc(sizeof(*param), GFP_KERNEL);
GFP_KERNEL 117 crypto/api.c larval = kzalloc(sizeof(*larval), GFP_KERNEL);
GFP_KERNEL 372 crypto/api.c tfm = kzalloc(tfm_size, GFP_KERNEL);
GFP_KERNEL 276 crypto/async_tx/async_tx.c master_ref = kmalloc(sizeof(*master_ref), GFP_KERNEL);
GFP_KERNEL 393 crypto/authenc.c inst = kzalloc(sizeof(*inst) + sizeof(*ctx), GFP_KERNEL);
GFP_KERNEL 572 crypto/blkcipher.c inst = kzalloc(sizeof(*inst) + sizeof(*spawn), GFP_KERNEL);
GFP_KERNEL 502 crypto/ccm.c inst = kzalloc(sizeof(*inst) + sizeof(*ictx), GFP_KERNEL);
GFP_KERNEL 773 crypto/ccm.c inst = kzalloc(sizeof(*inst) + sizeof(*spawn), GFP_KERNEL);
GFP_KERNEL 199 crypto/cryptd.c inst = kzalloc(sizeof(*inst) + sizeof(*ctx), GFP_KERNEL);
GFP_KERNEL 76 crypto/deflate.c stream->workspace = kzalloc(zlib_inflate_workspacesize(), GFP_KERNEL);
GFP_KERNEL 211 crypto/gcm.c GFP_KERNEL);
GFP_KERNEL 457 crypto/gcm.c inst = kzalloc(sizeof(*inst) + sizeof(*ctx), GFP_KERNEL);
GFP_KERNEL 706 crypto/gcm.c inst = kzalloc(sizeof(*inst) + sizeof(*spawn), GFP_KERNEL);
GFP_KERNEL 271 crypto/gf128mul.c t = kzalloc(sizeof(*t), GFP_KERNEL);
GFP_KERNEL 276 crypto/gf128mul.c t->t[i] = kzalloc(sizeof(*t->t[i]), GFP_KERNEL);
GFP_KERNEL 313 crypto/gf128mul.c t = kzalloc(sizeof(*t), GFP_KERNEL);
GFP_KERNEL 318 crypto/gf128mul.c t->t[i] = kzalloc(sizeof(*t->t[i]), GFP_KERNEL);
GFP_KERNEL 407 crypto/gf128mul.c t = kzalloc(sizeof(*t), GFP_KERNEL);
GFP_KERNEL 429 crypto/gf128mul.c t = kzalloc(sizeof(*t), GFP_KERNEL);
GFP_KERNEL 35 crypto/rng.c buf = kmalloc(slen, GFP_KERNEL);
GFP_KERNEL 119 crypto/seqiv.c CRYPTO_TFM_REQ_MAY_SLEEP ? GFP_KERNEL:
GFP_KERNEL 165 crypto/seqiv.c CRYPTO_TFM_REQ_MAY_SLEEP ? GFP_KERNEL:
GFP_KERNEL 869 crypto/tcrypt.c tvmem[i] = (void *)__get_free_page(GFP_KERNEL);
GFP_KERNEL 130 crypto/testmgr.c req = ahash_request_alloc(tfm, GFP_KERNEL);
GFP_KERNEL 288 crypto/testmgr.c req = aead_request_alloc(tfm, GFP_KERNEL);
GFP_KERNEL 631 crypto/testmgr.c req = ablkcipher_request_alloc(tfm, GFP_KERNEL);
GFP_KERNEL 1837 crypto/testmgr.c xbuf[i] = (void *)__get_free_page(GFP_KERNEL);
GFP_KERNEL 1843 crypto/testmgr.c axbuf[i] = (void *)__get_free_page(GFP_KERNEL);
GFP_KERNEL 104 crypto/xor.c b1 = (void *) __get_free_pages(GFP_KERNEL, 2);
GFP_KERNEL 52 fs/9p/fid.c dent = kmalloc(sizeof(struct v9fs_dentry), GFP_KERNEL);
GFP_KERNEL 173 fs/9p/fid.c wnames = kmalloc(sizeof(char *) * n, GFP_KERNEL);
GFP_KERNEL 96 fs/9p/v9fs.c options = kstrdup(v9ses->options, GFP_KERNEL);
GFP_KERNEL 210 fs/9p/v9fs.c v9ses->options = kstrdup(data, GFP_KERNEL);
GFP_KERNEL 124 fs/9p/vfs_super.c v9ses = kzalloc(sizeof(struct v9fs_session_info), GFP_KERNEL);
GFP_KERNEL 241 fs/adfs/super.c ei = (struct adfs_inode_info *)kmem_cache_alloc(adfs_inode_cachep, GFP_KERNEL);
GFP_KERNEL 301 fs/adfs/super.c dm = kmalloc(nzones * sizeof(*dm), GFP_KERNEL);
GFP_KERNEL 361 fs/adfs/super.c asb = kzalloc(sizeof(*asb), GFP_KERNEL);
GFP_KERNEL 292 fs/affs/bitmap.c bm = sbi->s_bitmap = kzalloc(size, GFP_KERNEL);
GFP_KERNEL 76 fs/affs/super.c i = kmem_cache_alloc(affs_inode_cachep, GFP_KERNEL);
GFP_KERNEL 289 fs/affs/super.c sbi = kzalloc(sizeof(struct affs_sb_info), GFP_KERNEL);
GFP_KERNEL 498 fs/affs/super.c char *new_opts = kstrdup(data, GFP_KERNEL);
GFP_KERNEL 50 fs/afs/cell.c cell = kzalloc(sizeof(struct afs_cell) + namelen + 1, GFP_KERNEL);
GFP_KERNEL 193 fs/afs/cmservice.c call->buffer = kmalloc(call->count * 3 * 4, GFP_KERNEL);
GFP_KERNEL 212 fs/afs/cmservice.c GFP_KERNEL);
GFP_KERNEL 451 fs/afs/cmservice.c call->buffer = kmalloc(11 * sizeof(__be32), GFP_KERNEL);
GFP_KERNEL 467 fs/afs/cmservice.c call->request = kmalloc(sizeof(struct afs_uuid), GFP_KERNEL);
GFP_KERNEL 528 fs/afs/cmservice.c ifs = kcalloc(32, sizeof(*ifs), GFP_KERNEL);
GFP_KERNEL 170 fs/afs/file.c GFP_KERNEL);
GFP_KERNEL 214 fs/afs/file.c GFP_KERNEL) != 0
GFP_KERNEL 1727 fs/afs/fsclient.c tmpbuf = kmalloc(AFSOPAQUEMAX, GFP_KERNEL);
GFP_KERNEL 157 fs/afs/mntpt.c devname = (char *) get_zeroed_page(GFP_KERNEL);
GFP_KERNEL 161 fs/afs/mntpt.c options = (char *) get_zeroed_page(GFP_KERNEL);
GFP_KERNEL 259 fs/afs/proc.c kbuf = kmalloc(size + 1, GFP_KERNEL);
GFP_KERNEL 358 fs/afs/proc.c kbuf = kmalloc(size + 1, GFP_KERNEL);
GFP_KERNEL 677 fs/afs/rxrpc.c call = kzalloc(sizeof(struct afs_call), GFP_KERNEL);
GFP_KERNEL 76 fs/afs/server.c server = kzalloc(sizeof(struct afs_server), GFP_KERNEL);
GFP_KERNEL 299 fs/afs/super.c as = kzalloc(sizeof(struct afs_super_info), GFP_KERNEL);
GFP_KERNEL 360 fs/afs/super.c char *new_opts = kstrdup(options, GFP_KERNEL);
GFP_KERNEL 477 fs/afs/super.c vnode = kmem_cache_alloc(afs_inode_cachep, GFP_KERNEL);
GFP_KERNEL 183 fs/afs/vlclient.c return afs_make_call(addr, call, GFP_KERNEL, wait_mode);
GFP_KERNEL 217 fs/afs/vlclient.c return afs_make_call(addr, call, GFP_KERNEL, wait_mode);
GFP_KERNEL 173 fs/afs/vlocation.c vl = kzalloc(sizeof(struct afs_vlocation), GFP_KERNEL);
GFP_KERNEL 99 fs/afs/volume.c volume = kzalloc(sizeof(struct afs_volume), GFP_KERNEL);
GFP_KERNEL 190 fs/afs/write.c candidate = kzalloc(sizeof(*candidate), GFP_KERNEL);
GFP_KERNEL 792 fs/afs/write.c wb = kzalloc(sizeof(*wb), GFP_KERNEL);
GFP_KERNEL 125 fs/aio.c info->ring_pages = kcalloc(nr_pages, sizeof(struct page *), GFP_KERNEL);
GFP_KERNEL 249 fs/aio.c ctx = kmem_cache_zalloc(kioctx_cachep, GFP_KERNEL);
GFP_KERNEL 417 fs/aio.c req = kmem_cache_alloc(kiocb_cachep, GFP_KERNEL);
GFP_KERNEL 146 fs/autofs/inode.c sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
GFP_KERNEL 302 fs/autofs/root.c sl->data = kmalloc(slsize = sl->len+1, GFP_KERNEL);
GFP_KERNEL 309 fs/autofs/root.c ent = kmalloc(sizeof(struct autofs_dir_ent), GFP_KERNEL);
GFP_KERNEL 317 fs/autofs/root.c ent->name = kmalloc(dentry->d_name.len+1, GFP_KERNEL);
GFP_KERNEL 459 fs/autofs/root.c ent = kmalloc(sizeof(struct autofs_dir_ent), GFP_KERNEL);
GFP_KERNEL 465 fs/autofs/root.c ent->name = kmalloc(dentry->d_name.len+1, GFP_KERNEL);
GFP_KERNEL 125 fs/autofs/waitq.c wq = kmalloc(sizeof(struct autofs_wait_queue),GFP_KERNEL);
GFP_KERNEL 129 fs/autofs/waitq.c wq->name = kmalloc(name->len,GFP_KERNEL);
GFP_KERNEL 40 fs/autofs4/inode.c ino = kmalloc(sizeof(*ino), GFP_KERNEL);
GFP_KERNEL 324 fs/autofs4/inode.c sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
GFP_KERNEL 633 fs/autofs4/root.c cp = kmalloc(ino->size + 1, GFP_KERNEL);
GFP_KERNEL 346 fs/autofs4/waitq.c name = kmalloc(NAME_MAX + 1, GFP_KERNEL);
GFP_KERNEL 378 fs/autofs4/waitq.c wq = kmalloc(sizeof(struct autofs_wait_queue),GFP_KERNEL);
GFP_KERNEL 31 fs/befs/debug.c char *err_buf = kmalloc(ERRBUFSIZE, GFP_KERNEL);
GFP_KERNEL 49 fs/befs/debug.c char *err_buf = kmalloc(ERRBUFSIZE, GFP_KERNEL);
GFP_KERNEL 73 fs/befs/debug.c err_buf = kmalloc(ERRBUFSIZE, GFP_KERNEL);
GFP_KERNEL 281 fs/befs/linuxvfs.c GFP_KERNEL);
GFP_KERNEL 769 fs/befs/linuxvfs.c sb->s_fs_info = kmalloc(sizeof (*befs_sb), GFP_KERNEL);
GFP_KERNEL 256 fs/bfs/inode.c bi = kmem_cache_alloc(bfs_inode_cachep, GFP_KERNEL);
GFP_KERNEL 305 fs/bfs/inode.c char *tmpbuf = (char *)get_zeroed_page(GFP_KERNEL);
GFP_KERNEL 331 fs/bfs/inode.c info = kzalloc(sizeof(*info), GFP_KERNEL);
GFP_KERNEL 357 fs/bfs/inode.c info->si_imap = kzalloc(imap_len, GFP_KERNEL);
GFP_KERNEL 413 fs/binfmt_elf.c elf_phdata = kmalloc(size, GFP_KERNEL);
GFP_KERNEL 581 fs/binfmt_elf.c loc = kmalloc(sizeof(*loc), GFP_KERNEL);
GFP_KERNEL 610 fs/binfmt_elf.c elf_phdata = kmalloc(size, GFP_KERNEL);
GFP_KERNEL 650 fs/binfmt_elf.c GFP_KERNEL);
GFP_KERNEL 1055 fs/binfmt_elf.c elf_phdata = kmalloc(j, GFP_KERNEL);
GFP_KERNEL 1137 fs/binfmt_elf.c char *buf = (char *)get_zeroed_page(GFP_KERNEL);
GFP_KERNEL 1470 fs/binfmt_elf.c void *data = kmalloc(size, GFP_KERNEL);
GFP_KERNEL 1509 fs/binfmt_elf.c psinfo = kmalloc(sizeof(*psinfo), GFP_KERNEL);
GFP_KERNEL 1545 fs/binfmt_elf.c GFP_KERNEL);
GFP_KERNEL 1719 fs/binfmt_elf.c GFP_KERNEL);
GFP_KERNEL 1722 fs/binfmt_elf.c info->psinfo = kmalloc(sizeof(*info->psinfo), GFP_KERNEL);
GFP_KERNEL 1725 fs/binfmt_elf.c info->prstatus = kmalloc(sizeof(*info->prstatus), GFP_KERNEL);
GFP_KERNEL 1728 fs/binfmt_elf.c info->fpu = kmalloc(sizeof(*info->fpu), GFP_KERNEL);
GFP_KERNEL 1732 fs/binfmt_elf.c info->xfpu = kmalloc(sizeof(*info->xfpu), GFP_KERNEL);
GFP_KERNEL 1744 fs/binfmt_elf.c ets = kzalloc(sizeof(*ets), GFP_KERNEL);
GFP_KERNEL 1914 fs/binfmt_elf.c elf = kmalloc(sizeof(*elf), GFP_KERNEL);
GFP_KERNEL 133 fs/binfmt_elf_fdpic.c params->phdrs = kmalloc(size, GFP_KERNEL);
GFP_KERNEL 213 fs/binfmt_elf_fdpic.c interpreter_name = kmalloc(phdr->p_filesz, GFP_KERNEL);
GFP_KERNEL 722 fs/binfmt_elf_fdpic.c loadmap = kzalloc(size, GFP_KERNEL);
GFP_KERNEL 1600 fs/binfmt_elf_fdpic.c elf = kmalloc(sizeof(*elf), GFP_KERNEL);
GFP_KERNEL 1603 fs/binfmt_elf_fdpic.c prstatus = kzalloc(sizeof(*prstatus), GFP_KERNEL);
GFP_KERNEL 1606 fs/binfmt_elf_fdpic.c psinfo = kmalloc(sizeof(*psinfo), GFP_KERNEL);
GFP_KERNEL 1609 fs/binfmt_elf_fdpic.c notes = kmalloc(NUM_NOTES * sizeof(struct memelfnote), GFP_KERNEL);
GFP_KERNEL 1612 fs/binfmt_elf_fdpic.c fpu = kmalloc(sizeof(*fpu), GFP_KERNEL);
GFP_KERNEL 1616 fs/binfmt_elf_fdpic.c xfpu = kmalloc(sizeof(*xfpu), GFP_KERNEL);
GFP_KERNEL 1627 fs/binfmt_elf_fdpic.c tmp = kzalloc(sizeof(*tmp), GFP_KERNEL);
GFP_KERNEL 183 fs/binfmt_flat.c strm.workspace = kmalloc(zlib_inflate_workspacesize(), GFP_KERNEL);
GFP_KERNEL 188 fs/binfmt_flat.c buf = kmalloc(LBUFSIZE, GFP_KERNEL);
GFP_KERNEL 542 fs/binfmt_misc.c if (!(page = (char*) __get_free_page(GFP_KERNEL)))
GFP_KERNEL 211 fs/binfmt_som.c hpuxhdr = kmalloc(size, GFP_KERNEL);
GFP_KERNEL 1385 fs/bio.c struct bio_set *bs = kzalloc(sizeof(*bs), GFP_KERNEL);
GFP_KERNEL 260 fs/block_dev.c struct bdev_inode *ei = kmem_cache_alloc(bdev_cachep, GFP_KERNEL);
GFP_KERNEL 624 fs/block_dev.c bo = kzalloc(sizeof(*bo), GFP_KERNEL);
GFP_KERNEL 102 fs/char_dev.c cd = kzalloc(sizeof(struct char_device_struct), GFP_KERNEL);
GFP_KERNEL 509 fs/char_dev.c struct cdev *p = kzalloc(sizeof(struct cdev), GFP_KERNEL);
GFP_KERNEL 69 fs/cifs/cifs_dfs_ref.c GFP_KERNEL);
GFP_KERNEL 142 fs/cifs/cifs_dfs_ref.c mountdata = kzalloc(md_len+1, GFP_KERNEL);
GFP_KERNEL 38 fs/cifs/cifs_spnego.c payload = kmalloc(datalen, GFP_KERNEL);
GFP_KERNEL 111 fs/cifs/cifs_spnego.c description = kzalloc(desc_len, GFP_KERNEL);
GFP_KERNEL 372 fs/cifs/cifsacl.c GFP_KERNEL);
GFP_KERNEL 713 fs/cifs/cifsacl.c pnntsd = kmalloc(secdesclen, GFP_KERNEL);
GFP_KERNEL 249 fs/cifs/cifsencrypt.c ucase_buf = kmalloc((MAX_USERNAME_SIZE+1), GFP_KERNEL);
GFP_KERNEL 252 fs/cifs/cifsencrypt.c unicode_buf = kmalloc((MAX_USERNAME_SIZE+1)*4, GFP_KERNEL);
GFP_KERNEL 333 fs/cifs/cifsencrypt.c pctxt = kmalloc(sizeof(struct HMACMD5Context), GFP_KERNEL);
GFP_KERNEL 346 fs/cifs/cifsencrypt.c user = kmalloc(2 + (len * 2), GFP_KERNEL);
GFP_KERNEL 357 fs/cifs/cifsencrypt.c domain = kmalloc(2 + (len * 2), GFP_KERNEL);
GFP_KERNEL 104 fs/cifs/cifsfs.c sb->s_fs_info = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL);
GFP_KERNEL 119 fs/cifs/cifsfs.c cifs_sb->mountdata = kzalloc(len + 1, GFP_KERNEL);
GFP_KERNEL 300 fs/cifs/cifsfs.c cifs_inode = kmem_cache_alloc(cifs_inode_cachep, GFP_KERNEL);
GFP_KERNEL 98 fs/cifs/cifssmb.c *dst = kmalloc(plen + 2, GFP_KERNEL);
GFP_KERNEL 104 fs/cifs/cifssmb.c *dst = kmalloc(plen + 2, GFP_KERNEL);
GFP_KERNEL 3170 fs/cifs/cifssmb.c *acl_inf = kmalloc(*pbuflen, GFP_KERNEL);
GFP_KERNEL 3970 fs/cifs/cifssmb.c *num_of_nodes, GFP_KERNEL);
GFP_KERNEL 5250 fs/cifs/cifssmb.c GFP_KERNEL);
GFP_KERNEL 356 fs/cifs/connect.c GFP_KERNEL);
GFP_KERNEL 763 fs/cifs/connect.c GFP_KERNEL);
GFP_KERNEL 786 fs/cifs/connect.c dst = kmalloc((len + 1), GFP_KERNEL);
GFP_KERNEL 931 fs/cifs/connect.c vol->password = kzalloc(temp_len, GFP_KERNEL);
GFP_KERNEL 947 fs/cifs/connect.c vol->password = kzalloc(temp_len+1, GFP_KERNEL);
GFP_KERNEL 1012 fs/cifs/connect.c vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
GFP_KERNEL 1054 fs/cifs/connect.c vol->prepath = kmalloc(temp_len+1, GFP_KERNEL);
GFP_KERNEL 1308 fs/cifs/connect.c vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
GFP_KERNEL 1438 fs/cifs/connect.c GFP_KERNEL);
GFP_KERNEL 1595 fs/cifs/connect.c GFP_KERNEL);
GFP_KERNEL 1977 fs/cifs/connect.c srvTcp = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
GFP_KERNEL 2057 fs/cifs/connect.c kmalloc(len + 1, GFP_KERNEL);
GFP_KERNEL 2500 fs/cifs/connect.c GFP_KERNEL);
GFP_KERNEL 2515 fs/cifs/connect.c GFP_KERNEL);
GFP_KERNEL 2538 fs/cifs/connect.c GFP_KERNEL);
GFP_KERNEL 2552 fs/cifs/connect.c kzalloc(2, GFP_KERNEL);
GFP_KERNEL 2562 fs/cifs/connect.c kzalloc(2, GFP_KERNEL);
GFP_KERNEL 2565 fs/cifs/connect.c kzalloc(2, GFP_KERNEL);
GFP_KERNEL 2574 fs/cifs/connect.c GFP_KERNEL);
GFP_KERNEL 2587 fs/cifs/connect.c GFP_KERNEL);
GFP_KERNEL 2599 fs/cifs/connect.c GFP_KERNEL);
GFP_KERNEL 2843 fs/cifs/connect.c kzalloc(2 * (len + 1), GFP_KERNEL);
GFP_KERNEL 2860 fs/cifs/connect.c GFP_KERNEL);
GFP_KERNEL 2881 fs/cifs/connect.c GFP_KERNEL);
GFP_KERNEL 2898 fs/cifs/connect.c GFP_KERNEL);
GFP_KERNEL 2903 fs/cifs/connect.c kzalloc(2, GFP_KERNEL);
GFP_KERNEL 2906 fs/cifs/connect.c kzalloc(2, GFP_KERNEL);
GFP_KERNEL 2917 fs/cifs/connect.c GFP_KERNEL);
GFP_KERNEL 2929 fs/cifs/connect.c GFP_KERNEL);
GFP_KERNEL 2939 fs/cifs/connect.c GFP_KERNEL);
GFP_KERNEL 3245 fs/cifs/connect.c kzalloc(2 * (len + 1), GFP_KERNEL);
GFP_KERNEL 3262 fs/cifs/connect.c GFP_KERNEL);
GFP_KERNEL 3282 fs/cifs/connect.c GFP_KERNEL);
GFP_KERNEL 3306 fs/cifs/connect.c ses->serverDomain = kzalloc(2,GFP_KERNEL);
GFP_KERNEL 3311 fs/cifs/connect.c ses->serverDomain = kzalloc(2, GFP_KERNEL);
GFP_KERNEL 3313 fs/cifs/connect.c ses->serverNOS = kzalloc(2, GFP_KERNEL);
GFP_KERNEL 3322 fs/cifs/connect.c ses->serverOS = kzalloc(len + 1, GFP_KERNEL);
GFP_KERNEL 3332 fs/cifs/connect.c GFP_KERNEL);
GFP_KERNEL 3344 fs/cifs/connect.c GFP_KERNEL);
GFP_KERNEL 3499 fs/cifs/connect.c kzalloc(length + 2, GFP_KERNEL);
GFP_KERNEL 3518 fs/cifs/connect.c kzalloc(length + 1, GFP_KERNEL);
GFP_KERNEL 3657 fs/cifs/connect.c GFP_KERNEL);
GFP_KERNEL 80 fs/cifs/dir.c full_path = kmalloc(namelen+1, GFP_KERNEL);
GFP_KERNEL 192 fs/cifs/dir.c buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
GFP_KERNEL 302 fs/cifs/dir.c kzalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
GFP_KERNEL 407 fs/cifs/dir.c buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
GFP_KERNEL 67 fs/cifs/dns_resolve.c ip = kmalloc(datalen + 1, GFP_KERNEL);
GFP_KERNEL 135 fs/cifs/dns_resolve.c name = kmalloc(len+1, GFP_KERNEL);
GFP_KERNEL 161 fs/cifs/dns_resolve.c *ip_addr = kmalloc(len + 1, GFP_KERNEL);
GFP_KERNEL 265 fs/cifs/file.c buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
GFP_KERNEL 291 fs/cifs/file.c kmalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
GFP_KERNEL 620 fs/cifs/file.c kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
GFP_KERNEL 1243 fs/cifs/file.c iov = kmalloc(32 * sizeof(struct kvec), GFP_KERNEL);
GFP_KERNEL 1768 fs/cifs/file.c GFP_KERNEL)) {
GFP_KERNEL 435 fs/cifs/inode.c buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
GFP_KERNEL 801 fs/cifs/inode.c info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
GFP_KERNEL 885 fs/cifs/inode.c attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
GFP_KERNEL 993 fs/cifs/inode.c kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
GFP_KERNEL 1299 fs/cifs/inode.c GFP_KERNEL);
GFP_KERNEL 1696 fs/cifs/inode.c args = kmalloc(sizeof(*args), GFP_KERNEL);
GFP_KERNEL 127 fs/cifs/link.c target_path = kmalloc(PATH_MAX, GFP_KERNEL);
GFP_KERNEL 263 fs/cifs/link.c tmpbuffer = kmalloc(len, GFP_KERNEL);
GFP_KERNEL 76 fs/cifs/misc.c ret_buf = kzalloc(sizeof(struct cifsSesInfo), GFP_KERNEL);
GFP_KERNEL 112 fs/cifs/misc.c ret_buf = kzalloc(sizeof(struct cifsTconInfo), GFP_KERNEL);
GFP_KERNEL 451 fs/cifs/readdir.c kzalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
GFP_KERNEL 1077 fs/cifs/readdir.c tmp_buf = kmalloc((2 * NAME_MAX) + 4, GFP_KERNEL);
GFP_KERNEL 231 fs/cifs/sess.c ses->serverOS = kzalloc(4 * len, GFP_KERNEL);
GFP_KERNEL 244 fs/cifs/sess.c ses->serverNOS = kzalloc(4 * len, GFP_KERNEL); /* BB this is wrong length FIXME BB */
GFP_KERNEL 263 fs/cifs/sess.c ses->serverDomain = kzalloc(2 * (len + 1), GFP_KERNEL); /* BB FIXME wrong length */
GFP_KERNEL 294 fs/cifs/sess.c ses->serverOS = kzalloc(len + 1, GFP_KERNEL);
GFP_KERNEL 311 fs/cifs/sess.c ses->serverNOS = kzalloc(len + 1, GFP_KERNEL);
GFP_KERNEL 396 fs/cifs/sess.c str_area = kmalloc(2000, GFP_KERNEL);
GFP_KERNEL 468 fs/cifs/sess.c kmalloc(sizeof(struct ntlmv2_resp), GFP_KERNEL);
GFP_KERNEL 205 fs/cifs/smbdes.c pk1 = kmalloc(56+56+64+64, GFP_KERNEL);
GFP_KERNEL 209 fs/cifs/smbdes.c ki = kmalloc(16*48, GFP_KERNEL);
GFP_KERNEL 249 fs/cifs/smbdes.c er = kmalloc(48+48+32+32+32, GFP_KERNEL);
GFP_KERNEL 329 fs/cifs/smbdes.c outb = kmalloc(64 * 3, GFP_KERNEL);
GFP_KERNEL 187 fs/cifs/smbencrypt.c user_u = kmalloc(2048 * sizeof(wchar_t), GFP_KERNEL);
GFP_KERNEL 120 fs/cifs/transport.c GFP_KERNEL);
GFP_KERNEL 511 fs/coda/dir.c vdir = kmalloc(sizeof(*vdir), GFP_KERNEL);
GFP_KERNEL 132 fs/coda/file.c cfi = kmalloc(sizeof(struct coda_file_info), GFP_KERNEL);
GFP_KERNEL 46 fs/coda/inode.c ei = (struct coda_inode_info *)kmem_cache_alloc(coda_inode_cachep, GFP_KERNEL);
GFP_KERNEL 678 fs/coda/upcall.c req = kmalloc(sizeof(struct upc_req), GFP_KERNEL);
GFP_KERNEL 735 fs/coda/upcall.c sig_req = kmalloc(sizeof(struct upc_req), GFP_KERNEL);
GFP_KERNEL 1062 fs/compat.c iov = kmalloc(nr_segs*sizeof(struct iovec), GFP_KERNEL);
GFP_KERNEL 1359 fs/compat.c bprm = kzalloc(sizeof(*bprm), GFP_KERNEL);
GFP_KERNEL 1547 fs/compat.c bits = kmalloc(6 * size, GFP_KERNEL);
GFP_KERNEL 2747 fs/compat_ioctl.c path = (char *)__get_free_page(GFP_KERNEL);
GFP_KERNEL 89 fs/configfs/dir.c sd = kmem_cache_zalloc(configfs_dir_cachep, GFP_KERNEL);
GFP_KERNEL 1155 fs/configfs/dir.c name = kmalloc(dentry->d_name.len + 1, GFP_KERNEL);
GFP_KERNEL 73 fs/configfs/file.c buffer->page = (char *) get_zeroed_page(GFP_KERNEL);
GFP_KERNEL 143 fs/configfs/file.c buffer->page = (char *)__get_free_pages(GFP_KERNEL, 0);
GFP_KERNEL 258 fs/configfs/file.c buffer = kzalloc(sizeof(struct configfs_buffer),GFP_KERNEL);
GFP_KERNEL 80 fs/configfs/inode.c sd_iattr = kzalloc(sizeof(struct iattr), GFP_KERNEL);
GFP_KERNEL 86 fs/configfs/item.c name = kmalloc(limit,GFP_KERNEL);
GFP_KERNEL 83 fs/configfs/symlink.c sl = kmalloc(sizeof(struct configfs_symlink), GFP_KERNEL);
GFP_KERNEL 288 fs/configfs/symlink.c unsigned long page = get_zeroed_page(GFP_KERNEL);
GFP_KERNEL 234 fs/cramfs/inode.c sbi = kzalloc(sizeof(struct cramfs_sb_info), GFP_KERNEL);
GFP_KERNEL 354 fs/cramfs/inode.c buf = kmalloc(CRAMFS_MAXPATHLEN, GFP_KERNEL);
GFP_KERNEL 917 fs/dcache.c dentry = kmem_cache_alloc(dentry_cache, GFP_KERNEL);
GFP_KERNEL 922 fs/dcache.c dname = kmalloc(name->len + 1, GFP_KERNEL);
GFP_KERNEL 95 fs/dcookies.c GFP_KERNEL);
GFP_KERNEL 169 fs/dcookies.c kbuf = kmalloc(PAGE_SIZE, GFP_KERNEL);
GFP_KERNEL 211 fs/dcookies.c dcookie_hashtable = kmalloc(PAGE_SIZE, GFP_KERNEL);
GFP_KERNEL 292 fs/dcookies.c user = kmalloc(sizeof(struct dcookie_user), GFP_KERNEL);
GFP_KERNEL 299 fs/debugfs/inode.c link = kstrdup(target, GFP_KERNEL);
GFP_KERNEL 179 fs/devpts/inode.c if (!ida_pre_get(&allocated_ptys, GFP_KERNEL)) {
GFP_KERNEL 309 fs/direct-io.c bio = bio_alloc(GFP_KERNEL, nr_vecs);
GFP_KERNEL 1156 fs/direct-io.c dio = kzalloc(sizeof(*dio), GFP_KERNEL);
GFP_KERNEL 413 fs/dlm/config.c cl = kzalloc(sizeof(struct dlm_cluster), GFP_KERNEL);
GFP_KERNEL 414 fs/dlm/config.c gps = kcalloc(3, sizeof(struct config_group *), GFP_KERNEL);
GFP_KERNEL 415 fs/dlm/config.c sps = kzalloc(sizeof(struct dlm_spaces), GFP_KERNEL);
GFP_KERNEL 416 fs/dlm/config.c cms = kzalloc(sizeof(struct dlm_comms), GFP_KERNEL);
GFP_KERNEL 485 fs/dlm/config.c sp = kzalloc(sizeof(struct dlm_space), GFP_KERNEL);
GFP_KERNEL 486 fs/dlm/config.c gps = kcalloc(2, sizeof(struct config_group *), GFP_KERNEL);
GFP_KERNEL 487 fs/dlm/config.c nds = kzalloc(sizeof(struct dlm_nodes), GFP_KERNEL);
GFP_KERNEL 539 fs/dlm/config.c cm = kzalloc(sizeof(struct dlm_comm), GFP_KERNEL);
GFP_KERNEL 572 fs/dlm/config.c nd = kzalloc(sizeof(struct dlm_node), GFP_KERNEL);
GFP_KERNEL 708 fs/dlm/config.c addr = kzalloc(sizeof(*addr), GFP_KERNEL);
GFP_KERNEL 871 fs/dlm/config.c ids = kcalloc(ids_count, sizeof(int), GFP_KERNEL);
GFP_KERNEL 889 fs/dlm/config.c new = kcalloc(new_count, sizeof(int), GFP_KERNEL);
GFP_KERNEL 270 fs/dlm/debug_fs.c ri = kzalloc(sizeof *ri, GFP_KERNEL);
GFP_KERNEL 381 fs/dlm/debug_fs.c ri = kzalloc(sizeof *ri, GFP_KERNEL);
GFP_KERNEL 52 fs/dlm/dir.c de = kzalloc(sizeof(struct dlm_direntry) + len, GFP_KERNEL);
GFP_KERNEL 214 fs/dlm/dir.c last_name = kmalloc(DLM_RESNAME_MAXLEN, GFP_KERNEL);
GFP_KERNEL 325 fs/dlm/dir.c de = kzalloc(sizeof(struct dlm_direntry) + namelen, GFP_KERNEL);
GFP_KERNEL 4470 fs/dlm/lock.c ua->lksb.sb_lvbptr = kzalloc(DLM_USER_LVB_LEN, GFP_KERNEL);
GFP_KERNEL 4540 fs/dlm/lock.c ua->lksb.sb_lvbptr = kzalloc(DLM_USER_LVB_LEN, GFP_KERNEL);
GFP_KERNEL 435 fs/dlm/lockspace.c ls = kzalloc(sizeof(struct dlm_ls) + namelen, GFP_KERNEL);
GFP_KERNEL 451 fs/dlm/lockspace.c ls->ls_allocation = GFP_KERNEL;
GFP_KERNEL 461 fs/dlm/lockspace.c ls->ls_rsbtbl = kmalloc(sizeof(struct dlm_rsbtable) * size, GFP_KERNEL);
GFP_KERNEL 473 fs/dlm/lockspace.c ls->ls_lkbtbl = kmalloc(sizeof(struct dlm_lkbtable) * size, GFP_KERNEL);
GFP_KERNEL 485 fs/dlm/lockspace.c ls->ls_dirtbl = kmalloc(sizeof(struct dlm_dirtable) * size, GFP_KERNEL);
GFP_KERNEL 532 fs/dlm/lockspace.c ls->ls_recover_buf = kmalloc(dlm_config.ci_buffer_size, GFP_KERNEL);
GFP_KERNEL 466 fs/dlm/lowcomms.c new_con = nodeid2con(nodeid, GFP_KERNEL);
GFP_KERNEL 702 fs/dlm/lowcomms.c newcon = nodeid2con(nodeid, GFP_KERNEL);
GFP_KERNEL 712 fs/dlm/lowcomms.c othercon = kmem_cache_zalloc(con_cache, GFP_KERNEL);
GFP_KERNEL 1017 fs/dlm/lowcomms.c addr = kmalloc(sizeof(*addr), GFP_KERNEL);
GFP_KERNEL 1056 fs/dlm/lowcomms.c struct connection *con = nodeid2con(0, GFP_KERNEL);
GFP_KERNEL 1128 fs/dlm/lowcomms.c struct connection *con = nodeid2con(0, GFP_KERNEL);
GFP_KERNEL 50 fs/dlm/member.c memb = kzalloc(sizeof(struct dlm_member), GFP_KERNEL);
GFP_KERNEL 139 fs/dlm/member.c array = kmalloc(sizeof(int) * total, GFP_KERNEL);
GFP_KERNEL 222 fs/dlm/member.c memb = kzalloc(sizeof(struct dlm_member), GFP_KERNEL);
GFP_KERNEL 337 fs/dlm/member.c rv = kzalloc(sizeof(struct dlm_recover), GFP_KERNEL);
GFP_KERNEL 42 fs/dlm/memory.c p = kzalloc(ls->ls_lvblen, GFP_KERNEL);
GFP_KERNEL 60 fs/dlm/memory.c r = kzalloc(sizeof(*r) + namelen, GFP_KERNEL);
GFP_KERNEL 75 fs/dlm/memory.c lkb = kmem_cache_zalloc(lkb_cache, GFP_KERNEL);
GFP_KERNEL 115 fs/dlm/midcomms.c p = kmalloc(dlm_config.ci_buffer_size, GFP_KERNEL);
GFP_KERNEL 29 fs/dlm/netlink.c skb = genlmsg_new(size, GFP_KERNEL);
GFP_KERNEL 85 fs/dlm/plock.c xop = kzalloc(sizeof(*xop), GFP_KERNEL);
GFP_KERNEL 214 fs/dlm/plock.c op = kzalloc(sizeof(*op), GFP_KERNEL);
GFP_KERNEL 269 fs/dlm/plock.c op = kzalloc(sizeof(*op), GFP_KERNEL);
GFP_KERNEL 38 fs/dlm/requestqueue.c e = kmalloc(sizeof(struct rq_entry) + length, GFP_KERNEL);
GFP_KERNEL 270 fs/dlm/user.c ua = kzalloc(sizeof(struct dlm_user_args), GFP_KERNEL);
GFP_KERNEL 310 fs/dlm/user.c ua = kzalloc(sizeof(struct dlm_user_args), GFP_KERNEL);
GFP_KERNEL 355 fs/dlm/user.c ls->ls_device.name = kzalloc(len, GFP_KERNEL);
GFP_KERNEL 523 fs/dlm/user.c kbuf = kzalloc(count + 1, GFP_KERNEL);
GFP_KERNEL 542 fs/dlm/user.c sizeof(struct dlm_write_request32)), GFP_KERNEL);
GFP_KERNEL 643 fs/dlm/user.c proc = kzalloc(sizeof(struct dlm_user_proc), GFP_KERNEL);
GFP_KERNEL 82 fs/dnotify.c dn = kmem_cache_alloc(dn_cache, GFP_KERNEL);
GFP_KERNEL 61 fs/drop_caches.c nr_objects = shrink_slab(1000, GFP_KERNEL, 1000);
GFP_KERNEL 155 fs/ecryptfs/crypto.c (*algified_name) = kmalloc(algified_name_len, GFP_KERNEL);
GFP_KERNEL 1371 fs/ecryptfs/crypto.c virt = kzalloc(crypt_stat->num_header_bytes_at_front, GFP_KERNEL);
GFP_KERNEL 1656 fs/ecryptfs/crypto.c (*encoded_name) = kmalloc(length + 2, GFP_KERNEL);
GFP_KERNEL 1700 fs/ecryptfs/crypto.c (*decrypted_name) = kmalloc(length + 2, GFP_KERNEL);
GFP_KERNEL 1817 fs/ecryptfs/crypto.c tmp_tfm = kmem_cache_alloc(ecryptfs_key_tfm_cache, GFP_KERNEL);
GFP_KERNEL 177 fs/ecryptfs/file.c file_info = kmem_cache_zalloc(ecryptfs_file_info_cache, GFP_KERNEL);
GFP_KERNEL 307 fs/ecryptfs/inode.c GFP_KERNEL));
GFP_KERNEL 621 fs/ecryptfs/inode.c lower_buf = kmalloc(bufsiz, GFP_KERNEL);
GFP_KERNEL 666 fs/ecryptfs/inode.c buf = kmalloc(len, GFP_KERNEL);
GFP_KERNEL 759 fs/ecryptfs/inode.c GFP_KERNEL));
GFP_KERNEL 789 fs/ecryptfs/inode.c zeros_virt = kzalloc(num_zeros, GFP_KERNEL);
GFP_KERNEL 157 fs/ecryptfs/keystore.c *packet = kmalloc(data_len, GFP_KERNEL);
GFP_KERNEL 300 fs/ecryptfs/keystore.c *packet = kmalloc(data_len, GFP_KERNEL);
GFP_KERNEL 572 fs/ecryptfs/keystore.c GFP_KERNEL);
GFP_KERNEL 706 fs/ecryptfs/keystore.c kmem_cache_zalloc(ecryptfs_auth_tok_list_item_cache, GFP_KERNEL);
GFP_KERNEL 1764 fs/ecryptfs/keystore.c key_rec = kmem_cache_alloc(ecryptfs_key_record_cache, GFP_KERNEL);
GFP_KERNEL 1847 fs/ecryptfs/keystore.c new_key_sig = kmem_cache_alloc(ecryptfs_key_sig_cache, GFP_KERNEL);
GFP_KERNEL 1872 fs/ecryptfs/keystore.c GFP_KERNEL);
GFP_KERNEL 149 fs/ecryptfs/kthread.c req = kmem_cache_alloc(ecryptfs_open_req_cache, GFP_KERNEL);
GFP_KERNEL 431 fs/ecryptfs/main.c GFP_KERNEL));
GFP_KERNEL 453 fs/ecryptfs/main.c GFP_KERNEL));
GFP_KERNEL 207 fs/ecryptfs/messaging.c (*daemon) = kzalloc(sizeof(**daemon), GFP_KERNEL);
GFP_KERNEL 450 fs/ecryptfs/messaging.c msg_ctx->msg = kmalloc(msg_size, GFP_KERNEL);
GFP_KERNEL 606 fs/ecryptfs/messaging.c * ecryptfs_hash_buckets), GFP_KERNEL);
GFP_KERNEL 618 fs/ecryptfs/messaging.c GFP_KERNEL);
GFP_KERNEL 199 fs/ecryptfs/miscdev.c GFP_KERNEL);
GFP_KERNEL 421 fs/ecryptfs/miscdev.c data = kmalloc(count, GFP_KERNEL);
GFP_KERNEL 379 fs/ecryptfs/mmap.c file_size_virt = kmalloc(sizeof(u64), GFP_KERNEL);
GFP_KERNEL 412 fs/ecryptfs/mmap.c xattr_virt = kmem_cache_alloc(ecryptfs_xattr_cache, GFP_KERNEL);
GFP_KERNEL 57 fs/ecryptfs/netlink.c skb = alloc_skb(NLMSG_SPACE(payload_len), GFP_KERNEL);
GFP_KERNEL 53 fs/ecryptfs/super.c inode_info = kmem_cache_alloc(ecryptfs_inode_info_cache, GFP_KERNEL);
GFP_KERNEL 62 fs/efs/super.c ei = (struct efs_inode_info *)kmem_cache_alloc(efs_inode_cachep, GFP_KERNEL);
GFP_KERNEL 252 fs/efs/super.c sb = kzalloc(sizeof(struct efs_sb_info), GFP_KERNEL);
GFP_KERNEL 213 fs/eventfd.c ctx = kmalloc(sizeof(*ctx), GFP_KERNEL);
GFP_KERNEL 535 fs/eventpoll.c struct eventpoll *ep = kzalloc(sizeof(*ep), GFP_KERNEL);
GFP_KERNEL 663 fs/eventpoll.c if (epi->nwait >= 0 && (pwq = kmem_cache_alloc(pwq_cache, GFP_KERNEL))) {
GFP_KERNEL 707 fs/eventpoll.c if (!(epi = kmem_cache_alloc(epi_cache, GFP_KERNEL)))
GFP_KERNEL 242 fs/exec.c bprm->vma = vma = kmem_cache_zalloc(vm_area_cachep, GFP_KERNEL);
GFP_KERNEL 889 fs/exec.c newsighand = kmem_cache_alloc(sighand_cachep, GFP_KERNEL);
GFP_KERNEL 1291 fs/exec.c bprm = kzalloc(sizeof(*bprm), GFP_KERNEL);
GFP_KERNEL 1779 fs/exec.c helper_argv = argv_split(GFP_KERNEL, corename+1, &helper_argc);
GFP_KERNEL 39 fs/ext2/acl.c acl = posix_acl_alloc(count, GFP_KERNEL);
GFP_KERNEL 93 fs/ext2/acl.c sizeof(ext2_acl_entry), GFP_KERNEL);
GFP_KERNEL 187 fs/ext2/acl.c value = kmalloc(retval, GFP_KERNEL);
GFP_KERNEL 332 fs/ext2/acl.c clone = posix_acl_clone(acl, GFP_KERNEL);
GFP_KERNEL 380 fs/ext2/acl.c clone = posix_acl_clone(acl, GFP_KERNEL);
GFP_KERNEL 145 fs/ext2/super.c ei = (struct ext2_inode_info *)kmem_cache_alloc(ext2_inode_cachep, GFP_KERNEL);
GFP_KERNEL 756 fs/ext2/super.c sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
GFP_KERNEL 981 fs/ext2/super.c sbi->s_group_desc = kmalloc (db_count * sizeof (struct buffer_head *), GFP_KERNEL);
GFP_KERNEL 987 fs/ext2/super.c sbi->s_debts = kcalloc(sbi->s_groups_count, sizeof(*sbi->s_debts), GFP_KERNEL);
GFP_KERNEL 507 fs/ext2/xattr.c header = kmalloc(bh->b_size, GFP_KERNEL);
GFP_KERNEL 521 fs/ext2/xattr.c header = kzalloc(sb->s_blocksize, GFP_KERNEL);
GFP_KERNEL 387 fs/ext3/acl.c clone = posix_acl_clone(acl, GFP_KERNEL);
GFP_KERNEL 311 fs/ext3/dir.c p = kzalloc(sizeof(struct dir_private_info), GFP_KERNEL);
GFP_KERNEL 342 fs/ext3/dir.c new_fn = kzalloc(len, GFP_KERNEL);
GFP_KERNEL 1531 fs/ext3/super.c sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
GFP_KERNEL 1768 fs/ext3/super.c GFP_KERNEL);
GFP_KERNEL 387 fs/ext4/acl.c clone = posix_acl_clone(acl, GFP_KERNEL);
GFP_KERNEL 317 fs/ext4/dir.c p = kzalloc(sizeof(struct dir_private_info), GFP_KERNEL);
GFP_KERNEL 348 fs/ext4/dir.c new_fn = kzalloc(len, GFP_KERNEL);
GFP_KERNEL 1992 fs/ext4/mballoc.c s = kmalloc(sizeof(*s), GFP_KERNEL);
GFP_KERNEL 1997 fs/ext4/mballoc.c s->history = kmalloc(size, GFP_KERNEL);
GFP_KERNEL 2195 fs/ext4/mballoc.c sbi->s_mb_history = kzalloc(i, GFP_KERNEL);
GFP_KERNEL 2261 fs/ext4/mballoc.c meta_group_info = kmalloc(metalen, GFP_KERNEL);
GFP_KERNEL 2282 fs/ext4/mballoc.c meta_group_info[i] = kzalloc(len, GFP_KERNEL);
GFP_KERNEL 2308 fs/ext4/mballoc.c kmalloc(sb->s_blocksize, GFP_KERNEL);
GFP_KERNEL 2428 fs/ext4/mballoc.c sbi->s_group_info = kmalloc(array_size, GFP_KERNEL);
GFP_KERNEL 2446 fs/ext4/mballoc.c meta_group_info = kmalloc(metalen, GFP_KERNEL);
GFP_KERNEL 2491 fs/ext4/mballoc.c sbi->s_mb_offsets = kmalloc(i, GFP_KERNEL);
GFP_KERNEL 2495 fs/ext4/mballoc.c sbi->s_mb_maxs = kmalloc(i, GFP_KERNEL);
GFP_KERNEL 1529 fs/ext4/super.c sizeof(struct flex_groups), GFP_KERNEL);
GFP_KERNEL 1948 fs/ext4/super.c sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
GFP_KERNEL 2228 fs/ext4/super.c GFP_KERNEL);
GFP_KERNEL 1193 fs/fat/inode.c sbi = kzalloc(sizeof(struct msdos_sb_info), GFP_KERNEL);
GFP_KERNEL 514 fs/fcntl.c new = kmem_cache_alloc(fasync_cache, GFP_KERNEL);
GFP_KERNEL 44 fs/file.c return kmalloc(size, GFP_KERNEL);
GFP_KERNEL 165 fs/file.c fdt = kmalloc(sizeof(struct fdtable), GFP_KERNEL);
GFP_KERNEL 301 fs/file.c newf = kmem_cache_alloc(files_cachep, GFP_KERNEL);
GFP_KERNEL 113 fs/file_table.c f = kmem_cache_zalloc(filp_cachep, GFP_KERNEL);
GFP_KERNEL 84 fs/freevxfs/vxfs_fshead.c if (!(fhp = kmalloc(sizeof(*fhp), GFP_KERNEL)))
GFP_KERNEL 101 fs/freevxfs/vxfs_inode.c if (!(vip = kmem_cache_alloc(vxfs_inode_cachep, GFP_KERNEL)))
GFP_KERNEL 143 fs/freevxfs/vxfs_inode.c if (!(vip = kmem_cache_alloc(vxfs_inode_cachep, GFP_KERNEL)))
GFP_KERNEL 159 fs/freevxfs/vxfs_super.c infp = kzalloc(sizeof(*infp), GFP_KERNEL);
GFP_KERNEL 44 fs/fuse/dev.c struct fuse_req *req = kmem_cache_alloc(fuse_req_cachep, GFP_KERNEL);
GFP_KERNEL 1021 fs/fuse/dir.c page = alloc_page(GFP_KERNEL);
GFP_KERNEL 1052 fs/fuse/dir.c link = (char *) __get_free_page(GFP_KERNEL);
GFP_KERNEL 52 fs/fuse/file.c ff = kmalloc(sizeof(struct fuse_file), GFP_KERNEL);
GFP_KERNEL 54 fs/fuse/inode.c inode = kmem_cache_alloc(fuse_inode_cachep, GFP_KERNEL);
GFP_KERNEL 470 fs/fuse/inode.c fc = kzalloc(sizeof(*fc), GFP_KERNEL);
GFP_KERNEL 144 fs/generic_acl.c clone = posix_acl_clone(acl, GFP_KERNEL);
GFP_KERNEL 151 fs/generic_acl.c clone = posix_acl_clone(acl, GFP_KERNEL);
GFP_KERNEL 187 fs/generic_acl.c clone = posix_acl_clone(acl, GFP_KERNEL);
GFP_KERNEL 684 fs/gfs2/glock.c gl = kmem_cache_alloc(gfs2_glock_cachep, GFP_KERNEL);
GFP_KERNEL 96 fs/gfs2/locking.c lw = kzalloc(sizeof(struct lmh_wrapper), GFP_KERNEL);
GFP_KERNEL 21 fs/gfs2/locking/dlm/mount.c ls = kzalloc(sizeof(struct gdlm_ls), GFP_KERNEL);
GFP_KERNEL 466 fs/gfs2/ops_file.c fp = kzalloc(sizeof(struct gfs2_file), GFP_KERNEL);
GFP_KERNEL 85 fs/gfs2/ops_fstype.c sdp = kzalloc(sizeof(struct gfs2_sbd), GFP_KERNEL);
GFP_KERNEL 636 fs/gfs2/ops_fstype.c GFP_KERNEL);
GFP_KERNEL 545 fs/gfs2/ops_super.c ip = kmem_cache_alloc(gfs2_inode_cachep, GFP_KERNEL);
GFP_KERNEL 1039 fs/gfs2/quota.c qda = kcalloc(max_qd, sizeof(struct gfs2_quota_data *), GFP_KERNEL);
GFP_KERNEL 867 fs/gfs2/rgrp.c ip->i_alloc = kzalloc(sizeof(struct gfs2_alloc), GFP_KERNEL);
GFP_KERNEL 80 fs/gfs2/super.c jd = kzalloc(sizeof(struct gfs2_jdesc), GFP_KERNEL);
GFP_KERNEL 500 fs/gfs2/super.c gha = kcalloc(slots, sizeof(struct gfs2_holder), GFP_KERNEL);
GFP_KERNEL 588 fs/gfs2/super.c lfcc = kmalloc(sizeof(struct lfcc), GFP_KERNEL);
GFP_KERNEL 20 fs/hfs/bfind.c ptr = kmalloc(tree->max_key_len * 2 + 4, GFP_KERNEL);
GFP_KERNEL 252 fs/hfs/bnode.c node = kzalloc(size, GFP_KERNEL);
GFP_KERNEL 25 fs/hfs/btree.c tree = kzalloc(sizeof(*tree), GFP_KERNEL);
GFP_KERNEL 147 fs/hfs/dir.c rd = kmalloc(sizeof(struct hfs_readdir_data), GFP_KERNEL);
GFP_KERNEL 168 fs/hfs/mdb.c HFS_SB(sb)->bitmap = (__be32 *)__get_free_pages(GFP_KERNEL, PAGE_SIZE < 8192 ? 1 : 0);
GFP_KERNEL 148 fs/hfs/super.c i = kmem_cache_alloc(hfs_inode_cachep, GFP_KERNEL);
GFP_KERNEL 361 fs/hfs/super.c sbi = kzalloc(sizeof(struct hfs_sb_info), GFP_KERNEL);
GFP_KERNEL 20 fs/hfsplus/bfind.c ptr = kmalloc(tree->max_key_len * 2 + 4, GFP_KERNEL);
GFP_KERNEL 412 fs/hfsplus/bnode.c node = kzalloc(size, GFP_KERNEL);
GFP_KERNEL 29 fs/hfsplus/btree.c tree = kzalloc(sizeof(*tree), GFP_KERNEL);
GFP_KERNEL 213 fs/hfsplus/dir.c rd = kmalloc(sizeof(struct hfsplus_readdir_data), GFP_KERNEL);
GFP_KERNEL 295 fs/hfsplus/super.c sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
GFP_KERNEL 461 fs/hfsplus/super.c i = kmem_cache_alloc(hfsplus_inode_cachep, GFP_KERNEL);
GFP_KERNEL 107 fs/hostfs/hostfs_kern.c name = kmalloc(len + extra + 1, GFP_KERNEL);
GFP_KERNEL 167 fs/hostfs/hostfs_kern.c name = kmalloc(len, GFP_KERNEL);
GFP_KERNEL 190 fs/hostfs/hostfs_kern.c resolved = kmalloc(len, GFP_KERNEL);
GFP_KERNEL 290 fs/hostfs/hostfs_kern.c hi = kmalloc(sizeof(*hi), GFP_KERNEL);
GFP_KERNEL 981 fs/hostfs/hostfs_kern.c + strlen(req_root) + 1, GFP_KERNEL);
GFP_KERNEL 75 fs/hpfs/map.c if (!(cp_table = kmalloc(256, GFP_KERNEL))) {
GFP_KERNEL 98 fs/hpfs/map.c if (!(b = kmalloc(n * 512, GFP_KERNEL))) {
GFP_KERNEL 98 fs/hpfs/name.c if (!(to = kmalloc(len, GFP_KERNEL))) {
GFP_KERNEL 389 fs/hpfs/super.c char *new_opts = kstrdup(data, GFP_KERNEL);
GFP_KERNEL 468 fs/hpfs/super.c sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
GFP_KERNEL 83 fs/hppfs/hppfs.c name = kmalloc(len + extra + 1, GFP_KERNEL);
GFP_KERNEL 218 fs/hppfs/hppfs.c new_buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
GFP_KERNEL 345 fs/hppfs/hppfs.c data = kmalloc(sizeof(*data), GFP_KERNEL);
GFP_KERNEL 382 fs/hppfs/hppfs.c new = kmalloc(sizeof(*data), GFP_KERNEL);
GFP_KERNEL 406 fs/hppfs/hppfs.c data = kmalloc(sizeof(*data), GFP_KERNEL);
GFP_KERNEL 610 fs/hppfs/hppfs.c hi = kmalloc(sizeof(*hi), GFP_KERNEL);
GFP_KERNEL 685 fs/hugetlbfs/inode.c p = kmem_cache_alloc(hugetlbfs_inode_cachep, GFP_KERNEL);
GFP_KERNEL 865 fs/hugetlbfs/inode.c sbinfo = kmalloc(sizeof(struct hugetlbfs_sb_info), GFP_KERNEL);
GFP_KERNEL 121 fs/inode.c inode = (struct inode *) kmem_cache_alloc(inode_cachep, GFP_KERNEL);
GFP_KERNEL 138 fs/inotify.c if (unlikely(!idr_pre_get(&ih->idr, GFP_KERNEL)))
GFP_KERNEL 453 fs/inotify.c ih = kmalloc(sizeof(struct inotify_handle), GFP_KERNEL);
GFP_KERNEL 223 fs/inotify_user.c kevent->name = kmalloc(len + rem, GFP_KERNEL);
GFP_KERNEL 396 fs/inotify_user.c watch = kmem_cache_alloc(watch_cachep, GFP_KERNEL);
GFP_KERNEL 614 fs/inotify_user.c dev = kmalloc(sizeof(struct inotify_device), GFP_KERNEL);
GFP_KERNEL 259 fs/isofs/dir.c tmpname = (char *)__get_free_page(GFP_KERNEL);
GFP_KERNEL 65 fs/isofs/inode.c ei = kmem_cache_alloc(isofs_inode_cachep, GFP_KERNEL);
GFP_KERNEL 567 fs/isofs/inode.c sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
GFP_KERNEL 1158 fs/isofs/inode.c tmpde = kmalloc(256, GFP_KERNEL);
GFP_KERNEL 1239 fs/isofs/inode.c tmpde = kmalloc(de_len, GFP_KERNEL);
GFP_KERNEL 103 fs/isofs/rock.c rs->buffer = kmalloc(rs->cont_size, GFP_KERNEL);
GFP_KERNEL 657 fs/jbd/journal.c journal = kzalloc(sizeof(*journal), GFP_KERNEL);
GFP_KERNEL 727 fs/jbd/journal.c journal->j_wbuf = kmalloc(n * sizeof(struct buffer_head*), GFP_KERNEL);
GFP_KERNEL 781 fs/jbd/journal.c journal->j_wbuf = kmalloc(n * sizeof(struct buffer_head*), GFP_KERNEL);
GFP_KERNEL 214 fs/jbd/revoke.c table = kmem_cache_alloc(revoke_table_cache, GFP_KERNEL);
GFP_KERNEL 224 fs/jbd/revoke.c kmalloc(hash_size * sizeof(struct list_head), GFP_KERNEL);
GFP_KERNEL 751 fs/jbd2/journal.c s = kmalloc(sizeof(*s), GFP_KERNEL);
GFP_KERNEL 755 fs/jbd2/journal.c s->stats = kmalloc(size, GFP_KERNEL);
GFP_KERNEL 853 fs/jbd2/journal.c s = kmalloc(sizeof(*s), GFP_KERNEL);
GFP_KERNEL 857 fs/jbd2/journal.c s->stats = kmalloc(size, GFP_KERNEL);
GFP_KERNEL 925 fs/jbd2/journal.c journal->j_history = kzalloc(size, GFP_KERNEL);
GFP_KERNEL 947 fs/jbd2/journal.c journal = kzalloc(sizeof(*journal), GFP_KERNEL|__GFP_NOFAIL);
GFP_KERNEL 1021 fs/jbd2/journal.c journal->j_wbuf = kmalloc(n * sizeof(struct buffer_head*), GFP_KERNEL);
GFP_KERNEL 1088 fs/jbd2/journal.c journal->j_wbuf = kmalloc(n * sizeof(struct buffer_head*), GFP_KERNEL);
GFP_KERNEL 213 fs/jbd2/revoke.c table = kmem_cache_alloc(jbd2_revoke_table_cache, GFP_KERNEL);
GFP_KERNEL 223 fs/jbd2/revoke.c kmalloc(hash_size * sizeof(struct list_head), GFP_KERNEL);
GFP_KERNEL 79 fs/jffs2/acl.c acl = posix_acl_alloc(count, GFP_KERNEL);
GFP_KERNEL 126 fs/jffs2/acl.c header = kmalloc(sizeof(*header) + acl->a_count * sizeof(*entry), GFP_KERNEL);
GFP_KERNEL 204 fs/jffs2/acl.c value = kmalloc(rc, GFP_KERNEL);
GFP_KERNEL 344 fs/jffs2/acl.c clone = posix_acl_clone(acl, GFP_KERNEL);
GFP_KERNEL 402 fs/jffs2/acl.c clone = posix_acl_clone(acl, GFP_KERNEL);
GFP_KERNEL 341 fs/jffs2/build.c c->blocks = kmalloc(size, GFP_KERNEL);
GFP_KERNEL 88 fs/jffs2/compr.c output_buf = kmalloc(*cdatalen,GFP_KERNEL);
GFP_KERNEL 139 fs/jffs2/compr.c tmp_buf = kmalloc(orig_slen, GFP_KERNEL);
GFP_KERNEL 128 fs/jffs2/debug.c buf = kmalloc(len, GFP_KERNEL);
GFP_KERNEL 369 fs/jffs2/dir.c f->target = kmalloc(targetlen + 1, GFP_KERNEL);
GFP_KERNEL 50 fs/jffs2/erase.c instr = kmalloc(sizeof(struct erase_info) + sizeof(struct erase_priv_struct), GFP_KERNEL);
GFP_KERNEL 362 fs/jffs2/erase.c ebuf = kmalloc(PAGE_SIZE, GFP_KERNEL);
GFP_KERNEL 529 fs/jffs2/fs.c c->inocache_list = kcalloc(INOCACHE_HASHSIZE, sizeof(struct jffs2_inode_cache *), GFP_KERNEL);
GFP_KERNEL 571 fs/jffs2/gc.c node = kmalloc(rawlen, GFP_KERNEL);
GFP_KERNEL 715 fs/jffs2/gc.c mdata = kmalloc(fn->size, GFP_KERNEL);
GFP_KERNEL 848 fs/jffs2/gc.c rd = kmalloc(rawlen, GFP_KERNEL);
GFP_KERNEL 123 fs/jffs2/malloc.c ret = kmalloc(sizeof(struct jffs2_full_dirent) + namesize, GFP_KERNEL);
GFP_KERNEL 137 fs/jffs2/malloc.c ret = kmem_cache_alloc(full_dnode_slab, GFP_KERNEL);
GFP_KERNEL 151 fs/jffs2/malloc.c ret = kmem_cache_alloc(raw_dirent_slab, GFP_KERNEL);
GFP_KERNEL 165 fs/jffs2/malloc.c ret = kmem_cache_alloc(raw_inode_slab, GFP_KERNEL);
GFP_KERNEL 179 fs/jffs2/malloc.c ret = kmem_cache_alloc(tmp_dnode_info_slab, GFP_KERNEL);
GFP_KERNEL 195 fs/jffs2/malloc.c ret = kmem_cache_alloc(raw_node_ref_slab, GFP_KERNEL);
GFP_KERNEL 258 fs/jffs2/malloc.c ret = kmem_cache_alloc(node_frag_slab, GFP_KERNEL);
GFP_KERNEL 272 fs/jffs2/malloc.c ret = kmem_cache_alloc(inode_cache_slab, GFP_KERNEL);
GFP_KERNEL 287 fs/jffs2/malloc.c xd = kmem_cache_alloc(xattr_datum_cache, GFP_KERNEL);
GFP_KERNEL 306 fs/jffs2/malloc.c ref = kmem_cache_alloc(xattr_ref_cache, GFP_KERNEL);
GFP_KERNEL 90 fs/jffs2/read.c readbuf = kmalloc(je32_to_cpu(ri->csize), GFP_KERNEL);
GFP_KERNEL 98 fs/jffs2/read.c decomprbuf = kmalloc(je32_to_cpu(ri->dsize), GFP_KERNEL);
GFP_KERNEL 79 fs/jffs2/readinode.c buffer = kmalloc(len, GFP_KERNEL);
GFP_KERNEL 970 fs/jffs2/readinode.c buf = kmalloc(len, GFP_KERNEL);
GFP_KERNEL 1245 fs/jffs2/readinode.c f->target = kmalloc(je32_to_cpu(latest_node->csize) + 1, GFP_KERNEL);
GFP_KERNEL 1379 fs/jffs2/readinode.c struct jffs2_inode_info *f = kzalloc(sizeof(*f), GFP_KERNEL);
GFP_KERNEL 125 fs/jffs2/scan.c flashbuf = kmalloc(buf_size, GFP_KERNEL);
GFP_KERNEL 131 fs/jffs2/scan.c s = kzalloc(sizeof(struct jffs2_summary), GFP_KERNEL);
GFP_KERNEL 506 fs/jffs2/scan.c sumptr = kmalloc(sumlen, GFP_KERNEL);
GFP_KERNEL 28 fs/jffs2/summary.c c->summary = kzalloc(sizeof(struct jffs2_summary), GFP_KERNEL);
GFP_KERNEL 35 fs/jffs2/summary.c c->summary->sum_buf = kmalloc(sum_size, GFP_KERNEL);
GFP_KERNEL 116 fs/jffs2/summary.c struct jffs2_sum_inode_mem *temp = kmalloc(sizeof(struct jffs2_sum_inode_mem), GFP_KERNEL);
GFP_KERNEL 135 fs/jffs2/summary.c kmalloc(sizeof(struct jffs2_sum_dirent_mem) + rd->nsize, GFP_KERNEL);
GFP_KERNEL 160 fs/jffs2/summary.c temp = kmalloc(sizeof(struct jffs2_sum_xattr_mem), GFP_KERNEL);
GFP_KERNEL 178 fs/jffs2/summary.c temp = kmalloc(sizeof(struct jffs2_sum_xref_mem), GFP_KERNEL);
GFP_KERNEL 264 fs/jffs2/summary.c kmalloc(sizeof(struct jffs2_sum_inode_mem), GFP_KERNEL);
GFP_KERNEL 281 fs/jffs2/summary.c kmalloc(sizeof(struct jffs2_sum_dirent_mem) + node->d.nsize, GFP_KERNEL);
GFP_KERNEL 315 fs/jffs2/summary.c temp = kmalloc(sizeof(struct jffs2_sum_xattr_mem), GFP_KERNEL);
GFP_KERNEL 330 fs/jffs2/summary.c temp = kmalloc(sizeof(struct jffs2_sum_xref_mem), GFP_KERNEL);
GFP_KERNEL 36 fs/jffs2/super.c f = kmem_cache_alloc(jffs2_inode_cachep, GFP_KERNEL);
GFP_KERNEL 89 fs/jffs2/super.c c = kzalloc(sizeof(*c), GFP_KERNEL);
GFP_KERNEL 92 fs/jffs2/wbuf.c new = kmalloc(sizeof(*new), GFP_KERNEL);
GFP_KERNEL 332 fs/jffs2/wbuf.c buf = kmalloc(end - start, GFP_KERNEL);
GFP_KERNEL 1173 fs/jffs2/wbuf.c c->wbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
GFP_KERNEL 1177 fs/jffs2/wbuf.c c->oobbuf = kmalloc(NR_OOB_SCAN_PAGES * c->oobavail, GFP_KERNEL);
GFP_KERNEL 1184 fs/jffs2/wbuf.c c->wbuf_verify = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
GFP_KERNEL 1235 fs/jffs2/wbuf.c c->wbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
GFP_KERNEL 1240 fs/jffs2/wbuf.c c->wbuf_verify = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
GFP_KERNEL 1270 fs/jffs2/wbuf.c c->wbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
GFP_KERNEL 1292 fs/jffs2/wbuf.c c->wbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
GFP_KERNEL 211 fs/jffs2/xattr.c data = kmalloc(length, GFP_KERNEL);
GFP_KERNEL 362 fs/jffs2/xattr.c data = kmalloc(name_len + 1 + xsize, GFP_KERNEL);
GFP_KERNEL 58 fs/jfs/acl.c value = kmalloc(size, GFP_KERNEL);
GFP_KERNEL 108 fs/jfs/acl.c value = kmalloc(size, GFP_KERNEL);
GFP_KERNEL 168 fs/jfs/acl.c clone = posix_acl_clone(acl, GFP_KERNEL);
GFP_KERNEL 205 fs/jfs/acl.c clone = posix_acl_clone(acl, GFP_KERNEL);
GFP_KERNEL 175 fs/jfs/jfs_dmap.c bmp = kmalloc(sizeof(struct bmap), GFP_KERNEL);
GFP_KERNEL 3176 fs/jfs/jfs_dtree.c dirent_buf = __get_free_page(GFP_KERNEL);
GFP_KERNEL 3773 fs/jfs/jfs_dtree.c GFP_KERNEL);
GFP_KERNEL 3778 fs/jfs/jfs_dtree.c GFP_KERNEL);
GFP_KERNEL 123 fs/jfs/jfs_imap.c imap = kmalloc(sizeof(struct inomap), GFP_KERNEL);
GFP_KERNEL 1111 fs/jfs/jfs_logmgr.c if (!(log = kzalloc(sizeof(struct jfs_log), GFP_KERNEL))) {
GFP_KERNEL 1186 fs/jfs/jfs_logmgr.c if (!(log = kzalloc(sizeof(struct jfs_log), GFP_KERNEL)))
GFP_KERNEL 1220 fs/jfs/jfs_logmgr.c dummy_log = kzalloc(sizeof(struct jfs_log), GFP_KERNEL);
GFP_KERNEL 1847 fs/jfs/jfs_logmgr.c buffer = (char *) get_zeroed_page(GFP_KERNEL);
GFP_KERNEL 1852 fs/jfs/jfs_logmgr.c lbuf = kmalloc(sizeof(struct lbuf), GFP_KERNEL);
GFP_KERNEL 425 fs/jfs/super.c sbi = kzalloc(sizeof (struct jfs_sb_info), GFP_KERNEL);
GFP_KERNEL 518 fs/jfs/xattr.c ea_buf->xattr = kmalloc(size, GFP_KERNEL);
GFP_KERNEL 800 fs/jfs/xattr.c GFP_KERNEL);
GFP_KERNEL 964 fs/jfs/xattr.c GFP_KERNEL);
GFP_KERNEL 590 fs/libfs.c ar = (struct simple_transaction_argresp *)get_zeroed_page(GFP_KERNEL);
GFP_KERNEL 648 fs/libfs.c attr = kmalloc(sizeof(*attr), GFP_KERNEL);
GFP_KERNEL 92 fs/lockd/clntlock.c block = kmalloc(sizeof(*block), GFP_KERNEL);
GFP_KERNEL 103 fs/lockd/clntproc.c new = kmalloc(sizeof(*new), GFP_KERNEL);
GFP_KERNEL 199 fs/lockd/clntproc.c call = kzalloc(sizeof(*call), GFP_KERNEL);
GFP_KERNEL 200 fs/lockd/host.c host = kzalloc(sizeof(*host), GFP_KERNEL);
GFP_KERNEL 676 fs/lockd/host.c nsm = kzalloc(sizeof(*nsm) + hostname_len + 1, GFP_KERNEL);
GFP_KERNEL 189 fs/lockd/svclock.c block = kzalloc(sizeof(*block), GFP_KERNEL);
GFP_KERNEL 315 fs/lockd/svclock.c void *data = kmalloc(lock->oh.len, GFP_KERNEL);
GFP_KERNEL 480 fs/lockd/svclock.c struct file_lock *conf = kzalloc(sizeof(*conf), GFP_KERNEL);
GFP_KERNEL 43 fs/lockd/svcshare.c GFP_KERNEL);
GFP_KERNEL 106 fs/lockd/svcsubs.c file = kzalloc(sizeof(*file), GFP_KERNEL);
GFP_KERNEL 151 fs/locks.c return kmem_cache_alloc(filelock_cache, GFP_KERNEL);
GFP_KERNEL 184 fs/mbcache.c __mb_cache_entry_forget(ce, GFP_KERNEL);
GFP_KERNEL 265 fs/mbcache.c indexes_count * sizeof(struct list_head), GFP_KERNEL);
GFP_KERNEL 280 fs/mbcache.c GFP_KERNEL);
GFP_KERNEL 288 fs/mbcache.c GFP_KERNEL);
GFP_KERNEL 342 fs/mbcache.c e_lru_list), GFP_KERNEL);
GFP_KERNEL 375 fs/mbcache.c e_lru_list), GFP_KERNEL);
GFP_KERNEL 60 fs/minix/inode.c ei = (struct minix_inode_info *)kmem_cache_alloc(minix_inode_cachep, GFP_KERNEL);
GFP_KERNEL 152 fs/minix/inode.c sbi = kzalloc(sizeof(struct minix_sb_info), GFP_KERNEL);
GFP_KERNEL 225 fs/minix/inode.c map = kzalloc(i, GFP_KERNEL);
GFP_KERNEL 300 fs/mpage.c GFP_KERNEL);
GFP_KERNEL 388 fs/mpage.c page->index, GFP_KERNEL)) {
GFP_KERNEL 69 fs/namespace.c ida_pre_get(&mnt_id_ida, GFP_KERNEL);
GFP_KERNEL 93 fs/namespace.c if (!ida_pre_get(&mnt_group_ida, GFP_KERNEL))
GFP_KERNEL 110 fs/namespace.c struct vfsmount *mnt = kmem_cache_zalloc(mnt_cache, GFP_KERNEL);
GFP_KERNEL 119 fs/namespace.c mnt->mnt_devname = kstrdup(name, GFP_KERNEL);
GFP_KERNEL 723 fs/namespace.c sb->s_options = kstrdup(options, GFP_KERNEL);
GFP_KERNEL 1865 fs/namespace.c if (!(page = __get_free_page(GFP_KERNEL)))
GFP_KERNEL 1980 fs/namespace.c new_ns = kmalloc(sizeof(struct mnt_namespace), GFP_KERNEL);
GFP_KERNEL 2289 fs/namespace.c ns = kmalloc(sizeof(*ns), GFP_KERNEL);
GFP_KERNEL 56 fs/ncpfs/inode.c ei = (struct ncp_inode_info *)kmem_cache_alloc(ncp_inode_cachep, GFP_KERNEL);
GFP_KERNEL 449 fs/ncpfs/inode.c server = kzalloc(sizeof(struct ncp_server), GFP_KERNEL);
GFP_KERNEL 1190 fs/ncpfs/ncplib_kernel.c vname_cc = kmalloc(vlen, GFP_KERNEL);
GFP_KERNEL 76 fs/ncpfs/sock.c req = kmalloc(sizeof(struct ncp_request_reply), GFP_KERNEL);
GFP_KERNEL 51 fs/ncpfs/symlink.c rawlink = kmalloc(NCP_MAX_SYMLINK_SIZE, GFP_KERNEL);
GFP_KERNEL 129 fs/ncpfs/symlink.c rawlink = kmalloc(NCP_MAX_SYMLINK_SIZE, GFP_KERNEL);
GFP_KERNEL 117 fs/nfs/client.c if ((clp = kzalloc(sizeof(*clp), GFP_KERNEL)) == NULL)
GFP_KERNEL 135 fs/nfs/client.c clp->cl_hostname = kstrdup(cl_init->hostname, GFP_KERNEL);
GFP_KERNEL 843 fs/nfs/client.c server = kzalloc(sizeof(struct nfs_server), GFP_KERNEL);
GFP_KERNEL 165 fs/nfs/delegation.c delegation = kmalloc(sizeof(*delegation), GFP_KERNEL);
GFP_KERNEL 1508 fs/nfs/dir.c GFP_KERNEL)) {
GFP_KERNEL 1846 fs/nfs/dir.c struct nfs_access_entry *cache = kmalloc(sizeof(*cache), GFP_KERNEL);
GFP_KERNEL 152 fs/nfs/direct.c dreq = kmem_cache_alloc(nfs_direct_cachep, GFP_KERNEL);
GFP_KERNEL 118 fs/nfs/idmap.c idmap = kzalloc(sizeof(*idmap), GFP_KERNEL);
GFP_KERNEL 553 fs/nfs/inode.c ctx = kmalloc(sizeof(*ctx), GFP_KERNEL);
GFP_KERNEL 1215 fs/nfs/inode.c nfsi = (struct nfs_inode *)kmem_cache_alloc(nfs_inode_cachep, GFP_KERNEL);
GFP_KERNEL 380 fs/nfs/nfs3acl.c alloc = acl = posix_acl_from_mode(inode->i_mode, GFP_KERNEL);
GFP_KERNEL 405 fs/nfs/nfs3acl.c acl = posix_acl_clone(dfacl, GFP_KERNEL);
GFP_KERNEL 271 fs/nfs/nfs3proc.c data = kzalloc(sizeof(*data), GFP_KERNEL);
GFP_KERNEL 720 fs/nfs/nfs3xdr.c args->pages[count] = alloc_page(GFP_KERNEL);
GFP_KERNEL 228 fs/nfs/nfs4namespace.c page = alloc_page(GFP_KERNEL);
GFP_KERNEL 232 fs/nfs/nfs4namespace.c fs_locations = kmalloc(sizeof(struct nfs4_fs_locations), GFP_KERNEL);
GFP_KERNEL 259 fs/nfs/nfs4proc.c p = kzalloc(sizeof(*p), GFP_KERNEL);
GFP_KERNEL 1320 fs/nfs/nfs4proc.c calldata = kmalloc(sizeof(*calldata), GFP_KERNEL);
GFP_KERNEL 1567 fs/nfs/nfs4proc.c page = alloc_page(GFP_KERNEL);
GFP_KERNEL 1570 fs/nfs/nfs4proc.c locations = kmalloc(sizeof(struct nfs4_fs_locations), GFP_KERNEL);
GFP_KERNEL 2093 fs/nfs/nfs4proc.c data = kzalloc(sizeof(*data), GFP_KERNEL);
GFP_KERNEL 2604 fs/nfs/nfs4proc.c acl = kmalloc(sizeof(*acl) + acl_len, GFP_KERNEL);
GFP_KERNEL 2610 fs/nfs/nfs4proc.c acl = kmalloc(sizeof(*acl), GFP_KERNEL);
GFP_KERNEL 2641 fs/nfs/nfs4proc.c localpage = alloc_page(GFP_KERNEL);
GFP_KERNEL 2986 fs/nfs/nfs4proc.c data = kmalloc(sizeof(*data), GFP_KERNEL);
GFP_KERNEL 3143 fs/nfs/nfs4proc.c p = kmalloc(sizeof(*p), GFP_KERNEL);
GFP_KERNEL 3299 fs/nfs/nfs4proc.c p = kzalloc(sizeof(*p), GFP_KERNEL);
GFP_KERNEL 271 fs/nfs/nfs4state.c sp = kzalloc(sizeof(*sp),GFP_KERNEL);
GFP_KERNEL 353 fs/nfs/nfs4state.c state = kzalloc(sizeof(*state), GFP_KERNEL);
GFP_KERNEL 540 fs/nfs/nfs4state.c lsp = kzalloc(sizeof(*lsp), GFP_KERNEL);
GFP_KERNEL 681 fs/nfs/nfs4state.c new = kmalloc(sizeof(*new), GFP_KERNEL);
GFP_KERNEL 30 fs/nfs/pagelist.c p = kmem_cache_alloc(nfs_page_cachep, GFP_KERNEL);
GFP_KERNEL 743 fs/nfs/super.c p = kstrndup(delim + 1, len, GFP_KERNEL);
GFP_KERNEL 1371 fs/nfs/super.c *hostname = kstrndup(dev_name, len, GFP_KERNEL);
GFP_KERNEL 1387 fs/nfs/super.c *export_path = kstrndup(colon, len, GFP_KERNEL);
GFP_KERNEL 1436 fs/nfs/super.c *hostname = kstrndup(start, len, GFP_KERNEL);
GFP_KERNEL 1444 fs/nfs/super.c *export_path = kstrndup(end, len, GFP_KERNEL);
GFP_KERNEL 1581 fs/nfs/super.c args->nfs_server.hostname = kstrdup(data->hostname, GFP_KERNEL);
GFP_KERNEL 1601 fs/nfs/super.c char *opts_str = kmalloc(sizeof(data->context) + 8, GFP_KERNEL);
GFP_KERNEL 1732 fs/nfs/super.c data = kzalloc(sizeof(*data), GFP_KERNEL);
GFP_KERNEL 1959 fs/nfs/super.c data = kzalloc(sizeof(*data), GFP_KERNEL);
GFP_KERNEL 1960 fs/nfs/super.c mntfh = kzalloc(sizeof(*mntfh), GFP_KERNEL);
GFP_KERNEL 2313 fs/nfs/super.c data = kzalloc(sizeof(*data), GFP_KERNEL);
GFP_KERNEL 2314 fs/nfs/super.c mntfh = kzalloc(sizeof(*mntfh), GFP_KERNEL);
GFP_KERNEL 51 fs/nfs/unlink.c str = kmemdup(dentry->d_name.name, NAME_ALLOC_LEN(len), GFP_KERNEL);
GFP_KERNEL 234 fs/nfs/unlink.c data = kzalloc(sizeof(*data), GFP_KERNEL);
GFP_KERNEL 98 fs/nfs_common/nfsacl.c acl2 = posix_acl_alloc(4, GFP_KERNEL);
GFP_KERNEL 136 fs/nfs_common/nfsacl.c nfsacl_desc->acl = posix_acl_alloc(desc->array_len, GFP_KERNEL);
GFP_KERNEL 108 fs/nfsd/export.c buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
GFP_KERNEL 250 fs/nfsd/export.c struct svc_expkey *i = kmalloc(sizeof(*i), GFP_KERNEL);
GFP_KERNEL 415 fs/nfsd/export.c * sizeof(struct nfsd4_fs_location), GFP_KERNEL);
GFP_KERNEL 425 fs/nfsd/export.c fsloc->locations[i].hosts = kstrdup(buf, GFP_KERNEL);
GFP_KERNEL 434 fs/nfsd/export.c fsloc->locations[i].path = kstrdup(buf, GFP_KERNEL);
GFP_KERNEL 524 fs/nfsd/export.c buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
GFP_KERNEL 549 fs/nfsd/export.c exp.ex_pathname = kstrdup(buf, GFP_KERNEL);
GFP_KERNEL 594 fs/nfsd/export.c kmemdup(buf, 16, GFP_KERNEL);
GFP_KERNEL 727 fs/nfsd/export.c struct svc_export *i = kmalloc(sizeof(*i), GFP_KERNEL);
GFP_KERNEL 1063 fs/nfsd/export.c new.ex_pathname = kstrdup(nxp->ex_path, GFP_KERNEL);
GFP_KERNEL 67 fs/nfsd/nfs2acl.c acl = posix_acl_from_mode(inode->i_mode, GFP_KERNEL);
GFP_KERNEL 63 fs/nfsd/nfs3acl.c acl = posix_acl_from_mode(inode->i_mode, GFP_KERNEL);
GFP_KERNEL 447 fs/nfsd/nfs4acl.c state->users = kzalloc(alloc, GFP_KERNEL);
GFP_KERNEL 450 fs/nfsd/nfs4acl.c state->groups = kzalloc(alloc, GFP_KERNEL);
GFP_KERNEL 513 fs/nfsd/nfs4acl.c pacl = posix_acl_alloc(0, GFP_KERNEL);
GFP_KERNEL 522 fs/nfsd/nfs4acl.c pacl = posix_acl_alloc(nace, GFP_KERNEL);
GFP_KERNEL 788 fs/nfsd/nfs4acl.c acl = kmalloc(sizeof(*acl) + n*sizeof(struct nfs4_ace), GFP_KERNEL);
GFP_KERNEL 105 fs/nfsd/nfs4idmap.c struct ent *e = kmalloc(sizeof(*e), GFP_KERNEL);
GFP_KERNEL 217 fs/nfsd/nfs4idmap.c buf1 = kmalloc(PAGE_SIZE, GFP_KERNEL);
GFP_KERNEL 387 fs/nfsd/nfs4idmap.c buf1 = kmalloc(PAGE_SIZE, GFP_KERNEL);
GFP_KERNEL 578 fs/nfsd/nfs4idmap.c mdr = kzalloc(sizeof(*mdr), GFP_KERNEL);
GFP_KERNEL 753 fs/nfsd/nfs4proc.c buf = kmalloc(count << 2, GFP_KERNEL);
GFP_KERNEL 830 fs/nfsd/nfs4proc.c cstate = kmalloc(sizeof(struct nfsd4_compound_state), GFP_KERNEL);
GFP_KERNEL 102 fs/nfsd/nfs4recover.c cksum.data = kmalloc(cksum.len, GFP_KERNEL);
GFP_KERNEL 203 fs/nfsd/nfs4recover.c child = kmalloc(sizeof(*child), GFP_KERNEL);
GFP_KERNEL 201 fs/nfsd/nfs4state.c dp = kmem_cache_alloc(deleg_slab, GFP_KERNEL);
GFP_KERNEL 346 fs/nfsd/nfs4state.c clp = kzalloc(sizeof(struct nfs4_client), GFP_KERNEL);
GFP_KERNEL 349 fs/nfsd/nfs4state.c clp->cl_name.data = kmalloc(name.len, GFP_KERNEL);
GFP_KERNEL 912 fs/nfsd/nfs4state.c fp = kmem_cache_alloc(file_slab, GFP_KERNEL);
GFP_KERNEL 985 fs/nfsd/nfs4state.c if ((sop = kmem_cache_alloc(stateowner_slab, GFP_KERNEL))) {
GFP_KERNEL 986 fs/nfsd/nfs4state.c if ((sop->so_owner.data = kmalloc(owner->len, GFP_KERNEL))) {
GFP_KERNEL 1527 fs/nfsd/nfs4state.c return kmem_cache_alloc(stateid_slab, GFP_KERNEL);
GFP_KERNEL 3018 fs/nfsd/nfs4state.c return kmalloc(sizeof(struct nfs4_client_reclaim), GFP_KERNEL);
GFP_KERNEL 167 fs/nfsd/nfs4xdr.c p = argp->tmpp = kmalloc(nbytes, GFP_KERNEL);
GFP_KERNEL 199 fs/nfsd/nfs4xdr.c tb = kmalloc(sizeof(*tb), GFP_KERNEL);
GFP_KERNEL 212 fs/nfsd/nfs4xdr.c p = kmalloc(nbytes, GFP_KERNEL);
GFP_KERNEL 1091 fs/nfsd/nfs4xdr.c argp->ops = kmalloc(argp->opcnt * sizeof(*argp->ops), GFP_KERNEL);
GFP_KERNEL 55 fs/nfsd/nfscache.c rp = kmalloc(sizeof(*rp), GFP_KERNEL);
GFP_KERNEL 65 fs/nfsd/nfscache.c hash_list = kcalloc (HASHSIZE, sizeof(struct hlist_head), GFP_KERNEL);
GFP_KERNEL 282 fs/nfsd/nfscache.c cachv->iov_base = kmalloc(len << 2, GFP_KERNEL);
GFP_KERNEL 475 fs/nfsd/nfsctl.c nthreads = kcalloc(npools, sizeof(int), GFP_KERNEL);
GFP_KERNEL 631 fs/nfsd/nfsctl.c char *toclose = kstrdup(buf+1, GFP_KERNEL);
GFP_KERNEL 418 fs/nfsd/vfs.c *buf = kmalloc(buflen, GFP_KERNEL);
GFP_KERNEL 436 fs/nfsd/vfs.c buf = kmalloc(buflen, GFP_KERNEL);
GFP_KERNEL 525 fs/nfsd/vfs.c pacl = posix_acl_from_mode(inode->i_mode, GFP_KERNEL);
GFP_KERNEL 1541 fs/nfsd/vfs.c char *path_alloced = kmalloc(plen+1, GFP_KERNEL);
GFP_KERNEL 2009 fs/nfsd/vfs.c *raparm = kzalloc(sizeof(struct raparms), GFP_KERNEL);
GFP_KERNEL 2084 fs/nfsd/vfs.c value = kmalloc(size, GFP_KERNEL);
GFP_KERNEL 433 fs/ntfs/file.c GFP_KERNEL);
GFP_KERNEL 883 fs/ocfs2/alloc.c GFP_KERNEL);
GFP_KERNEL 5639 fs/ocfs2/alloc.c *tl_copy = kmalloc(tl_bh->b_size, GFP_KERNEL);
GFP_KERNEL 6978 fs/ocfs2/alloc.c *tc = kzalloc(sizeof(struct ocfs2_truncate_context), GFP_KERNEL);
GFP_KERNEL 1132 fs/ocfs2/cluster/heartbeat.c reg->hr_tmp_block = kmalloc(reg->hr_block_bytes, GFP_KERNEL);
GFP_KERNEL 1139 fs/ocfs2/cluster/heartbeat.c sizeof(struct o2hb_disk_slot), GFP_KERNEL);
GFP_KERNEL 1158 fs/ocfs2/cluster/heartbeat.c GFP_KERNEL);
GFP_KERNEL 1165 fs/ocfs2/cluster/heartbeat.c page = alloc_page(GFP_KERNEL);
GFP_KERNEL 1497 fs/ocfs2/cluster/heartbeat.c reg = kzalloc(sizeof(struct o2hb_region), GFP_KERNEL);
GFP_KERNEL 1631 fs/ocfs2/cluster/heartbeat.c hs = kzalloc(sizeof(struct o2hb_heartbeat_group), GFP_KERNEL);
GFP_KERNEL 179 fs/ocfs2/cluster/netdebug.c dummy_nst = kmalloc(sizeof(struct o2net_send_tracking), GFP_KERNEL);
GFP_KERNEL 360 fs/ocfs2/cluster/netdebug.c dummy_sc = kmalloc(sizeof(struct o2net_sock_container), GFP_KERNEL);
GFP_KERNEL 655 fs/ocfs2/cluster/nodemanager.c node = kzalloc(sizeof(struct o2nm_node), GFP_KERNEL);
GFP_KERNEL 760 fs/ocfs2/cluster/nodemanager.c cluster = kzalloc(sizeof(struct o2nm_cluster), GFP_KERNEL);
GFP_KERNEL 761 fs/ocfs2/cluster/nodemanager.c ns = kzalloc(sizeof(struct o2nm_node_group), GFP_KERNEL);
GFP_KERNEL 762 fs/ocfs2/cluster/nodemanager.c defs = kcalloc(3, sizeof(struct config_group *), GFP_KERNEL);
GFP_KERNEL 2025 fs/ocfs2/cluster/tcp.c o2net_hand = kzalloc(sizeof(struct o2net_handshake), GFP_KERNEL);
GFP_KERNEL 2026 fs/ocfs2/cluster/tcp.c o2net_keep_req = kzalloc(sizeof(struct o2net_msg), GFP_KERNEL);
GFP_KERNEL 2027 fs/ocfs2/cluster/tcp.c o2net_keep_resp = kzalloc(sizeof(struct o2net_msg), GFP_KERNEL);
GFP_KERNEL 388 fs/ocfs2/dlm/dlmdebug.c db = kzalloc(sizeof(struct debug_buffer), GFP_KERNEL);
GFP_KERNEL 393 fs/ocfs2/dlm/dlmdebug.c db->buf = kmalloc(db->len, GFP_KERNEL);
GFP_KERNEL 705 fs/ocfs2/dlm/dlmdebug.c dl = kzalloc(sizeof(struct debug_lockres), GFP_KERNEL);
GFP_KERNEL 712 fs/ocfs2/dlm/dlmdebug.c dl->dl_buf = kmalloc(dl->dl_len, GFP_KERNEL);
GFP_KERNEL 1002 fs/ocfs2/dlm/dlmdebug.c GFP_KERNEL);
GFP_KERNEL 91 fs/ocfs2/dlm/dlmdomain.c void **vec = kmalloc(pages * sizeof(void *), GFP_KERNEL);
GFP_KERNEL 98 fs/ocfs2/dlm/dlmdomain.c if (!(vec[i] = (void *)__get_free_page(GFP_KERNEL)))
GFP_KERNEL 1180 fs/ocfs2/dlm/dlmdomain.c ctxt = kzalloc(sizeof(*ctxt), GFP_KERNEL);
GFP_KERNEL 1511 fs/ocfs2/dlm/dlmdomain.c dlm = kzalloc(sizeof(*dlm), GFP_KERNEL);
GFP_KERNEL 1517 fs/ocfs2/dlm/dlmdomain.c dlm->name = kmalloc(strlen(domain) + 1, GFP_KERNEL);
GFP_KERNEL 2445 fs/ocfs2/dlmglue.c dlm_debug = kmalloc(sizeof(struct ocfs2_dlm_debug), GFP_KERNEL);
GFP_KERNEL 2650 fs/ocfs2/dlmglue.c priv = kzalloc(sizeof(struct ocfs2_dlm_seq_priv), GFP_KERNEL);
GFP_KERNEL 72 fs/ocfs2/file.c fp = kzalloc(sizeof(struct ocfs2_file_private), GFP_KERNEL);
GFP_KERNEL 89 fs/ocfs2/journal.c GFP_KERNEL);
GFP_KERNEL 469 fs/ocfs2/localalloc.c *alloc_copy = kmalloc(alloc_bh->b_size, GFP_KERNEL);
GFP_KERNEL 1062 fs/ocfs2/localalloc.c *ac = kzalloc(sizeof(struct ocfs2_alloc_context), GFP_KERNEL);
GFP_KERNEL 1408 fs/ocfs2/namei.c bhs = kcalloc(blocks, sizeof(struct buffer_head *), GFP_KERNEL);
GFP_KERNEL 388 fs/ocfs2/slot_map.c GFP_KERNEL);
GFP_KERNEL 429 fs/ocfs2/slot_map.c GFP_KERNEL);
GFP_KERNEL 281 fs/ocfs2/stack_o2cb.c priv = kzalloc(sizeof(struct o2dlm_private), GFP_KERNEL);
GFP_KERNEL 208 fs/ocfs2/stack_user.c c = kzalloc(sizeof(struct ocfs2_live_connection), GFP_KERNEL);
GFP_KERNEL 610 fs/ocfs2/stack_user.c p = kzalloc(sizeof(struct ocfs2_control_private), GFP_KERNEL);
GFP_KERNEL 332 fs/ocfs2/stackglue.c GFP_KERNEL);
GFP_KERNEL 507 fs/ocfs2/suballoc.c *ac = kzalloc(sizeof(struct ocfs2_alloc_context), GFP_KERNEL);
GFP_KERNEL 585 fs/ocfs2/suballoc.c *ac = kzalloc(sizeof(struct ocfs2_alloc_context), GFP_KERNEL);
GFP_KERNEL 693 fs/ocfs2/suballoc.c *ac = kzalloc(sizeof(struct ocfs2_alloc_context), GFP_KERNEL);
GFP_KERNEL 1376 fs/ocfs2/super.c osb->uuid_str = kzalloc(OCFS2_VOL_UUID_LEN * 2 + 1, GFP_KERNEL);
GFP_KERNEL 1406 fs/ocfs2/super.c osb = kzalloc(sizeof(struct ocfs2_super), GFP_KERNEL);
GFP_KERNEL 1472 fs/ocfs2/super.c osb->vol_label = kmalloc(OCFS2_MAX_VOL_LABEL_LEN, GFP_KERNEL);
GFP_KERNEL 1490 fs/ocfs2/super.c GFP_KERNEL);
GFP_KERNEL 1500 fs/ocfs2/super.c GFP_KERNEL);
GFP_KERNEL 1558 fs/ocfs2/super.c journal = kzalloc(sizeof(struct ocfs2_journal), GFP_KERNEL);
GFP_KERNEL 309 fs/omfs/inode.c sbi->s_imap = kzalloc(array_size * sizeof(unsigned long *), GFP_KERNEL);
GFP_KERNEL 319 fs/omfs/inode.c *ptr = kmalloc(sb->s_blocksize, GFP_KERNEL);
GFP_KERNEL 417 fs/omfs/inode.c sbi = kzalloc(sizeof(struct omfs_sb_info), GFP_KERNEL);
GFP_KERNEL 341 fs/openpromfs/inode.c oi = kmem_cache_alloc(op_inode_cachep, GFP_KERNEL);
GFP_KERNEL 162 fs/partitions/check.c state = kmalloc(sizeof(struct parsed_partitions), GFP_KERNEL);
GFP_KERNEL 360 fs/partitions/check.c p = kzalloc(sizeof(*p), GFP_KERNEL);
GFP_KERNEL 233 fs/partitions/efi.c pte = kzalloc(count, GFP_KERNEL);
GFP_KERNEL 263 fs/partitions/efi.c gpt = kzalloc(sizeof (gpt_header), GFP_KERNEL);
GFP_KERNEL 518 fs/partitions/efi.c legacymbr = kzalloc(sizeof (*legacymbr), GFP_KERNEL);
GFP_KERNEL 67 fs/partitions/ibm.c info = kmalloc(sizeof(dasd_information2_t), GFP_KERNEL);
GFP_KERNEL 70 fs/partitions/ibm.c geo = kmalloc(sizeof(struct hd_geometry), GFP_KERNEL);
GFP_KERNEL 73 fs/partitions/ibm.c label = kmalloc(sizeof(union label_t), GFP_KERNEL);
GFP_KERNEL 337 fs/partitions/ldm.c ph[1] = kmalloc (sizeof (*ph[1]), GFP_KERNEL);
GFP_KERNEL 338 fs/partitions/ldm.c ph[2] = kmalloc (sizeof (*ph[2]), GFP_KERNEL);
GFP_KERNEL 426 fs/partitions/ldm.c tb[1] = kmalloc(sizeof(*tb[1]) * 3, GFP_KERNEL);
GFP_KERNEL 1234 fs/partitions/ldm.c vb = kmalloc (sizeof (*vb), GFP_KERNEL);
GFP_KERNEL 1311 fs/partitions/ldm.c f = kmalloc (sizeof (*f) + size*num, GFP_KERNEL);
GFP_KERNEL 1505 fs/partitions/ldm.c ldb = kmalloc (sizeof (*ldb), GFP_KERNEL);
GFP_KERNEL 824 fs/pipe.c pipe = kzalloc(sizeof(struct pipe_inode_info), GFP_KERNEL);
GFP_KERNEL 601 fs/proc/base.c p = kmalloc(sizeof(struct proc_mounts), GFP_KERNEL);
GFP_KERNEL 318 fs/proc/generic.c if (ida_pre_get(&proc_inum_ida, GFP_KERNEL) == 0)
GFP_KERNEL 585 fs/proc/generic.c ent = kmalloc(sizeof(struct proc_dir_entry) + len + 1, GFP_KERNEL);
GFP_KERNEL 612 fs/proc/generic.c ent->data = kmalloc((ent->size=strlen(dest))+1, GFP_KERNEL);
GFP_KERNEL 83 fs/proc/inode.c ei = (struct proc_inode *)kmem_cache_alloc(proc_inode_cachep, GFP_KERNEL);
GFP_KERNEL 337 fs/proc/inode.c pdeo = kmalloc(sizeof(struct pde_opener), GFP_KERNEL);
GFP_KERNEL 333 fs/proc/kcore.c elf_buf = kzalloc(tsz, GFP_KERNEL);
GFP_KERNEL 142 fs/proc/proc_devtree.c fixed_name = kmalloc(fixup_len, GFP_KERNEL);
GFP_KERNEL 446 fs/proc/proc_misc.c unsigned long *n = kzalloc(PAGE_SIZE, GFP_KERNEL);
GFP_KERNEL 477 fs/proc/proc_misc.c ptr = kmalloc(nr_node_ids * sizeof(unsigned int), GFP_KERNEL);
GFP_KERNEL 512 fs/proc/proc_misc.c per_irq_sum = kzalloc(sizeof(unsigned int)*NR_IRQS, GFP_KERNEL);
GFP_KERNEL 609 fs/proc/proc_misc.c buf = kmalloc(size, GFP_KERNEL);
GFP_KERNEL 199 fs/proc/proc_net.c netd = kzalloc(sizeof(*netd), GFP_KERNEL);
GFP_KERNEL 187 fs/proc/task_mmu.c priv = kzalloc(sizeof(*priv), GFP_KERNEL);
GFP_KERNEL 666 fs/proc/task_mmu.c pages = kcalloc(pagecount, sizeof(struct page *), GFP_KERNEL);
GFP_KERNEL 175 fs/proc/task_nommu.c priv = kzalloc(sizeof(*priv), GFP_KERNEL);
GFP_KERNEL 176 fs/proc/vmcore.c p = kmalloc(sizeof(*p), GFP_KERNEL);
GFP_KERNEL 239 fs/proc/vmcore.c notes_section = kmalloc(max_sz, GFP_KERNEL);
GFP_KERNEL 320 fs/proc/vmcore.c notes_section = kmalloc(max_sz, GFP_KERNEL);
GFP_KERNEL 524 fs/proc/vmcore.c elfcorebuf = kmalloc(elfcorebuf_sz, GFP_KERNEL);
GFP_KERNEL 580 fs/proc/vmcore.c elfcorebuf = kmalloc(elfcorebuf_sz, GFP_KERNEL);
GFP_KERNEL 330 fs/qnx4/inode.c qnx4_sb(sb)->BitMap = kmalloc( sizeof( struct qnx4_inode_entry ), GFP_KERNEL );
GFP_KERNEL 360 fs/qnx4/inode.c qs = kzalloc(sizeof(struct qnx4_sb_info), GFP_KERNEL);
GFP_KERNEL 545 fs/qnx4/inode.c ei = kmem_cache_alloc(qnx4_inode_cachep, GFP_KERNEL);
GFP_KERNEL 110 fs/ramfs/file-nommu.c ret = add_to_page_cache(page, inode->i_mapping, loop, GFP_KERNEL);
GFP_KERNEL 263 fs/ramfs/file-nommu.c pages = kzalloc(lpages * sizeof(struct page *), GFP_KERNEL);
GFP_KERNEL 521 fs/read_write.c iov = kmalloc(nr_segs*sizeof(struct iovec), GFP_KERNEL);
GFP_KERNEL 512 fs/reiserfs/super.c kmem_cache_alloc(reiserfs_inode_cachep, GFP_KERNEL);
GFP_KERNEL 1019 fs/reiserfs/super.c kmalloc(strlen(arg) + 1, GFP_KERNEL);
GFP_KERNEL 1169 fs/reiserfs/super.c char *new_opts = kstrdup(arg, GFP_KERNEL);
GFP_KERNEL 1612 fs/reiserfs/super.c sbi = kzalloc(sizeof(struct reiserfs_sb_info), GFP_KERNEL);
GFP_KERNEL 578 fs/romfs/inode.c ei = kmem_cache_alloc(romfs_inode_cachep, GFP_KERNEL);
GFP_KERNEL 104 fs/select.c new_table = (struct poll_table_page *) __get_free_page(GFP_KERNEL);
GFP_KERNEL 335 fs/select.c bits = kmalloc(6 * size, GFP_KERNEL);
GFP_KERNEL 681 fs/select.c walk = walk->next = kmalloc(size, GFP_KERNEL);
GFP_KERNEL 35 fs/seq_file.c p = kmalloc(sizeof(*p), GFP_KERNEL);
GFP_KERNEL 90 fs/seq_file.c m->buf = kmalloc(m->size = PAGE_SIZE, GFP_KERNEL);
GFP_KERNEL 131 fs/seq_file.c m->buf = kmalloc(m->size <<= 1, GFP_KERNEL);
GFP_KERNEL 203 fs/seq_file.c m->buf = kmalloc(m->size = PAGE_SIZE, GFP_KERNEL);
GFP_KERNEL 242 fs/seq_file.c m->buf = kmalloc(m->size <<= 1, GFP_KERNEL);
GFP_KERNEL 485 fs/seq_file.c struct seq_operations *op = kmalloc(sizeof(*op), GFP_KERNEL);
GFP_KERNEL 529 fs/seq_file.c private = kzalloc(psize, GFP_KERNEL);
GFP_KERNEL 228 fs/signalfd.c ctx = kmalloc(sizeof(*ctx), GFP_KERNEL);
GFP_KERNEL 59 fs/smbfs/inode.c ei = (struct smb_inode_info *)kmem_cache_alloc(smb_inode_cachep, GFP_KERNEL);
GFP_KERNEL 526 fs/smbfs/inode.c server = kzalloc(sizeof(struct smb_sb_info), GFP_KERNEL);
GFP_KERNEL 549 fs/smbfs/inode.c sizeof(struct smb_mount_data_kernel), GFP_KERNEL);
GFP_KERNEL 1965 fs/smbfs/proc.c if (! (name_buf = kmalloc(SMB_MAXNAMELEN, GFP_KERNEL)))
GFP_KERNEL 2333 fs/smbfs/proc.c if (! (name_buf = kmalloc(SMB_MAXNAMELEN+2, GFP_KERNEL)))
GFP_KERNEL 64 fs/smbfs/request.c req = kmem_cache_zalloc(req_cachep, GFP_KERNEL);
GFP_KERNEL 61 fs/splice.c if (PagePrivate(page) && !try_to_release_page(page, GFP_KERNEL))
GFP_KERNEL 951 fs/super.c mnt->mnt_sb->s_subtype = kstrdup(subtype, GFP_KERNEL);
GFP_KERNEL 191 fs/sysfs/bin.c bb = kzalloc(sizeof(*bb), GFP_KERNEL);
GFP_KERNEL 195 fs/sysfs/bin.c bb->buffer = kmalloc(PAGE_SIZE, GFP_KERNEL);
GFP_KERNEL 258 fs/sysfs/dir.c if (ida_pre_get(&sysfs_ino_ida, GFP_KERNEL))
GFP_KERNEL 315 fs/sysfs/dir.c name = dup_name = kstrdup(name, GFP_KERNEL);
GFP_KERNEL 320 fs/sysfs/dir.c sd = kmem_cache_zalloc(sysfs_dir_cachep, GFP_KERNEL);
GFP_KERNEL 834 fs/sysfs/dir.c new_name = dup_name = kstrdup(new_name, GFP_KERNEL);
GFP_KERNEL 75 fs/sysfs/file.c buffer->page = (char *) get_zeroed_page(GFP_KERNEL);
GFP_KERNEL 163 fs/sysfs/file.c buffer->page = (char *)get_zeroed_page(GFP_KERNEL);
GFP_KERNEL 284 fs/sysfs/file.c new_od = kmalloc(sizeof(*new_od), GFP_KERNEL);
GFP_KERNEL 367 fs/sysfs/file.c buffer = kzalloc(sizeof(struct sysfs_buffer), GFP_KERNEL);
GFP_KERNEL 689 fs/sysfs/file.c ss = kmalloc(sizeof(*ss), GFP_KERNEL);
GFP_KERNEL 70 fs/sysfs/inode.c sd_iattr = kzalloc(sizeof(struct iattr), GFP_KERNEL);
GFP_KERNEL 194 fs/sysfs/symlink.c unsigned long page = get_zeroed_page(GFP_KERNEL);
GFP_KERNEL 318 fs/sysv/inode.c si = kmem_cache_alloc(sysv_inode_cachep, GFP_KERNEL);
GFP_KERNEL 367 fs/sysv/super.c sbi = kzalloc(sizeof(struct sysv_sb_info), GFP_KERNEL);
GFP_KERNEL 450 fs/sysv/super.c sbi = kzalloc(sizeof(struct sysv_sb_info), GFP_KERNEL);
GFP_KERNEL 197 fs/timerfd.c ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
GFP_KERNEL 817 fs/ubifs/io.c wbuf->buf = kmalloc(c->min_io_size, GFP_KERNEL);
GFP_KERNEL 822 fs/ubifs/io.c wbuf->inodes = kmalloc(size, GFP_KERNEL);
GFP_KERNEL 602 fs/ubifs/lpt.c lsave = kmalloc(sizeof(int) * c->lsave_cnt, GFP_KERNEL);
GFP_KERNEL 603 fs/ubifs/lpt.c pnode = kzalloc(sizeof(struct ubifs_pnode), GFP_KERNEL);
GFP_KERNEL 604 fs/ubifs/lpt.c nnode = kzalloc(sizeof(struct ubifs_nnode), GFP_KERNEL);
GFP_KERNEL 1603 fs/ubifs/lpt.c c->lpt_nod_buf = kmalloc(i, GFP_KERNEL);
GFP_KERNEL 1609 fs/ubifs/lpt.c GFP_KERNEL);
GFP_KERNEL 1616 fs/ubifs/lpt.c c->dirty_idx.arr = kmalloc(sizeof(void *) * LPT_HEAP_SZ, GFP_KERNEL);
GFP_KERNEL 253 fs/ubifs/master.c c->mst_node = kzalloc(c->mst_node_alsz, GFP_KERNEL);
GFP_KERNEL 514 fs/ubifs/orphan.c orphan = kzalloc(sizeof(struct ubifs_orphan), GFP_KERNEL);
GFP_KERNEL 277 fs/ubifs/recovery.c c->rcvrd_mst_node = kmalloc(sz, GFP_KERNEL);
GFP_KERNEL 756 fs/ubifs/recovery.c cs_node = kmalloc(UBIFS_CS_NODE_SZ, GFP_KERNEL);
GFP_KERNEL 1240 fs/ubifs/recovery.c e = kzalloc(sizeof(struct size_entry), GFP_KERNEL);
GFP_KERNEL 357 fs/ubifs/replay.c r = kzalloc(sizeof(struct replay_entry), GFP_KERNEL);
GFP_KERNEL 424 fs/ubifs/replay.c r = kzalloc(sizeof(struct replay_entry), GFP_KERNEL);
GFP_KERNEL 427 fs/ubifs/replay.c nbuf = kmalloc(nlen + 1, GFP_KERNEL);
GFP_KERNEL 682 fs/ubifs/replay.c r = kzalloc(sizeof(struct replay_entry), GFP_KERNEL);
GFP_KERNEL 758 fs/ubifs/replay.c bud = kmalloc(sizeof(struct ubifs_bud), GFP_KERNEL);
GFP_KERNEL 762 fs/ubifs/replay.c b = kmalloc(sizeof(struct bud_entry), GFP_KERNEL);
GFP_KERNEL 158 fs/ubifs/sb.c sup = kzalloc(tmp, GFP_KERNEL);
GFP_KERNEL 201 fs/ubifs/sb.c mst = kzalloc(c->mst_node_alsz, GFP_KERNEL);
GFP_KERNEL 265 fs/ubifs/sb.c idx = kzalloc(ALIGN(tmp, c->min_io_size), GFP_KERNEL);
GFP_KERNEL 290 fs/ubifs/sb.c ino = kzalloc(tmp, GFP_KERNEL);
GFP_KERNEL 327 fs/ubifs/sb.c cs = kzalloc(tmp, GFP_KERNEL);
GFP_KERNEL 711 fs/ubifs/super.c GFP_KERNEL);
GFP_KERNEL 985 fs/ubifs/super.c c->bottom_up_buf = kmalloc(BOTTOM_UP_HEIGHT * sizeof(int), GFP_KERNEL);
GFP_KERNEL 1644 fs/ubifs/super.c c = kzalloc(sizeof(struct ubifs_info), GFP_KERNEL);
GFP_KERNEL 85 fs/udf/ialloc.c GFP_KERNEL);
GFP_KERNEL 90 fs/udf/ialloc.c GFP_KERNEL);
GFP_KERNEL 1337 fs/udf/inode.c iinfo->i_ext.i_data = kmalloc(size, GFP_KERNEL);
GFP_KERNEL 133 fs/udf/super.c ei = kmem_cache_alloc(udf_inode_cachep, GFP_KERNEL);
GFP_KERNEL 241 fs/udf/super.c GFP_KERNEL);
GFP_KERNEL 1073 fs/udf/super.c bitmap = kmalloc(size, GFP_KERNEL);
GFP_KERNEL 1859 fs/udf/super.c sbi = kzalloc(sizeof(struct udf_sb_info), GFP_KERNEL);
GFP_KERNEL 473 fs/ufs/super.c base = space = kmalloc(size, GFP_KERNEL);
GFP_KERNEL 498 fs/ufs/super.c if (!(sbi->s_ucg = kmalloc (sizeof(struct buffer_head *) * uspi->s_ncg, GFP_KERNEL)))
GFP_KERNEL 516 fs/ufs/super.c if (!(sbi->s_ucpi[i] = kmalloc (sizeof(struct ufs_cg_private_info), GFP_KERNEL)))
GFP_KERNEL 647 fs/ufs/super.c sbi = kzalloc(sizeof(struct ufs_sb_info), GFP_KERNEL);
GFP_KERNEL 681 fs/ufs/super.c uspi = kzalloc(sizeof(struct ufs_sb_private_info), GFP_KERNEL);
GFP_KERNEL 1293 fs/ufs/super.c ei = (struct ufs_inode_info *)kmem_cache_alloc(ufs_inode_cachep, GFP_KERNEL);
GFP_KERNEL 30 fs/ufs/util.c kmalloc (sizeof (struct ufs_buffer_head), GFP_KERNEL);
GFP_KERNEL 240 fs/xattr.c kvalue = kmalloc(size, GFP_KERNEL);
GFP_KERNEL 334 fs/xattr.c kvalue = kzalloc(size, GFP_KERNEL);
GFP_KERNEL 409 fs/xattr.c klist = kmalloc(size, GFP_KERNEL);
GFP_KERNEL 39 fs/xattr_acl.c acl = posix_acl_alloc(count, GFP_KERNEL);
GFP_KERNEL 50 fs/xfs/linux-2.6/kmem.h lflags = GFP_KERNEL | __GFP_NOWARN;
GFP_KERNEL 89 fs/xfs/linux-2.6/xfs_buf.c ((flags) & XBF_DONT_BLOCK) ? GFP_NOFS : GFP_KERNEL) | __GFP_NOWARN)
GFP_KERNEL 781 fs/xfs/linux-2.6/xfs_buf.c bp->b_pages[i] = alloc_page(GFP_KERNEL);
GFP_KERNEL 309 fs/xfs/linux-2.6/xfs_file.c buf.dirent = kmalloc(buf.len, GFP_KERNEL);
GFP_KERNEL 398 fs/xfs/linux-2.6/xfs_ioctl.c link = kmalloc(MAXPATHLEN+1, GFP_KERNEL);
GFP_KERNEL 483 fs/xfs/linux-2.6/xfs_ioctl.c kbuf = kmalloc(al_hreq.buflen, GFP_KERNEL);
GFP_KERNEL 517 fs/xfs/linux-2.6/xfs_ioctl.c kbuf = kmalloc(*len, GFP_KERNEL);
GFP_KERNEL 549 fs/xfs/linux-2.6/xfs_ioctl.c kbuf = kmalloc(len, GFP_KERNEL);
GFP_KERNEL 603 fs/xfs/linux-2.6/xfs_ioctl.c ops = kmalloc(size, GFP_KERNEL);
GFP_KERNEL 611 fs/xfs/linux-2.6/xfs_ioctl.c attr_name = kmalloc(MAXNAMELEN, GFP_KERNEL);
GFP_KERNEL 479 fs/xfs/linux-2.6/xfs_iops.c link = kmalloc(MAXPATHLEN+1, GFP_KERNEL);
GFP_KERNEL 84 fs/xfs/linux-2.6/xfs_super.c args = kzalloc(sizeof(struct xfs_mount_args), GFP_KERNEL);
GFP_KERNEL 1472 fs/xfs/linux-2.6/xfs_super.c mp->m_fsname = kstrdup(ap->fsname, GFP_KERNEL);
GFP_KERNEL 1477 fs/xfs/linux-2.6/xfs_super.c mp->m_rtname = kstrdup(ap->rtname, GFP_KERNEL);
GFP_KERNEL 1484 fs/xfs/linux-2.6/xfs_super.c mp->m_logname = kstrdup(ap->logname, GFP_KERNEL);
GFP_KERNEL 1677 fs/xfs/linux-2.6/xfs_super.c mp = kzalloc(sizeof(struct xfs_mount), GFP_KERNEL);
GFP_KERNEL 241 fs/xfs/xfs_iget.c if (radix_tree_preload(GFP_KERNEL)) {
GFP_KERNEL 455 fs/xfs/xfs_mru_cache.c if (radix_tree_preload(GFP_KERNEL)) {
GFP_KERNEL 123 include/acpi/platform/aclinux.h return kmalloc(size, irqs_disabled()? GFP_ATOMIC : GFP_KERNEL);
GFP_KERNEL 127 include/acpi/platform/aclinux.h return kzalloc(size, irqs_disabled()? GFP_ATOMIC : GFP_KERNEL);
GFP_KERNEL 133 include/acpi/platform/aclinux.h irqs_disabled()? GFP_ATOMIC : GFP_KERNEL);
GFP_KERNEL 17 include/asm-cris/pgalloc.h return (pgd_t *)get_zeroed_page(GFP_KERNEL);
GFP_KERNEL 27 include/asm-cris/pgalloc.h pte_t *pte = (pte_t *)__get_free_page(GFP_KERNEL|__GFP_REPEAT|__GFP_ZERO);
GFP_KERNEL 34 include/asm-cris/pgalloc.h pte = alloc_pages(GFP_KERNEL|__GFP_REPEAT|__GFP_ZERO, 0);
GFP_KERNEL 73 include/asm-cris/thread_info.h #define alloc_thread_info(tsk) ((struct thread_info *) __get_free_pages(GFP_KERNEL,1))
GFP_KERNEL 11 include/asm-frv/page.h #define get_user_page(vaddr) __get_free_page(GFP_KERNEL)
GFP_KERNEL 93 include/asm-frv/thread_info.h ret = kzalloc(THREAD_SIZE, GFP_KERNEL); \
GFP_KERNEL 98 include/asm-frv/thread_info.h #define alloc_thread_info(tsk) kmalloc(THREAD_SIZE, GFP_KERNEL)
GFP_KERNEL 23 include/asm-m32r/pgalloc.h pgd_t *pgd = (pgd_t *)__get_free_page(GFP_KERNEL|__GFP_ZERO);
GFP_KERNEL 36 include/asm-m32r/pgalloc.h pte_t *pte = (pte_t *)__get_free_page(GFP_KERNEL|__GFP_ZERO);
GFP_KERNEL 44 include/asm-m32r/pgalloc.h struct page *pte = alloc_page(GFP_KERNEL|__GFP_ZERO);
GFP_KERNEL 105 include/asm-m32r/thread_info.h ret = kzalloc(THREAD_SIZE, GFP_KERNEL); \
GFP_KERNEL 110 include/asm-m32r/thread_info.h #define alloc_thread_info(tsk) kmalloc(THREAD_SIZE, GFP_KERNEL)
GFP_KERNEL 14 include/asm-m68k/motorola_pgalloc.h pte = (pte_t *)__get_free_page(GFP_KERNEL|__GFP_REPEAT|__GFP_ZERO);
GFP_KERNEL 32 include/asm-m68k/motorola_pgalloc.h struct page *page = alloc_pages(GFP_KERNEL|__GFP_REPEAT|__GFP_ZERO, 0);
GFP_KERNEL 29 include/asm-m68k/page.h #define get_user_page(vaddr) __get_free_page(GFP_KERNEL)
GFP_KERNEL 44 include/asm-m68k/sun3_pgalloc.h unsigned long page = __get_free_page(GFP_KERNEL|__GFP_REPEAT);
GFP_KERNEL 56 include/asm-m68k/sun3_pgalloc.h struct page *page = alloc_pages(GFP_KERNEL|__GFP_REPEAT, 0);
GFP_KERNEL 94 include/asm-m68k/sun3_pgalloc.h new_pgd = (pgd_t *)get_zeroed_page(GFP_KERNEL);
GFP_KERNEL 119 include/asm-mn10300/thread_info.h #define alloc_thread_info(tsk) kzalloc(THREAD_SIZE, GFP_KERNEL)
GFP_KERNEL 121 include/asm-mn10300/thread_info.h #define alloc_thread_info(tsk) kmalloc(THREAD_SIZE, GFP_KERNEL)
GFP_KERNEL 20 include/asm-parisc/agp.h ((char *)__get_free_pages(GFP_KERNEL, (order)))
GFP_KERNEL 168 include/asm-parisc/floppy.h return __get_dma_pages(GFP_KERNEL, get_order(size));
GFP_KERNEL 23 include/asm-parisc/pgalloc.h pgd_t *pgd = (pgd_t *)__get_free_pages(GFP_KERNEL,
GFP_KERNEL 66 include/asm-parisc/pgalloc.h pmd_t *pmd = (pmd_t *)__get_free_pages(GFP_KERNEL|__GFP_REPEAT,
GFP_KERNEL 123 include/asm-parisc/pgalloc.h struct page *page = alloc_page(GFP_KERNEL|__GFP_REPEAT|__GFP_ZERO);
GFP_KERNEL 132 include/asm-parisc/pgalloc.h pte_t *pte = (pte_t *)__get_free_page(GFP_KERNEL|__GFP_REPEAT|__GFP_ZERO);
GFP_KERNEL 31 include/asm-x86/agp.h ((char *)__get_free_pages(GFP_KERNEL, (order)))
GFP_KERNEL 156 include/asm-x86/floppy.h return __get_dma_pages(GFP_KERNEL|__GFP_NORETRY, get_order(size));
GFP_KERNEL 71 include/asm-x86/pgalloc.h return (pmd_t *)get_zeroed_page(GFP_KERNEL|__GFP_REPEAT);
GFP_KERNEL 101 include/asm-x86/pgalloc.h return (pud_t *)get_zeroed_page(GFP_KERNEL|__GFP_REPEAT);
GFP_KERNEL 152 include/asm-x86/thread_info.h #define THREAD_FLAGS (GFP_KERNEL | __GFP_ZERO)
GFP_KERNEL 154 include/asm-x86/thread_info.h #define THREAD_FLAGS GFP_KERNEL
GFP_KERNEL 32 include/asm-xtensa/pgalloc.h return (pgd_t*) __get_free_pages(GFP_KERNEL | __GFP_ZERO, PGD_ORDER);
GFP_KERNEL 47 include/asm-xtensa/pgalloc.h return kmem_cache_alloc(pgtable_cache, GFP_KERNEL|__GFP_REPEAT);
GFP_KERNEL 1131 include/drm/drmP.h return kmalloc(size, GFP_KERNEL);
GFP_KERNEL 1143 include/drm/drmP.h return kcalloc(nmemb, size, GFP_KERNEL);
GFP_KERNEL 154 include/drm/drm_memory_debug.h if (!(pt = kmalloc(size, GFP_KERNEL))) {
GFP_KERNEL 898 include/linux/blkdev.h return blkdev_issue_discard(sb->s_bdev, block, nr_blocks, GFP_KERNEL);
GFP_KERNEL 60 include/linux/coda_linux.h ptr = kmalloc((unsigned long) size, GFP_KERNEL); \
GFP_KERNEL 331 include/linux/cpumask.h #define CPUMASK_ALLOC(m) struct m *m = kmalloc(sizeof(*m), GFP_KERNEL)
GFP_KERNEL 1702 include/linux/fs.h #define __getname() kmem_cache_alloc(names_cachep, GFP_KERNEL)
GFP_KERNEL 2212 include/linux/fs.h return (char *)get_zeroed_page(GFP_KERNEL);
GFP_KERNEL 273 include/linux/fsnotify.h return kstrdup(name, GFP_KERNEL);
GFP_KERNEL 107 include/linux/gameport.h struct gameport *gameport = kzalloc(sizeof(struct gameport), GFP_KERNEL);
GFP_KERNEL 937 include/linux/i2o.h pool->name = kmalloc(strlen(name) + 1, GFP_KERNEL);
GFP_KERNEL 73 include/linux/kmod.h gfp_t gfp_mask = (wait == UMH_NO_WAIT) ? GFP_ATOMIC : GFP_KERNEL;
GFP_KERNEL 86 include/linux/kmod.h gfp_t gfp_mask = (wait == UMH_NO_WAIT) ? GFP_ATOMIC : GFP_KERNEL;
GFP_KERNEL 118 include/linux/memory_hotplug.h kzalloc(sizeof(pg_data_t), GFP_KERNEL); \
GFP_KERNEL 110 include/linux/percpu.h #define __alloc_percpu(size) percpu_alloc_mask((size), GFP_KERNEL, \
GFP_KERNEL 46 include/linux/rmap.h return kmem_cache_alloc(anon_vma_cachep, GFP_KERNEL);
GFP_KERNEL 174 include/net/inet_hashtables.h GFP_KERNEL);
GFP_KERNEL 1236 include/net/sock.h return in_atomic() ? GFP_ATOMIC : GFP_KERNEL;
GFP_KERNEL 1521 include/net/xfrm.h return kmemdup(orig, xfrm_alg_len(orig), GFP_KERNEL);
GFP_KERNEL 57 init/do_mounts_rd.c buf = kmalloc(size, GFP_KERNEL);
GFP_KERNEL 206 init/do_mounts_rd.c buf = kmalloc(BLOCK_SIZE, GFP_KERNEL);
GFP_KERNEL 378 init/do_mounts_rd.c inbuf = kmalloc(INBUFSIZ, GFP_KERNEL);
GFP_KERNEL 383 init/do_mounts_rd.c window = kmalloc(WSIZE, GFP_KERNEL);
GFP_KERNEL 50 init/initramfs.c q = kmalloc(sizeof(struct hash), GFP_KERNEL);
GFP_KERNEL 430 init/initramfs.c header_buf = kmalloc(110, GFP_KERNEL);
GFP_KERNEL 431 init/initramfs.c symlink_buf = kmalloc(PATH_MAX + N_ALIGN(PATH_MAX) + 1, GFP_KERNEL);
GFP_KERNEL 432 init/initramfs.c name_buf = kmalloc(N_ALIGN(PATH_MAX), GFP_KERNEL);
GFP_KERNEL 433 init/initramfs.c window = kmalloc(WSIZE, GFP_KERNEL);
GFP_KERNEL 157 ipc/mqueue.c info->messages = kmalloc(mq_msg_tblsz, GFP_KERNEL);
GFP_KERNEL 221 ipc/mqueue.c ei = kmem_cache_alloc(mqueue_inode_cachep, GFP_KERNEL);
GFP_KERNEL 1018 ipc/mqueue.c nc = alloc_skb(NOTIFY_COOKIE_LEN, GFP_KERNEL);
GFP_KERNEL 39 ipc/msgutil.c msg = kmalloc(sizeof(*msg) + alen, GFP_KERNEL);
GFP_KERNEL 60 ipc/msgutil.c GFP_KERNEL);
GFP_KERNEL 19 ipc/namespace.c ns = kmalloc(sizeof(struct ipc_namespace), GFP_KERNEL);
GFP_KERNEL 944 ipc/sem.c undo_list = kzalloc(sizeof(*undo_list), GFP_KERNEL);
GFP_KERNEL 1009 ipc/sem.c new = kzalloc(sizeof(struct sem_undo) + sizeof(short)*nsems, GFP_KERNEL);
GFP_KERNEL 1071 ipc/sem.c sops = kmalloc(sizeof(*sops)*nsops,GFP_KERNEL);
GFP_KERNEL 879 ipc/shm.c sfd = kzalloc(sizeof(*sfd), GFP_KERNEL);
GFP_KERNEL 160 ipc/util.c iface = kmalloc(sizeof(*iface), GFP_KERNEL);
GFP_KERNEL 305 ipc/util.c err = idr_pre_get(&ids->ipcs_idr, GFP_KERNEL);
GFP_KERNEL 371 ipc/util.c err = idr_pre_get(&ids->ipcs_idr, GFP_KERNEL);
GFP_KERNEL 450 ipc/util.c out = kmalloc(size, GFP_KERNEL);
GFP_KERNEL 540 ipc/util.c out = kmalloc(HDRLEN_KMALLOC + size, GFP_KERNEL);
GFP_KERNEL 964 ipc/util.c iter = kmalloc(sizeof(*iter), GFP_KERNEL);
GFP_KERNEL 239 kernel/acct.c acct = kzalloc(sizeof(struct bsd_acct_struct), GFP_KERNEL);
GFP_KERNEL 268 kernel/audit.c ab = audit_log_start(NULL, GFP_KERNEL, AUDIT_CONFIG_CHANGE);
GFP_KERNEL 520 kernel/audit.c skb = alloc_skb(len, GFP_KERNEL);
GFP_KERNEL 568 kernel/audit.c GFP_KERNEL);
GFP_KERNEL 639 kernel/audit.c *ab = audit_log_start(NULL, GFP_KERNEL, msg_type);
GFP_KERNEL 862 kernel/audit.c sig_data = kmalloc(sizeof(*sig_data) + len, GFP_KERNEL);
GFP_KERNEL 983 kernel/audit.c audit_log(NULL, GFP_KERNEL, AUDIT_KERNEL, "initialized");
GFP_KERNEL 73 kernel/audit_tree.c tree = kmalloc(sizeof(struct audit_tree) + strlen(s) + 1, GFP_KERNEL);
GFP_KERNEL 117 kernel/audit_tree.c chunk = kzalloc(size, GFP_KERNEL);
GFP_KERNEL 409 kernel/audit_tree.c ab = audit_log_start(NULL, GFP_KERNEL, AUDIT_CONFIG_CHANGE);
GFP_KERNEL 157 kernel/auditfilter.c parent = kzalloc(sizeof(*parent), GFP_KERNEL);
GFP_KERNEL 182 kernel/auditfilter.c watch = kzalloc(sizeof(*watch), GFP_KERNEL);
GFP_KERNEL 201 kernel/auditfilter.c entry = kzalloc(sizeof(*entry), GFP_KERNEL);
GFP_KERNEL 205 kernel/auditfilter.c fields = kzalloc(sizeof(*fields) * field_count, GFP_KERNEL);
GFP_KERNEL 230 kernel/auditfilter.c str = kmalloc(len + 1, GFP_KERNEL);
GFP_KERNEL 283 kernel/auditfilter.c __u32 *p = kzalloc(AUDIT_BITMASK_SIZE * sizeof(__u32), GFP_KERNEL);
GFP_KERNEL 704 kernel/auditfilter.c rule = kzalloc(sizeof(*rule), GFP_KERNEL);
GFP_KERNEL 734 kernel/auditfilter.c data = kmalloc(sizeof(*data) + krule->buflen, GFP_KERNEL);
GFP_KERNEL 849 kernel/auditfilter.c path = kstrdup(old->path, GFP_KERNEL);
GFP_KERNEL 877 kernel/auditfilter.c lsm_str = kstrdup(sf->lsm_str, GFP_KERNEL);
GFP_KERNEL 954 kernel/auditfilter.c fk = kstrdup(old->filterkey, GFP_KERNEL);
GFP_KERNEL 1023 kernel/auditfilter.c ab = audit_log_start(NULL, GFP_KERNEL,
GFP_KERNEL 1062 kernel/auditfilter.c ab = audit_log_start(NULL, GFP_KERNEL,
GFP_KERNEL 1140 kernel/auditfilter.c ndparent = kmalloc(sizeof(*ndparent), GFP_KERNEL);
GFP_KERNEL 1144 kernel/auditfilter.c ndwatch = kmalloc(sizeof(*ndwatch), GFP_KERNEL);
GFP_KERNEL 1521 kernel/auditfilter.c ab = audit_log_start(NULL, GFP_KERNEL, AUDIT_CONFIG_CHANGE);
GFP_KERNEL 1573 kernel/auditfilter.c dest = kmalloc(sizeof(struct audit_netlink_list), GFP_KERNEL);
GFP_KERNEL 339 kernel/auditsc.c ctx->trees = kzalloc(sizeof(struct audit_tree_refs), GFP_KERNEL);
GFP_KERNEL 838 kernel/auditsc.c if (!(context = kmalloc(sizeof(*context), GFP_KERNEL)))
GFP_KERNEL 968 kernel/auditsc.c ab = audit_log_start(context, GFP_KERNEL, AUDIT_OBJ_PID);
GFP_KERNEL 1084 kernel/auditsc.c *ab = audit_log_start(context, GFP_KERNEL, AUDIT_EXECVE);
GFP_KERNEL 1158 kernel/auditsc.c buf = kmalloc(MAX_EXECVE_AUDIT_LEN + 1, GFP_KERNEL);
GFP_KERNEL 1195 kernel/auditsc.c ab = audit_log_start(context, GFP_KERNEL, AUDIT_SYSCALL);
GFP_KERNEL 1244 kernel/auditsc.c ab = audit_log_start(context, GFP_KERNEL, aux->type);
GFP_KERNEL 1362 kernel/auditsc.c ab = audit_log_start(context, GFP_KERNEL, AUDIT_CWD);
GFP_KERNEL 1371 kernel/auditsc.c ab = audit_log_start(context, GFP_KERNEL, AUDIT_PATH);
GFP_KERNEL 1428 kernel/auditsc.c ab = audit_log_start(context, GFP_KERNEL, AUDIT_EOE);
GFP_KERNEL 1976 kernel/auditsc.c ab = audit_log_start(NULL, GFP_KERNEL, AUDIT_LOGIN);
GFP_KERNEL 2258 kernel/auditsc.c ax = kmalloc(sizeof(*ax), GFP_KERNEL);
GFP_KERNEL 2287 kernel/auditsc.c ax = kmalloc(sizeof(*ax) + nargs * sizeof(unsigned long), GFP_KERNEL);
GFP_KERNEL 2316 kernel/auditsc.c ax = kmalloc(sizeof(*ax), GFP_KERNEL);
GFP_KERNEL 2345 kernel/auditsc.c ax = kmalloc(sizeof(*ax) + len, GFP_KERNEL);
GFP_KERNEL 2452 kernel/auditsc.c ab = audit_log_start(NULL, GFP_KERNEL, AUDIT_ANOM_ABEND);
GFP_KERNEL 380 kernel/cgroup.c link = kmalloc(sizeof(*link), GFP_KERNEL);
GFP_KERNEL 420 kernel/cgroup.c res = kmalloc(sizeof(*res), GFP_KERNEL);
GFP_KERNEL 801 kernel/cgroup.c opts->release_agent = kzalloc(PATH_MAX, GFP_KERNEL);
GFP_KERNEL 963 kernel/cgroup.c root = kzalloc(sizeof(*root), GFP_KERNEL);
GFP_KERNEL 1417 kernel/cgroup.c buffer = kmalloc(nbytes + 1, GFP_KERNEL);
GFP_KERNEL 1911 kernel/cgroup.c retval = heap_init(heap, PAGE_SIZE, GFP_KERNEL, &started_after);
GFP_KERNEL 2123 kernel/cgroup.c ctr = kmalloc(sizeof(*ctr), GFP_KERNEL);
GFP_KERNEL 2135 kernel/cgroup.c pidarray = kmalloc(npids * sizeof(pid_t), GFP_KERNEL);
GFP_KERNEL 2144 kernel/cgroup.c ctr->buf = kmalloc(ctr->bufsz, GFP_KERNEL);
GFP_KERNEL 2290 kernel/cgroup.c cgrp = kzalloc(sizeof(*cgrp), GFP_KERNEL);
GFP_KERNEL 2598 kernel/cgroup.c buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
GFP_KERNEL 3064 kernel/cgroup.c pathbuf = kmalloc(PAGE_SIZE, GFP_KERNEL);
GFP_KERNEL 3069 kernel/cgroup.c agentbuf = kstrdup(cgrp->root->release_agent_path, GFP_KERNEL);
GFP_KERNEL 21 kernel/cgroup_debug.c struct cgroup_subsys_state *css = kzalloc(sizeof(*css), GFP_KERNEL);
GFP_KERNEL 597 kernel/cpuset.c doms = kmalloc(sizeof(cpumask_t), GFP_KERNEL);
GFP_KERNEL 601 kernel/cpuset.c dattr = kmalloc(sizeof(struct sched_domain_attr), GFP_KERNEL);
GFP_KERNEL 612 kernel/cpuset.c csa = kmalloc(number_of_cpusets * sizeof(cp), GFP_KERNEL);
GFP_KERNEL 676 kernel/cpuset.c doms = kmalloc(ndoms * sizeof(cpumask_t), GFP_KERNEL);
GFP_KERNEL 686 kernel/cpuset.c dattr = kmalloc(ndoms * sizeof(struct sched_domain_attr), GFP_KERNEL);
GFP_KERNEL 909 kernel/cpuset.c retval = heap_init(&heap, PAGE_SIZE, GFP_KERNEL, NULL);
GFP_KERNEL 1017 kernel/cpuset.c mmarray = kmalloc(ntasks * sizeof(*mmarray), GFP_KERNEL);
GFP_KERNEL 1740 kernel/cpuset.c cs = kmalloc(sizeof(*cs), GFP_KERNEL);
GFP_KERNEL 2395 kernel/cpuset.c buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
GFP_KERNEL 40 kernel/delayacct.c tsk->delays = kmem_cache_zalloc(delayacct_cache, GFP_KERNEL);
GFP_KERNEL 36 kernel/dma-coherent.c dev->dma_mem = kzalloc(sizeof(struct dma_coherent_mem), GFP_KERNEL);
GFP_KERNEL 39 kernel/dma-coherent.c dev->dma_mem->bitmap = kzalloc(bitmap_size, GFP_KERNEL);
GFP_KERNEL 93 kernel/fork.c # define alloc_task_struct() kmem_cache_alloc(task_struct_cachep, GFP_KERNEL)
GFP_KERNEL 102 kernel/fork.c gfp_t mask = GFP_KERNEL | __GFP_ZERO;
GFP_KERNEL 104 kernel/fork.c gfp_t mask = GFP_KERNEL;
GFP_KERNEL 300 kernel/fork.c tmp = kmem_cache_alloc(vm_area_cachep, GFP_KERNEL);
GFP_KERNEL 392 kernel/fork.c #define allocate_mm() (kmem_cache_alloc(mm_cachep, GFP_KERNEL))
GFP_KERNEL 652 kernel/fork.c struct fs_struct *fs = kmem_cache_alloc(fs_cachep, GFP_KERNEL);
GFP_KERNEL 729 kernel/fork.c tsk->io_context = alloc_io_context(GFP_KERNEL, -1);
GFP_KERNEL 747 kernel/fork.c sig = kmem_cache_alloc(sighand_cachep, GFP_KERNEL);
GFP_KERNEL 772 kernel/fork.c sig = kmem_cache_alloc(signal_cachep, GFP_KERNEL);
GFP_KERNEL 379 kernel/futex.c pi_state = kzalloc(sizeof(*pi_state), GFP_KERNEL);
GFP_KERNEL 53 kernel/irq/devres.c GFP_KERNEL);
GFP_KERNEL 453 kernel/kallsyms.c iter = kmalloc(sizeof(*iter), GFP_KERNEL);
GFP_KERNEL 127 kernel/kexec.c image = kzalloc(sizeof(*image), GFP_KERNEL);
GFP_KERNEL 424 kernel/kexec.c pages = kimage_alloc_pages(GFP_KERNEL, order);
GFP_KERNEL 551 kernel/kexec.c page = kimage_alloc_page(image, GFP_KERNEL, KIMAGE_NO_DEST);
GFP_KERNEL 498 kernel/kmod.c sub_info = call_usermodehelper_setup(path, argv, envp, GFP_KERNEL);
GFP_KERNEL 176 kernel/kprobes.c kip = kmalloc(sizeof(struct kprobe_insn_page), GFP_KERNEL);
GFP_KERNEL 554 kernel/kprobes.c ap = kzalloc(sizeof(struct kprobe), GFP_KERNEL);
GFP_KERNEL 948 kernel/kprobes.c rp->data_size, GFP_KERNEL);
GFP_KERNEL 269 kernel/marker.c GFP_KERNEL);
GFP_KERNEL 335 kernel/marker.c * sizeof(struct marker_probe_closure), GFP_KERNEL);
GFP_KERNEL 398 kernel/marker.c GFP_KERNEL);
GFP_KERNEL 468 kernel/marker.c GFP_KERNEL);
GFP_KERNEL 353 kernel/module.c GFP_KERNEL);
GFP_KERNEL 475 kernel/module.c GFP_KERNEL);
GFP_KERNEL 515 kernel/module.c mod->field = kstrdup(s, GFP_KERNEL); \
GFP_KERNEL 1099 kernel/module.c sect_attrs = kzalloc(size[0] + size[1], GFP_KERNEL);
GFP_KERNEL 1115 kernel/module.c GFP_KERNEL);
GFP_KERNEL 1200 kernel/module.c GFP_KERNEL);
GFP_KERNEL 1273 kernel/module.c GFP_KERNEL);
GFP_KERNEL 84 kernel/ns_cgroup.c ns_cgroup = kzalloc(sizeof(*ns_cgroup), GFP_KERNEL);
GFP_KERNEL 36 kernel/nsproxy.c ns = kmem_cache_alloc(nsproxy_cachep, GFP_KERNEL);
GFP_KERNEL 473 kernel/params.c mp = kzalloc(size[0] + size[1], GFP_KERNEL);
GFP_KERNEL 557 kernel/params.c mk = kzalloc(sizeof(struct module_kobject), GFP_KERNEL);
GFP_KERNEL 138 kernel/pid.c void *page = kzalloc(PAGE_SIZE, GFP_KERNEL);
GFP_KERNEL 250 kernel/pid.c pid = kmem_cache_alloc(ns->pid_cachep, GFP_KERNEL);
GFP_KERNEL 523 kernel/pid.c init_pid_ns.pidmap[0].page = kzalloc(PAGE_SIZE, GFP_KERNEL);
GFP_KERNEL 45 kernel/pid_namespace.c pcache = kmalloc(sizeof(struct pid_cache), GFP_KERNEL);
GFP_KERNEL 75 kernel/pid_namespace.c ns = kmem_cache_zalloc(pid_ns_cachep, GFP_KERNEL);
GFP_KERNEL 79 kernel/pid_namespace.c ns->pidmap[0].page = kzalloc(PAGE_SIZE, GFP_KERNEL);
GFP_KERNEL 215 kernel/pm_qos_params.c dep = kzalloc(sizeof(struct requirement_list), GFP_KERNEL);
GFP_KERNEL 221 kernel/pm_qos_params.c dep->name = kstrdup(name, GFP_KERNEL);
GFP_KERNEL 439 kernel/posix-timers.c tmr = kmem_cache_zalloc(posix_timers_cache, GFP_KERNEL);
GFP_KERNEL 488 kernel/posix-timers.c if (unlikely(!idr_pre_get(&posix_timers_id, GFP_KERNEL))) {
GFP_KERNEL 603 kernel/power/snapshot.c region = kmalloc(sizeof(struct nosave_region), GFP_KERNEL);
GFP_KERNEL 713 kernel/power/snapshot.c bm1 = kzalloc(sizeof(struct memory_bitmap), GFP_KERNEL);
GFP_KERNEL 717 kernel/power/snapshot.c error = memory_bm_create(bm1, GFP_KERNEL, PG_ANY);
GFP_KERNEL 721 kernel/power/snapshot.c bm2 = kzalloc(sizeof(struct memory_bitmap), GFP_KERNEL);
GFP_KERNEL 725 kernel/power/snapshot.c error = memory_bm_create(bm2, GFP_KERNEL, PG_ANY);
GFP_KERNEL 257 kernel/power/swap.c handle->cur = (struct swap_map_page *)get_zeroed_page(GFP_KERNEL);
GFP_KERNEL 641 kernel/power/swap.c swsusp_header = (struct swsusp_header*) __get_free_page(GFP_KERNEL);
GFP_KERNEL 110 kernel/power/swsusp.c ext = kzalloc(sizeof(struct swsusp_extent), GFP_KERNEL);
GFP_KERNEL 346 kernel/profile.c GFP_KERNEL | __GFP_ZERO,
GFP_KERNEL 354 kernel/profile.c GFP_KERNEL | __GFP_ZERO,
GFP_KERNEL 539 kernel/profile.c GFP_KERNEL | __GFP_ZERO | GFP_THISNODE,
GFP_KERNEL 546 kernel/profile.c GFP_KERNEL | __GFP_ZERO | GFP_THISNODE,
GFP_KERNEL 314 kernel/rcupreempt_trace.c rcupreempt_trace_buf = kmalloc(RCUPREEMPT_TRACE_BUF_SIZE, GFP_KERNEL);
GFP_KERNEL 1078 kernel/rcutorture.c GFP_KERNEL);
GFP_KERNEL 1096 kernel/rcutorture.c GFP_KERNEL);
GFP_KERNEL 81 kernel/relay.c array = kzalloc(pa_size, GFP_KERNEL);
GFP_KERNEL 146 kernel/relay.c buf->page_array[i] = alloc_page(GFP_KERNEL);
GFP_KERNEL 174 kernel/relay.c struct rchan_buf *buf = kzalloc(sizeof(struct rchan_buf), GFP_KERNEL);
GFP_KERNEL 178 kernel/relay.c buf->padding = kmalloc(chan->n_subbufs * sizeof(size_t *), GFP_KERNEL);
GFP_KERNEL 424 kernel/relay.c tmpname = kzalloc(NAME_MAX + 1, GFP_KERNEL);
GFP_KERNEL 585 kernel/relay.c chan = kzalloc(sizeof(struct rchan), GFP_KERNEL);
GFP_KERNEL 525 kernel/resource.c struct resource *res = kzalloc(sizeof(*res), GFP_KERNEL);
GFP_KERNEL 631 kernel/resource.c struct resource *res = kzalloc(sizeof(*res), GFP_KERNEL);
GFP_KERNEL 773 kernel/resource.c GFP_KERNEL);
GFP_KERNEL 726 kernel/sched.c buf = kmalloc(len + 2, GFP_KERNEL);
GFP_KERNEL 6313 kernel/sched.c kcalloc(n, sizeof(struct ctl_table), GFP_KERNEL);
GFP_KERNEL 6405 kernel/sched.c entry->procname = kstrdup(buf, GFP_KERNEL);
GFP_KERNEL 6429 kernel/sched.c entry->procname = kstrdup(buf, GFP_KERNEL);
GFP_KERNEL 6733 kernel/sched.c groupmask = kmalloc(sizeof(cpumask_t), GFP_KERNEL);
GFP_KERNEL 6856 kernel/sched.c rd = kmalloc(sizeof(*rd), GFP_KERNEL);
GFP_KERNEL 7385 kernel/sched.c GFP_KERNEL);
GFP_KERNEL 7403 kernel/sched.c allmasks = kmalloc(sizeof(*allmasks), GFP_KERNEL);
GFP_KERNEL 7567 kernel/sched.c sg = kmalloc_node(sizeof(struct sched_group), GFP_KERNEL, i);
GFP_KERNEL 7602 kernel/sched.c GFP_KERNEL, i);
GFP_KERNEL 7709 kernel/sched.c doms_cur = kmalloc(sizeof(cpumask_t), GFP_KERNEL);
GFP_KERNEL 7975 kernel/sched.c GFP_KERNEL);
GFP_KERNEL 8477 kernel/sched.c tg->cfs_rq = kzalloc(sizeof(cfs_rq) * nr_cpu_ids, GFP_KERNEL);
GFP_KERNEL 8480 kernel/sched.c tg->se = kzalloc(sizeof(se) * nr_cpu_ids, GFP_KERNEL);
GFP_KERNEL 8490 kernel/sched.c GFP_KERNEL|__GFP_ZERO, cpu_to_node(i));
GFP_KERNEL 8495 kernel/sched.c GFP_KERNEL|__GFP_ZERO, cpu_to_node(i));
GFP_KERNEL 8565 kernel/sched.c tg->rt_rq = kzalloc(sizeof(rt_rq) * nr_cpu_ids, GFP_KERNEL);
GFP_KERNEL 8568 kernel/sched.c tg->rt_se = kzalloc(sizeof(rt_se) * nr_cpu_ids, GFP_KERNEL);
GFP_KERNEL 8579 kernel/sched.c GFP_KERNEL|__GFP_ZERO, cpu_to_node(i));
GFP_KERNEL 8584 kernel/sched.c GFP_KERNEL|__GFP_ZERO, cpu_to_node(i));
GFP_KERNEL 8643 kernel/sched.c tg = kzalloc(sizeof(*tg), GFP_KERNEL);
GFP_KERNEL 9259 kernel/sched.c struct cpuacct *ca = kzalloc(sizeof(*ca), GFP_KERNEL);
GFP_KERNEL 13 kernel/sched_stats.h char *mask_str = kmalloc(mask_len, GFP_KERNEL);
GFP_KERNEL 77 kernel/sched_stats.h char *buf = kmalloc(size, GFP_KERNEL);
GFP_KERNEL 1250 kernel/signal.c if ((q = __sigqueue_alloc(current, GFP_KERNEL, 0)))
GFP_KERNEL 115 kernel/stop_machine.c threads = kcalloc(NR_CPUS, sizeof(threads[0]), GFP_KERNEL);
GFP_KERNEL 1817 kernel/sysctl.c (2 * npath * sizeof(struct ctl_table)), GFP_KERNEL);
GFP_KERNEL 88 kernel/taskstats.c skb = genlmsg_new(size, GFP_KERNEL);
GFP_KERNEL 149 kernel/taskstats.c skb_next = skb_clone(skb_cur, GFP_KERNEL);
GFP_KERNEL 305 kernel/taskstats.c s = kmalloc_node(sizeof(struct listener), GFP_KERNEL,
GFP_KERNEL 351 kernel/taskstats.c data = kmalloc(len, GFP_KERNEL);
GFP_KERNEL 496 kernel/taskstats.c stats = kmem_cache_zalloc(taskstats_cache, GFP_KERNEL);
GFP_KERNEL 1374 kernel/timer.c GFP_KERNEL | __GFP_ZERO,
GFP_KERNEL 531 kernel/trace/ftrace.c ftrace_pages->next = (void *)get_zeroed_page(GFP_KERNEL);
GFP_KERNEL 842 kernel/trace/ftrace.c ftrace_pages_start = (void *)get_zeroed_page(GFP_KERNEL);
GFP_KERNEL 865 kernel/trace/ftrace.c pg->next = (void *)get_zeroed_page(GFP_KERNEL);
GFP_KERNEL 987 kernel/trace/ftrace.c iter = kzalloc(sizeof(*iter), GFP_KERNEL);
GFP_KERNEL 1068 kernel/trace/ftrace.c iter = kzalloc(sizeof(*iter), GFP_KERNEL);
GFP_KERNEL 1878 kernel/trace/trace.c iter = kzalloc(sizeof(*iter), GFP_KERNEL);
GFP_KERNEL 2173 kernel/trace/trace.c buf = kmalloc(len + 2, GFP_KERNEL);
GFP_KERNEL 2448 kernel/trace/trace.c iter = kzalloc(sizeof(*iter), GFP_KERNEL);
GFP_KERNEL 2944 kernel/trace/trace.c array = (void *)__get_free_page(GFP_KERNEL);
GFP_KERNEL 2957 kernel/trace/trace.c array = (void *)__get_free_page(GFP_KERNEL);
GFP_KERNEL 3067 kernel/trace/trace.c array = (void *)__get_free_page(GFP_KERNEL);
GFP_KERNEL 3086 kernel/trace/trace.c array = (void *)__get_free_page(GFP_KERNEL);
GFP_KERNEL 113 kernel/trace/trace_mmiotrace.c hiter = kzalloc(sizeof(*hiter), GFP_KERNEL);
GFP_KERNEL 402 kernel/user.c new = kmem_cache_zalloc(uid_cachep, GFP_KERNEL);
GFP_KERNEL 24 kernel/user_namespace.c ns = kmalloc(sizeof(struct user_namespace), GFP_KERNEL);
GFP_KERNEL 27 kernel/utsname.c ns = kmalloc(sizeof(struct uts_namespace), GFP_KERNEL);
GFP_KERNEL 811 kernel/workqueue.c wq = kzalloc(sizeof(*wq), GFP_KERNEL);
GFP_KERNEL 28 lib/devres.c ptr = devres_alloc(devm_ioremap_release, sizeof(*ptr), GFP_KERNEL);
GFP_KERNEL 57 lib/devres.c ptr = devres_alloc(devm_ioremap_release, sizeof(*ptr), GFP_KERNEL);
GFP_KERNEL 116 lib/devres.c ptr = devres_alloc(devm_ioport_map_release, sizeof(*ptr), GFP_KERNEL);
GFP_KERNEL 189 lib/devres.c new_dr = devres_alloc(pcim_iomap_release, sizeof(*new_dr), GFP_KERNEL);
GFP_KERNEL 29 lib/genalloc.c pool = kmalloc_node(sizeof(struct gen_pool), GFP_KERNEL, nid);
GFP_KERNEL 57 lib/genalloc.c chunk = kmalloc_node(nbytes, GFP_KERNEL | __GFP_ZERO, nid);
GFP_KERNEL 269 lib/inflate.c #define malloc(a) kmalloc(a, GFP_KERNEL)
GFP_KERNEL 221 lib/kobject.c kobj->name = kvasprintf(GFP_KERNEL, fmt, vargs);
GFP_KERNEL 417 lib/kobject.c devpath = kobject_get_path(kobj, GFP_KERNEL);
GFP_KERNEL 422 lib/kobject.c devpath_string = kmalloc(strlen(devpath) + 15, GFP_KERNEL);
GFP_KERNEL 470 lib/kobject.c devpath = kobject_get_path(kobj, GFP_KERNEL);
GFP_KERNEL 475 lib/kobject.c devpath_string = kmalloc(strlen(devpath) + 15, GFP_KERNEL);
GFP_KERNEL 618 lib/kobject.c kobj = kzalloc(sizeof(*kobj), GFP_KERNEL);
GFP_KERNEL 789 lib/kobject.c kset = kzalloc(sizeof(*kset), GFP_KERNEL);
GFP_KERNEL 143 lib/kobject_uevent.c env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL);
GFP_KERNEL 148 lib/kobject_uevent.c devpath = kobject_get_path(kobj, GFP_KERNEL);
GFP_KERNEL 212 lib/kobject_uevent.c skb = alloc_skb(len + env->buflen, GFP_KERNEL);
GFP_KERNEL 228 lib/kobject_uevent.c netlink_broadcast(uevent_sock, skb, 0, 1, GFP_KERNEL);
GFP_KERNEL 129 lib/parser.c buf = kmalloc(s->to - s->from + 1, GFP_KERNEL);
GFP_KERNEL 217 lib/parser.c char *p = kmalloc(sz, GFP_KERNEL);
GFP_KERNEL 73 lib/reed_solomon/reed_solomon.c rs = kmalloc(sizeof (struct rs_control), GFP_KERNEL);
GFP_KERNEL 88 lib/reed_solomon/reed_solomon.c rs->alpha_to = kmalloc(sizeof(uint16_t) * (rs->nn + 1), GFP_KERNEL);
GFP_KERNEL 92 lib/reed_solomon/reed_solomon.c rs->index_of = kmalloc(sizeof(uint16_t) * (rs->nn + 1), GFP_KERNEL);
GFP_KERNEL 96 lib/reed_solomon/reed_solomon.c rs->genpoly = kmalloc(sizeof(uint16_t) * (rs->nroots + 1), GFP_KERNEL);
GFP_KERNEL 97 lib/sort.c a = kmalloc(1000 * sizeof(int), GFP_KERNEL);
GFP_KERNEL 229 lib/swiotlb.c io_tlb_list = (unsigned int *)__get_free_pages(GFP_KERNEL,
GFP_KERNEL 238 lib/swiotlb.c io_tlb_orig_addr = (unsigned char **)__get_free_pages(GFP_KERNEL,
GFP_KERNEL 17 lib/zlib_inflate/infutil.c strm = kmalloc(sizeof(*strm), GFP_KERNEL);
GFP_KERNEL 20 lib/zlib_inflate/infutil.c strm->workspace = kmalloc(zlib_inflate_workspacesize(), GFP_KERNEL);
GFP_KERNEL 159 mm/dmapool.c retval = kmalloc_node(sizeof(*retval), GFP_KERNEL, dev_to_node(dev));
GFP_KERNEL 477 mm/dmapool.c ptr = devres_alloc(dmam_pool_release, sizeof(*ptr), GFP_KERNEL);
GFP_KERNEL 940 mm/filemap.c if (page && add_to_page_cache_lru(page, mapping, index, GFP_KERNEL)) {
GFP_KERNEL 1172 mm/filemap.c index, GFP_KERNEL);
GFP_KERNEL 1396 mm/filemap.c ret = add_to_page_cache_lru(page, mapping, offset, GFP_KERNEL);
GFP_KERNEL 1634 mm/filemap.c err = add_to_page_cache_lru(page, mapping, index, GFP_KERNEL);
GFP_KERNEL 2205 mm/filemap.c status = add_to_page_cache_lru(page, mapping, index, GFP_KERNEL);
GFP_KERNEL 2273 mm/filemap.c src_page = alloc_page(GFP_KERNEL);
GFP_KERNEL 121 mm/hugetlb.c nrg = kmalloc(sizeof(*nrg), GFP_KERNEL);
GFP_KERNEL 267 mm/hugetlb.c struct resv_map *resv_map = kmalloc(sizeof(*resv_map), GFP_KERNEL);
GFP_KERNEL 1930 mm/hugetlb.c err = add_to_page_cache(page, mapping, idx, GFP_KERNEL);
GFP_KERNEL 771 mm/memcontrol.c ret = mem_cgroup_charge_common(newpage, NULL, GFP_KERNEL,
GFP_KERNEL 851 mm/memcontrol.c progress = try_to_free_mem_cgroup_pages(memcg, GFP_KERNEL);
GFP_KERNEL 1076 mm/memcontrol.c pn = kmalloc_node(sizeof(*pn), GFP_KERNEL, tmp);
GFP_KERNEL 1102 mm/memcontrol.c mem = kmalloc(sizeof(*mem), GFP_KERNEL);
GFP_KERNEL 1299 mm/memory.c retval = mem_cgroup_charge(page, mm, GFP_KERNEL);
GFP_KERNEL 1864 mm/memory.c if (mem_cgroup_charge(new_page, mm, GFP_KERNEL))
GFP_KERNEL 2291 mm/memory.c if (mem_cgroup_charge(page, mm, GFP_KERNEL)) {
GFP_KERNEL 2375 mm/memory.c if (mem_cgroup_charge(page, mm, GFP_KERNEL))
GFP_KERNEL 2500 mm/memory.c if (mem_cgroup_charge(page, mm, GFP_KERNEL)) {
GFP_KERNEL 3001 mm/memory.c char *buf = (char *)__get_free_page(GFP_KERNEL);
GFP_KERNEL 38 mm/memory_hotplug.c res = kzalloc(sizeof(struct resource), GFP_KERNEL);
GFP_KERNEL 215 mm/mempolicy.c policy = kmem_cache_alloc(policy_cache, GFP_KERNEL);
GFP_KERNEL 1403 mm/mempolicy.c enum zone_type highest_zoneidx = gfp_zone(GFP_KERNEL);
GFP_KERNEL 1611 mm/mempolicy.c struct mempolicy *new = kmem_cache_alloc(policy_cache, GFP_KERNEL);
GFP_KERNEL 1774 mm/mempolicy.c struct sp_node *n = kmem_cache_alloc(sn_cache, GFP_KERNEL);
GFP_KERNEL 2269 mm/mempolicy.c md = kzalloc(sizeof(struct numa_maps), GFP_KERNEL);
GFP_KERNEL 65 mm/mempool.c pool = kmalloc_node(sizeof(*pool), GFP_KERNEL | __GFP_ZERO, node_id);
GFP_KERNEL 69 mm/mempool.c GFP_KERNEL, node_id);
GFP_KERNEL 87 mm/mempool.c element = pool->alloc(GFP_KERNEL, pool->pool_data);
GFP_KERNEL 585 mm/migrate.c !try_to_release_page(page, GFP_KERNEL))
GFP_KERNEL 1152 mm/mmap.c vma = kmem_cache_zalloc(vm_area_cachep, GFP_KERNEL);
GFP_KERNEL 1827 mm/mmap.c new = kmem_cache_alloc(vm_area_cachep, GFP_KERNEL);
GFP_KERNEL 2035 mm/mmap.c vma = kmem_cache_zalloc(vm_area_cachep, GFP_KERNEL);
GFP_KERNEL 2158 mm/mmap.c new_vma = kmem_cache_alloc(vm_area_cachep, GFP_KERNEL);
GFP_KERNEL 2254 mm/mmap.c vma = kmem_cache_zalloc(vm_area_cachep, GFP_KERNEL);
GFP_KERNEL 154 mm/mmu_notifier.c mmu_notifier_mm = kmalloc(sizeof(struct mmu_notifier_mm), GFP_KERNEL);
GFP_KERNEL 202 mm/nommu.c ret = __vmalloc(size, GFP_KERNEL | __GFP_HIGHMEM | __GFP_ZERO,
GFP_KERNEL 259 mm/nommu.c return __vmalloc(size, GFP_KERNEL | __GFP_HIGHMEM, PAGE_KERNEL);
GFP_KERNEL 287 mm/nommu.c return __vmalloc(size, GFP_KERNEL | __GFP_HIGHMEM, PAGE_KERNEL_EXEC);
GFP_KERNEL 299 mm/nommu.c return __vmalloc(size, GFP_KERNEL, PAGE_KERNEL);
GFP_KERNEL 822 mm/nommu.c base = kmalloc(len, GFP_KERNEL|__GFP_COMP);
GFP_KERNEL 907 mm/nommu.c vml = kzalloc(sizeof(struct vm_list_struct), GFP_KERNEL);
GFP_KERNEL 991 mm/nommu.c vma = kzalloc(sizeof(struct vm_area_struct), GFP_KERNEL);
GFP_KERNEL 1768 mm/page_alloc.c struct zonelist *zonelist = node_zonelist(numa_node_id(), GFP_KERNEL);
GFP_KERNEL 2734 mm/page_alloc.c GFP_KERNEL, node);
GFP_KERNEL 130 mm/page_io.c bio = get_swap_bio(GFP_KERNEL, page_private(page), page,
GFP_KERNEL 67 mm/readahead.c page->index, GFP_KERNEL)) {
GFP_KERNEL 102 mm/readahead.c page->index, GFP_KERNEL)) {
GFP_KERNEL 924 mm/shmem.c error = mem_cgroup_cache_charge(page, current->mm, GFP_KERNEL);
GFP_KERNEL 927 mm/shmem.c error = radix_tree_preload(GFP_KERNEL);
GFP_KERNEL 2269 mm/shmem.c L1_CACHE_BYTES), GFP_KERNEL);
GFP_KERNEL 2338 mm/shmem.c p = (struct shmem_inode_info *)kmem_cache_alloc(shmem_inode_cachep, GFP_KERNEL);
GFP_KERNEL 956 mm/slab.c nc = kmalloc_node(memsize, GFP_KERNEL, node);
GFP_KERNEL 1035 mm/slab.c ac_ptr = kmalloc_node(memsize, GFP_KERNEL, node);
GFP_KERNEL 1243 mm/slab.c l3 = kmalloc_node(memsize, GFP_KERNEL, node);
GFP_KERNEL 1392 mm/slab.c ptr = kmalloc_node(sizeof(struct kmem_list3), GFP_KERNEL, nodeid);
GFP_KERNEL 1568 mm/slab.c ptr = kmalloc(sizeof(struct arraycache_init), GFP_KERNEL);
GFP_KERNEL 1582 mm/slab.c ptr = kmalloc(sizeof(struct arraycache_init), GFP_KERNEL);
GFP_KERNEL 2082 mm/slab.c kmalloc(sizeof(struct arraycache_init), GFP_KERNEL);
GFP_KERNEL 2092 mm/slab.c GFP_KERNEL, node);
GFP_KERNEL 2270 mm/slab.c cachep = kmem_cache_zalloc(&cache_cache, GFP_KERNEL);
GFP_KERNEL 3856 mm/slab.c l3 = kmalloc_node(sizeof(struct kmem_list3), GFP_KERNEL, node);
GFP_KERNEL 3917 mm/slab.c new = kzalloc(sizeof(*new), GFP_KERNEL);
GFP_KERNEL 4423 mm/slab.c m->private = kzalloc(n[0] * 4 * sizeof(unsigned long), GFP_KERNEL);
GFP_KERNEL 2769 mm/slub.c kmalloc(sizeof(struct list_head) * objects, GFP_KERNEL);
GFP_KERNEL 2900 mm/slub.c n = kmem_cache_alloc(kmalloc_caches, GFP_KERNEL);
GFP_KERNEL 2958 mm/slub.c sizeof(struct kmem_cache_node), GFP_KERNEL);
GFP_KERNEL 2971 mm/slub.c "kmalloc-96", 96, GFP_KERNEL);
GFP_KERNEL 2974 mm/slub.c "kmalloc-192", 192, GFP_KERNEL);
GFP_KERNEL 2980 mm/slub.c "kmalloc", 1 << i, GFP_KERNEL);
GFP_KERNEL 3017 mm/slub.c kasprintf(GFP_KERNEL, "kmalloc-%d", 1 << i);
GFP_KERNEL 3128 mm/slub.c s = kmalloc(kmem_size, GFP_KERNEL);
GFP_KERNEL 3130 mm/slub.c if (kmem_cache_open(s, GFP_KERNEL, name,
GFP_KERNEL 3170 mm/slub.c GFP_KERNEL);
GFP_KERNEL 3349 mm/slub.c sizeof(unsigned long), GFP_KERNEL);
GFP_KERNEL 3373 mm/slub.c p = kzalloc(16, GFP_KERNEL);
GFP_KERNEL 3381 mm/slub.c p = kzalloc(32, GFP_KERNEL);
GFP_KERNEL 3389 mm/slub.c p = kzalloc(64, GFP_KERNEL);
GFP_KERNEL 3399 mm/slub.c p = kzalloc(128, GFP_KERNEL);
GFP_KERNEL 3405 mm/slub.c p = kzalloc(256, GFP_KERNEL);
GFP_KERNEL 3412 mm/slub.c p = kzalloc(512, GFP_KERNEL);
GFP_KERNEL 3668 mm/slub.c nodes = kzalloc(2 * sizeof(unsigned long) * nr_node_ids, GFP_KERNEL);
GFP_KERNEL 4076 mm/slub.c int *data = kmalloc(nr_cpu_ids * sizeof(int), GFP_KERNEL);
GFP_KERNEL 4264 mm/slub.c char *name = kmalloc(ID_STR_LENGTH, GFP_KERNEL);
GFP_KERNEL 4367 mm/slub.c al = kmalloc(sizeof(struct saved_alias), GFP_KERNEL);
GFP_KERNEL 52 mm/sparse-vmemmap.c GFP_KERNEL | __GFP_ZERO, get_order(size));
GFP_KERNEL 66 mm/sparse.c section = kmalloc_node(array_size, GFP_KERNEL, nid);
GFP_KERNEL 267 mm/sparse.c return kmalloc(usemap_size(), GFP_KERNEL);
GFP_KERNEL 474 mm/sparse.c page = alloc_pages(GFP_KERNEL|__GFP_NOWARN, get_order(memmap_size));
GFP_KERNEL 306 mm/swap_state.c err = add_to_swap_cache(new_page, entry, gfp_mask & GFP_KERNEL);
GFP_KERNEL 518 mm/swapfile.c if (mem_cgroup_charge(page, vma->vm_mm, GFP_KERNEL))
GFP_KERNEL 1046 mm/swapfile.c new_se = kmalloc(sizeof(*se), GFP_KERNEL);
GFP_KERNEL 348 mm/truncate.c if (PagePrivate(page) && !try_to_release_page(page, GFP_KERNEL))
GFP_KERNEL 150 mm/util.c p = kmalloc(length, GFP_KERNEL);
GFP_KERNEL 297 mm/vmalloc.c return __get_vm_area_node(size, flags, start, end, -1, GFP_KERNEL,
GFP_KERNEL 314 mm/vmalloc.c -1, GFP_KERNEL, __builtin_return_address(0));
GFP_KERNEL 321 mm/vmalloc.c -1, GFP_KERNEL, caller);
GFP_KERNEL 597 mm/vmalloc.c return __vmalloc_node(size, GFP_KERNEL | __GFP_HIGHMEM, PAGE_KERNEL,
GFP_KERNEL 614 mm/vmalloc.c ret = __vmalloc(size, GFP_KERNEL | __GFP_HIGHMEM | __GFP_ZERO, PAGE_KERNEL);
GFP_KERNEL 638 mm/vmalloc.c return __vmalloc_node(size, GFP_KERNEL | __GFP_HIGHMEM, PAGE_KERNEL,
GFP_KERNEL 661 mm/vmalloc.c return __vmalloc(size, GFP_KERNEL | __GFP_HIGHMEM, PAGE_KERNEL_EXEC);
GFP_KERNEL 665 mm/vmalloc.c #define GFP_VMALLOC32 GFP_DMA32 | GFP_KERNEL
GFP_KERNEL 667 mm/vmalloc.c #define GFP_VMALLOC32 GFP_DMA | GFP_KERNEL
GFP_KERNEL 669 mm/vmalloc.c #define GFP_VMALLOC32 GFP_KERNEL
GFP_KERNEL 1301 mm/vmscan.c if (!cpuset_zone_allowed_hardwall(zone, GFP_KERNEL))
GFP_KERNEL 1364 mm/vmscan.c if (!cpuset_zone_allowed_hardwall(zone, GFP_KERNEL))
GFP_KERNEL 1428 mm/vmscan.c if (!cpuset_zone_allowed_hardwall(zone, GFP_KERNEL))
GFP_KERNEL 1511 mm/vmscan.c .gfp_mask = GFP_KERNEL,
GFP_KERNEL 1608 mm/vmscan.c nr_slab = shrink_slab(sc.nr_scanned, GFP_KERNEL,
GFP_KERNEL 1757 mm/vmscan.c if (!cpuset_zone_allowed_hardwall(zone, GFP_KERNEL))
GFP_KERNEL 1833 mm/vmscan.c .gfp_mask = GFP_KERNEL,
GFP_KERNEL 774 mm/vmstat.c + sizeof(struct vm_event_state), GFP_KERNEL);
GFP_KERNEL 777 mm/vmstat.c GFP_KERNEL);
GFP_KERNEL 539 net/802/garp.c port = kzalloc(sizeof(*port), GFP_KERNEL);
GFP_KERNEL 574 net/802/garp.c app = kzalloc(sizeof(*app), GFP_KERNEL);
GFP_KERNEL 108 net/8021q/vlan.c grp = kzalloc(sizeof(struct vlan_group), GFP_KERNEL);
GFP_KERNEL 130 net/8021q/vlan.c array = kzalloc(size, GFP_KERNEL);
GFP_KERNEL 665 net/8021q/vlan.c vn = kzalloc(sizeof(struct vlan_net), GFP_KERNEL);
GFP_KERNEL 398 net/8021q/vlan_dev.c np = kmalloc(sizeof(struct vlan_priority_tci_mapping), GFP_KERNEL);
GFP_KERNEL 84 net/9p/client.c options = kstrdup(opts, GFP_KERNEL);
GFP_KERNEL 152 net/9p/client.c clnt = kmalloc(sizeof(struct p9_client), GFP_KERNEL);
GFP_KERNEL 1009 net/9p/client.c ret = kmalloc(n, GFP_KERNEL);
GFP_KERNEL 1043 net/9p/client.c fid = kmalloc(sizeof(struct p9_fid), GFP_KERNEL);
GFP_KERNEL 504 net/9p/conv.c fc = kmalloc(sizeof(struct p9_fcall) + size, GFP_KERNEL);
GFP_KERNEL 398 net/9p/trans_fd.c m = kzalloc(sizeof(struct p9_conn), GFP_KERNEL);
GFP_KERNEL 715 net/9p/trans_fd.c kmalloc(sizeof(struct p9_fcall) + m->msize, GFP_KERNEL);
GFP_KERNEL 768 net/9p/trans_fd.c GFP_KERNEL);
GFP_KERNEL 864 net/9p/trans_fd.c req = kmalloc(sizeof(struct p9_req), GFP_KERNEL);
GFP_KERNEL 1181 net/9p/trans_fd.c options = kstrdup(params, GFP_KERNEL);
GFP_KERNEL 1222 net/9p/trans_fd.c GFP_KERNEL);
GFP_KERNEL 1423 net/9p/trans_fd.c trans = kmalloc(sizeof(struct p9_trans), GFP_KERNEL);
GFP_KERNEL 1485 net/9p/trans_fd.c trans = kmalloc(sizeof(struct p9_trans), GFP_KERNEL);
GFP_KERNEL 1551 net/9p/trans_fd.c trans = kmalloc(sizeof(struct p9_trans), GFP_KERNEL);
GFP_KERNEL 305 net/9p/trans_virtio.c *rc = kmalloc(sizeof(struct p9_fcall) + t->msize, GFP_KERNEL);
GFP_KERNEL 478 net/9p/trans_virtio.c trans = kmalloc(sizeof(struct p9_trans), GFP_KERNEL);
GFP_KERNEL 56 net/9p/util.c p = kmalloc(sizeof(struct p9_idpool), GFP_KERNEL);
GFP_KERNEL 94 net/9p/util.c if (idr_pre_get(&p->pool, GFP_KERNEL) == 0)
GFP_KERNEL 230 net/appletalk/ddp.c struct atalk_iface *iface = kzalloc(sizeof(*iface), GFP_KERNEL);
GFP_KERNEL 1046 net/appletalk/ddp.c sk = sk_alloc(net, PF_APPLETALK, GFP_KERNEL, &ddp_proto);
GFP_KERNEL 1660 net/appletalk/ddp.c struct sk_buff *skb2 = skb_copy(skb, GFP_KERNEL);
GFP_KERNEL 466 net/atm/br2684.c brvcc = kzalloc(sizeof(struct br2684_vcc), GFP_KERNEL);
GFP_KERNEL 460 net/atm/clip.c clip_vcc = kmalloc(sizeof(struct clip_vcc), GFP_KERNEL);
GFP_KERNEL 71 net/atm/common.c while (!(skb = alloc_skb(size,GFP_KERNEL))) schedule();
GFP_KERNEL 136 net/atm/common.c sk = sk_alloc(net, family, GFP_KERNEL, &vcc_proto);
GFP_KERNEL 871 net/atm/lec.c if (!(vpriv = kmalloc(sizeof(struct lec_vcc_priv), GFP_KERNEL)))
GFP_KERNEL 1336 net/atm/lec.c priv->tlvs = kmemdup(tlvs, sizeoftlvs, GFP_KERNEL);
GFP_KERNEL 1380 net/atm/lec.c entry->tlvs = kmemdup(tlvs, sizeoftlvs, GFP_KERNEL);
GFP_KERNEL 2366 net/atm/lec.c if (!(vpriv = kmalloc(sizeof(struct lec_vcc_priv), GFP_KERNEL)))
GFP_KERNEL 167 net/atm/mpc.c entry = kmalloc(sizeof(struct atm_mpoa_qos), GFP_KERNEL);
GFP_KERNEL 258 net/atm/mpc.c mpc = kzalloc(sizeof (struct mpoa_client), GFP_KERNEL);
GFP_KERNEL 446 net/atm/mpc.c mpc->mps_macs = kmalloc(num_macs*ETH_ALEN, GFP_KERNEL);
GFP_KERNEL 1343 net/atm/mpc.c client->mps_macs = kmemdup(msg->MPS_ctrl, ETH_ALEN, GFP_KERNEL);
GFP_KERNEL 90 net/atm/mpoa_caches.c in_cache_entry *entry = kzalloc(sizeof(in_cache_entry), GFP_KERNEL);
GFP_KERNEL 449 net/atm/mpoa_caches.c eg_cache_entry *entry = kzalloc(sizeof(eg_cache_entry), GFP_KERNEL);
GFP_KERNEL 204 net/atm/mpoa_proc.c page = (char *)__get_free_page(GFP_KERNEL);
GFP_KERNEL 279 net/atm/pppoatm.c pvcc = kzalloc(sizeof(*pvcc), GFP_KERNEL);
GFP_KERNEL 379 net/atm/proc.c page = get_zeroed_page(GFP_KERNEL);
GFP_KERNEL 415 net/atm/proc.c dev->proc_name = kmalloc(strlen(dev->type) + digits + 2, GFP_KERNEL);
GFP_KERNEL 36 net/atm/resources.c dev = kzalloc(sizeof(*dev), GFP_KERNEL);
GFP_KERNEL 77 net/atm/signaling.c while (!(skb = alloc_skb(sizeof(struct atmsvc_msg),GFP_KERNEL)))
GFP_KERNEL 173 net/atm/signaling.c while (!(skb = alloc_skb(sizeof(struct atmsvc_msg),GFP_KERNEL)))
GFP_KERNEL 1176 net/ax25/af_ax25.c if ((digi = kmalloc(sizeof(ax25_digi), GFP_KERNEL)) == NULL) {
GFP_KERNEL 104 net/ax25/ax25_uid.c if ((ax25_uid = kmalloc(sizeof(*ax25_uid), GFP_KERNEL)) == NULL)
GFP_KERNEL 350 net/bluetooth/bnep/core.c nskb = alloc_skb(2 + ETH_HLEN + skb->len, GFP_KERNEL);
GFP_KERNEL 78 net/bluetooth/cmtp/capi.c struct cmtp_application *app = kzalloc(sizeof(*app), GFP_KERNEL);
GFP_KERNEL 338 net/bluetooth/cmtp/core.c session = kzalloc(sizeof(struct cmtp_session), GFP_KERNEL);
GFP_KERNEL 589 net/bluetooth/hci_conn.c if (!(cl = kmalloc(size, GFP_KERNEL)))
GFP_KERNEL 444 net/bluetooth/hci_core.c if (!(buf = kmalloc(sizeof(struct inquiry_info) * max_rsp, GFP_KERNEL))) {
GFP_KERNEL 759 net/bluetooth/hci_core.c if (!(dl = kmalloc(size, GFP_KERNEL)))
GFP_KERNEL 826 net/bluetooth/hci_core.c hdev = kzalloc(sizeof(struct hci_dev), GFP_KERNEL);
GFP_KERNEL 693 net/bluetooth/hidp/core.c buf = kmalloc(req->rd_size, GFP_KERNEL);
GFP_KERNEL 807 net/bluetooth/hidp/core.c session = kzalloc(sizeof(struct hidp_session), GFP_KERNEL);
GFP_KERNEL 546 net/bluetooth/rfcomm/core.c struct rfcomm_session *s = kzalloc(sizeof(*s), GFP_KERNEL);
GFP_KERNEL 749 net/bluetooth/rfcomm/core.c skb = alloc_skb(sizeof(*cmd), GFP_KERNEL);
GFP_KERNEL 213 net/bluetooth/rfcomm/tty.c dev = kzalloc(sizeof(struct rfcomm_dev), GFP_KERNEL);
GFP_KERNEL 408 net/bluetooth/rfcomm/tty.c dlc = rfcomm_dlc_alloc(GFP_KERNEL);
GFP_KERNEL 477 net/bluetooth/rfcomm/tty.c if (!(dl = kmalloc(size, GFP_KERNEL)))
GFP_KERNEL 224 net/bridge/br_if.c GFP_KERNEL);
GFP_KERNEL 249 net/bridge/br_if.c p = kzalloc(sizeof(*p), GFP_KERNEL);
GFP_KERNEL 168 net/bridge/br_ioctl.c indices = kcalloc(num, sizeof(int), GFP_KERNEL);
GFP_KERNEL 336 net/bridge/br_ioctl.c indices = kcalloc(args[2], sizeof(int), GFP_KERNEL);
GFP_KERNEL 170 net/can/af_can.c sk = sk_alloc(net, PF_CAN, GFP_KERNEL, cp->prot);
GFP_KERNEL 400 net/can/af_can.c r = kmem_cache_alloc(rcv_cache, GFP_KERNEL);
GFP_KERNEL 750 net/can/af_can.c d = kzalloc(sizeof(*d), GFP_KERNEL);
GFP_KERNEL 845 net/can/bcm.c op = kzalloc(OPSIZ, GFP_KERNEL);
GFP_KERNEL 854 net/can/bcm.c GFP_KERNEL);
GFP_KERNEL 1005 net/can/bcm.c op = kzalloc(OPSIZ, GFP_KERNEL);
GFP_KERNEL 1015 net/can/bcm.c GFP_KERNEL);
GFP_KERNEL 1023 net/can/bcm.c GFP_KERNEL);
GFP_KERNEL 1156 net/can/bcm.c skb = alloc_skb(CFSIZ, GFP_KERNEL);
GFP_KERNEL 434 net/can/raw.c filter = kmalloc(optlen, GFP_KERNEL);
GFP_KERNEL 173 net/compat.c kcmsg_base = kcmsg = sock_kmalloc(sk, kcmlen, GFP_KERNEL);
GFP_KERNEL 979 net/core/dev.c dev->ifalias = krealloc(dev->ifalias, len+1, GFP_KERNEL);
GFP_KERNEL 4305 net/core/dev.c p = kzalloc(alloc_size, GFP_KERNEL);
GFP_KERNEL 4311 net/core/dev.c tx = kcalloc(queue_count, sizeof(struct netdev_queue), GFP_KERNEL);
GFP_KERNEL 4685 net/core/dev.c GFP_KERNEL);
GFP_KERNEL 4752 net/core/dev.c hash = kmalloc(sizeof(*hash) * NETDEV_HASHENTRIES, GFP_KERNEL);
GFP_KERNEL 23 net/core/fib_rules.c r = kzalloc(ops->rule_size, GFP_KERNEL);
GFP_KERNEL 241 net/core/fib_rules.c rule = kzalloc(ops->rule_size, GFP_KERNEL);
GFP_KERNEL 579 net/core/fib_rules.c skb = nlmsg_new(fib_rule_nlmsg_size(ops, rule), GFP_KERNEL);
GFP_KERNEL 591 net/core/fib_rules.c err = rtnl_notify(skb, net, pid, ops->nlgroup, nlh, GFP_KERNEL);
GFP_KERNEL 481 net/core/filter.c fp = sock_kmalloc(sk, fsize+sizeof(*fp), GFP_KERNEL);
GFP_KERNEL 322 net/core/flow.c __get_free_pages(GFP_KERNEL|__GFP_ZERO, order);
GFP_KERNEL 174 net/core/gen_estimator.c est = kzalloc(sizeof(*est), GFP_KERNEL);
GFP_KERNEL 530 net/core/neighbour.c n = kmalloc(sizeof(*n) + key_len, GFP_KERNEL);
GFP_KERNEL 1339 net/core/neighbour.c p = kmemdup(ref, sizeof(*p), GFP_KERNEL);
GFP_KERNEL 1439 net/core/neighbour.c tbl->phash_buckets = kzalloc(phsize, GFP_KERNEL);
GFP_KERNEL 2718 net/core/neighbour.c t = kmemdup(&neigh_sysctl_template, sizeof(*t), GFP_KERNEL);
GFP_KERNEL 2778 net/core/neighbour.c t->dev_name = kstrdup(dev_name_source, GFP_KERNEL);
GFP_KERNEL 45 net/core/net_namespace.c INITIAL_NET_GEN_PTRS * sizeof(void *), GFP_KERNEL);
GFP_KERNEL 84 net/core/net_namespace.c return kmem_cache_zalloc(net_cachep, GFP_KERNEL);
GFP_KERNEL 367 net/core/net_namespace.c ida_pre_get(&net_generic_ids, GFP_KERNEL);
GFP_KERNEL 433 net/core/net_namespace.c id * sizeof(void *), GFP_KERNEL);
GFP_KERNEL 678 net/core/netpoll.c npinfo = kmalloc(sizeof(*npinfo), GFP_KERNEL);
GFP_KERNEL 2636 net/core/pktgen.c struct page *page = alloc_pages(GFP_KERNEL, 0);
GFP_KERNEL 2984 net/core/pktgen.c struct page *page = alloc_pages(GFP_KERNEL, 0);
GFP_KERNEL 3627 net/core/pktgen.c pkt_dev = kzalloc(sizeof(struct pktgen_dev), GFP_KERNEL);
GFP_KERNEL 3695 net/core/pktgen.c t = kzalloc(sizeof(struct pktgen_thread), GFP_KERNEL);
GFP_KERNEL 49 net/core/request_sock.c GFP_KERNEL | __GFP_HIGHMEM | __GFP_ZERO,
GFP_KERNEL 52 net/core/request_sock.c lopt = kzalloc(lopt_size, GFP_KERNEL);
GFP_KERNEL 156 net/core/rtnetlink.c tab = kcalloc(RTM_NR_MSGTYPES, sizeof(*tab), GFP_KERNEL);
GFP_KERNEL 445 net/core/rtnetlink.c netlink_broadcast(rtnl, skb, pid, group, GFP_KERNEL);
GFP_KERNEL 826 net/core/rtnetlink.c sa = kmalloc(len, GFP_KERNEL);
GFP_KERNEL 1184 net/core/rtnetlink.c nskb = nlmsg_new(if_nlmsg_size(dev), GFP_KERNEL);
GFP_KERNEL 1235 net/core/rtnetlink.c skb = nlmsg_new(if_nlmsg_size(dev), GFP_KERNEL);
GFP_KERNEL 1246 net/core/rtnetlink.c err = rtnl_notify(skb, net, 0, RTNLGRP_LINK, NULL, GFP_KERNEL);
GFP_KERNEL 1398 net/core/rtnetlink.c rta_buf = kmalloc(rtattr_max * sizeof(struct rtattr *), GFP_KERNEL);
GFP_KERNEL 74 net/core/scm.c fpl = kmalloc(sizeof(struct scm_fp_list), GFP_KERNEL);
GFP_KERNEL 285 net/core/scm.c new_fpl = kmalloc(sizeof(*fpl), GFP_KERNEL);
GFP_KERNEL 1452 net/core/skbuff.c skb = skb_clone(__skb, GFP_KERNEL);
GFP_KERNEL 1704 net/core/sock.c sk->sk_allocation = GFP_KERNEL;
GFP_KERNEL 2056 net/core/sock.c request_sock_slab_name = kmalloc(strlen(prot->name) + sizeof(mask) - 1, GFP_KERNEL);
GFP_KERNEL 2075 net/core/sock.c timewait_sock_slab_name = kmalloc(strlen(prot->name) + sizeof(mask) - 1, GFP_KERNEL);
GFP_KERNEL 172 net/core/sysctl_net_core.c tbl = kmemdup(tbl, sizeof(netns_core_table), GFP_KERNEL);
GFP_KERNEL 69 net/dccp/ccid.c slab_name = kstrdup(slab_name_fmt, GFP_KERNEL);
GFP_KERNEL 571 net/dccp/feat.c u8 *copy = kmemdup(val, len, GFP_KERNEL);
GFP_KERNEL 574 net/dccp/feat.c rc = dccp_feat_change(dmsk, type, feat, copy, len, GFP_KERNEL);
GFP_KERNEL 484 net/dccp/output.c dccp_transmit_skb(sk, skb_clone(skb, GFP_KERNEL));
GFP_KERNEL 588 net/dccp/output.c const gfp_t prio = active ? GFP_KERNEL : GFP_ATOMIC;
GFP_KERNEL 163 net/dccp/probe.c dccpw.fifo = kfifo_alloc(bufsize, GFP_KERNEL, &dccpw.lock);
GFP_KERNEL 210 net/dccp/proto.c dp->dccps_hc_rx_ackvec = dccp_ackvec_alloc(GFP_KERNEL);
GFP_KERNEL 215 net/dccp/proto.c sk, GFP_KERNEL);
GFP_KERNEL 217 net/dccp/proto.c sk, GFP_KERNEL);
GFP_KERNEL 445 net/dccp/proto.c sl = kmalloc(optlen, GFP_KERNEL);
GFP_KERNEL 485 net/dccp/proto.c val = kmalloc(opt.dccpsf_len, GFP_KERNEL);
GFP_KERNEL 495 net/dccp/proto.c val, opt.dccpsf_len, GFP_KERNEL);
GFP_KERNEL 697 net/decnet/af_decnet.c if ((sk = dn_alloc_sock(net, sock, GFP_KERNEL)) == NULL)
GFP_KERNEL 240 net/decnet/dn_dev.c t = kmemdup(&dn_dev_sysctl, sizeof(*t), GFP_KERNEL);
GFP_KERNEL 388 net/decnet/dn_dev.c ifa = kzalloc(sizeof(*ifa), GFP_KERNEL);
GFP_KERNEL 763 net/decnet/dn_dev.c skb = alloc_skb(dn_ifaddr_nlmsg_size(), GFP_KERNEL);
GFP_KERNEL 774 net/decnet/dn_dev.c err = rtnl_notify(skb, &init_net, 0, RTNLGRP_DECnet_IFADDR, NULL, GFP_KERNEL);
GFP_KERNEL 289 net/decnet/dn_fib.c fi = kzalloc(sizeof(*fi)+nhs*sizeof(struct dn_fib_nh), GFP_KERNEL);
GFP_KERNEL 1530 net/decnet/dn_route.c skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
GFP_KERNEL 163 net/decnet/dn_table.c ht = kcalloc(new_divisor, sizeof(struct dn_fib_node*), GFP_KERNEL);
GFP_KERNEL 187 net/decnet/dn_table.c struct dn_zone *dz = kzalloc(sizeof(struct dn_zone), GFP_KERNEL);
GFP_KERNEL 199 net/decnet/dn_table.c dz->dz_hash = kcalloc(dz->dz_divisor, sizeof(struct dn_fib_node *), GFP_KERNEL);
GFP_KERNEL 365 net/decnet/dn_table.c skb = nlmsg_new(dn_fib_nlmsg_size(DN_FIB_INFO(f)), GFP_KERNEL);
GFP_KERNEL 378 net/decnet/dn_table.c err = rtnl_notify(skb, &init_net, pid, RTNLGRP_DECnet_ROUTE, nlh, GFP_KERNEL);
GFP_KERNEL 601 net/decnet/dn_table.c new_f = kmem_cache_zalloc(dn_hash_kmem, GFP_KERNEL);
GFP_KERNEL 842 net/decnet/dn_table.c GFP_KERNEL);
GFP_KERNEL 94 net/dsa/dsa.c ds = kzalloc(sizeof(*ds) + drv->priv_size, GFP_KERNEL);
GFP_KERNEL 625 net/econet/af_econet.c sk = sk_alloc(net, PF_ECONET, GFP_KERNEL, &econet_proto);
GFP_KERNEL 676 net/econet/af_econet.c edev = kzalloc(sizeof(struct ec_device), GFP_KERNEL);
GFP_KERNEL 113 net/ieee80211/ieee80211_crypt.c alg = kzalloc(sizeof(*alg), GFP_KERNEL);
GFP_KERNEL 72 net/ieee80211/ieee80211_module.c GFP_KERNEL);
GFP_KERNEL 381 net/ieee80211/ieee80211_wx.c GFP_KERNEL);
GFP_KERNEL 626 net/ieee80211/ieee80211_wx.c new_crypt = kzalloc(sizeof(*new_crypt), GFP_KERNEL);
GFP_KERNEL 344 net/ipv4/af_inet.c sk = sk_alloc(net, PF_INET, GFP_KERNEL, answer_prot);
GFP_KERNEL 232 net/ipv4/ah4.c ahp = kzalloc(sizeof(*ahp), GFP_KERNEL);
GFP_KERNEL 267 net/ipv4/ah4.c ahp->work_icv = kmalloc(ahp->icv_full_len, GFP_KERNEL);
GFP_KERNEL 249 net/ipv4/cipso_ipv4.c GFP_KERNEL);
GFP_KERNEL 115 net/ipv4/devinet.c struct in_ifaddr *ifa = kzalloc(sizeof(*ifa), GFP_KERNEL);
GFP_KERNEL 161 net/ipv4/devinet.c in_dev = kzalloc(sizeof(*in_dev), GFP_KERNEL);
GFP_KERNEL 1209 net/ipv4/devinet.c skb = nlmsg_new(inet_nlmsg_size(), GFP_KERNEL);
GFP_KERNEL 1220 net/ipv4/devinet.c err = rtnl_notify(skb, net, pid, RTNLGRP_IPV4_IFADDR, nlh, GFP_KERNEL);
GFP_KERNEL 1478 net/ipv4/devinet.c t = kmemdup(&devinet_sysctl, sizeof(*t), GFP_KERNEL);
GFP_KERNEL 1493 net/ipv4/devinet.c t->dev_name = kstrdup(dev_name, GFP_KERNEL);
GFP_KERNEL 1580 net/ipv4/devinet.c all = kmemdup(all, sizeof(ipv4_devconf), GFP_KERNEL);
GFP_KERNEL 1584 net/ipv4/devinet.c dflt = kmemdup(dflt, sizeof(ipv4_devconf_dflt), GFP_KERNEL);
GFP_KERNEL 1589 net/ipv4/devinet.c tbl = kmemdup(tbl, sizeof(ctl_forward_entry), GFP_KERNEL);
GFP_KERNEL 501 net/ipv4/esp4.c key = kmalloc(keylen, GFP_KERNEL);
GFP_KERNEL 556 net/ipv4/esp4.c esp = kzalloc(sizeof(*esp), GFP_KERNEL);
GFP_KERNEL 430 net/ipv4/fib_frontend.c mx = kzalloc(3 * nla_total_size(4), GFP_KERNEL);
GFP_KERNEL 863 net/ipv4/fib_frontend.c skb = skb_clone(skb, GFP_KERNEL);
GFP_KERNEL 980 net/ipv4/fib_frontend.c sizeof(struct hlist_head)*FIB_TABLE_HASHSZ, GFP_KERNEL);
GFP_KERNEL 104 net/ipv4/fib_hash.c return kzalloc(size, GFP_KERNEL);
GFP_KERNEL 107 net/ipv4/fib_hash.c __get_free_pages(GFP_KERNEL | __GFP_ZERO, get_order(size));
GFP_KERNEL 208 net/ipv4/fib_hash.c struct fn_zone *fz = kzalloc(sizeof(struct fn_zone), GFP_KERNEL);
GFP_KERNEL 499 net/ipv4/fib_hash.c new_f = kmem_cache_zalloc(fn_hash_kmem, GFP_KERNEL);
GFP_KERNEL 511 net/ipv4/fib_hash.c new_fa = kmem_cache_alloc(fn_alias_kmem, GFP_KERNEL);
GFP_KERNEL 785 net/ipv4/fib_hash.c GFP_KERNEL);
GFP_KERNEL 304 net/ipv4/fib_rules.c ops = kmemdup(&fib4_rules_ops_template, sizeof(*ops), GFP_KERNEL);
GFP_KERNEL 312 net/ipv4/fib_semantics.c skb = nlmsg_new(fib_nlmsg_size(fa->fa_info), GFP_KERNEL);
GFP_KERNEL 326 net/ipv4/fib_semantics.c info->nlh, GFP_KERNEL);
GFP_KERNEL 612 net/ipv4/fib_semantics.c return kzalloc(bytes, GFP_KERNEL);
GFP_KERNEL 615 net/ipv4/fib_semantics.c __get_free_pages(GFP_KERNEL | __GFP_ZERO, get_order(bytes));
GFP_KERNEL 727 net/ipv4/fib_semantics.c fi = kzalloc(sizeof(*fi)+nhs*sizeof(struct fib_nh), GFP_KERNEL);
GFP_KERNEL 355 net/ipv4/fib_trie.c return kzalloc(size, GFP_KERNEL);
GFP_KERNEL 357 net/ipv4/fib_trie.c return __vmalloc(size, GFP_KERNEL | __GFP_ZERO, PAGE_KERNEL);
GFP_KERNEL 390 net/ipv4/fib_trie.c struct leaf *l = kmem_cache_alloc(trie_leaf_kmem, GFP_KERNEL);
GFP_KERNEL 400 net/ipv4/fib_trie.c struct leaf_info *li = kmalloc(sizeof(struct leaf_info), GFP_KERNEL);
GFP_KERNEL 1257 net/ipv4/fib_trie.c new_fa = kmem_cache_alloc(fn_alias_kmem, GFP_KERNEL);
GFP_KERNEL 1295 net/ipv4/fib_trie.c new_fa = kmem_cache_alloc(fn_alias_kmem, GFP_KERNEL);
GFP_KERNEL 2007 net/ipv4/fib_trie.c GFP_KERNEL);
GFP_KERNEL 1149 net/ipv4/icmp.c kzalloc(nr_cpu_ids * sizeof(struct sock *), GFP_KERNEL);
GFP_KERNEL 1030 net/ipv4/igmp.c pmc = kzalloc(sizeof(*pmc), GFP_KERNEL);
GFP_KERNEL 1209 net/ipv4/igmp.c im = kmalloc(sizeof(*im), GFP_KERNEL);
GFP_KERNEL 1772 net/ipv4/igmp.c iml = sock_kmalloc(sk,sizeof(*iml),GFP_KERNEL);
GFP_KERNEL 1944 net/ipv4/igmp.c newpsl = sock_kmalloc(sk, IP_SFLSIZE(count), GFP_KERNEL);
GFP_KERNEL 2029 net/ipv4/igmp.c GFP_KERNEL);
GFP_KERNEL 302 net/ipv4/inet_diag.c GFP_KERNEL);
GFP_KERNEL 923 net/ipv4/inet_diag.c inet_diag_table = kzalloc(inet_diag_table_size, GFP_KERNEL);
GFP_KERNEL 661 net/ipv4/ip_fragment.c table = kmemdup(table, sizeof(ip4_frags_ns_ctl_table), GFP_KERNEL);
GFP_KERNEL 1253 net/ipv4/ip_gre.c ign = kzalloc(sizeof(struct ipgre_net), GFP_KERNEL);
GFP_KERNEL 505 net/ipv4/ip_options.c GFP_KERNEL);
GFP_KERNEL 220 net/ipv4/ip_sockglue.c new_ra = on ? kmalloc(sizeof(*new_ra), GFP_KERNEL) : NULL;
GFP_KERNEL 654 net/ipv4/ip_sockglue.c msf = kmalloc(optlen, GFP_KERNEL);
GFP_KERNEL 811 net/ipv4/ip_sockglue.c gsf = kmalloc(optlen,GFP_KERNEL);
GFP_KERNEL 831 net/ipv4/ip_sockglue.c msf = kmalloc(msize,GFP_KERNEL);
GFP_KERNEL 224 net/ipv4/ipconfig.c if (!(d = kmalloc(sizeof(struct ic_device), GFP_KERNEL))) {
GFP_KERNEL 715 net/ipv4/ipconfig.c GFP_KERNEL);
GFP_KERNEL 775 net/ipv4/ipip.c ipn = kzalloc(sizeof(struct ipip_net), GFP_KERNEL);
GFP_KERNEL 525 net/ipv4/ipmr.c struct mfc_cache *c=kmem_cache_zalloc(mrt_cachep, GFP_KERNEL);
GFP_KERNEL 576 net/ipv4/netfilter/ipt_CLUSTERIP.c idx = kmalloc(sizeof(struct clusterip_seq_position), GFP_KERNEL);
GFP_KERNEL 235 net/ipv4/route.c GFP_KERNEL);
GFP_KERNEL 2768 net/ipv4/route.c skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
GFP_KERNEL 3173 net/ipv4/route.c tbl = kmemdup(tbl, sizeof(ipv4_route_flush_table), GFP_KERNEL);
GFP_KERNEL 814 net/ipv4/sysctl_net_ipv4.c table = kmemdup(table, sizeof(ipv4_net_table), GFP_KERNEL);
GFP_KERNEL 1798 net/ipv4/tcp.c tcp_send_active_reset(sk, GFP_KERNEL);
GFP_KERNEL 2514 net/ipv4/tcp.c p = kzalloc(sizeof(*p), GFP_KERNEL);
GFP_KERNEL 976 net/ipv4/tcp_ipv4.c struct tcp_md5sig_info *p = kzalloc(sizeof(*p), GFP_KERNEL);
GFP_KERNEL 985 net/ipv4/tcp_ipv4.c newkey = kmemdup(cmd.tcpm_key, cmd.tcpm_keylen, GFP_KERNEL);
GFP_KERNEL 2148 net/ipv4/tcp_output.c skb = alloc_skb_fclone(MAX_TCP_HEADER, GFP_KERNEL);
GFP_KERNEL 2406 net/ipv4/tcp_output.c tcp_transmit_skb(sk, buff, 1, GFP_KERNEL);
GFP_KERNEL 227 net/ipv4/tcp_probe.c tcp_probe.log = kcalloc(bufsize, sizeof(struct tcp_log), GFP_KERNEL);
GFP_KERNEL 343 net/ipv6/addrconf.c ndev = kzalloc(sizeof(struct inet6_dev), GFP_KERNEL);
GFP_KERNEL 3607 net/ipv6/addrconf.c if ((skb = nlmsg_new(inet6_ifaddr_msgsize(), GFP_KERNEL)) == NULL) {
GFP_KERNEL 4291 net/ipv6/addrconf.c t = kmemdup(&addrconf_sysctl, sizeof(*t), GFP_KERNEL);
GFP_KERNEL 4306 net/ipv6/addrconf.c t->dev_name = kstrdup(dev_name, GFP_KERNEL);
GFP_KERNEL 4372 net/ipv6/addrconf.c all = kmemdup(all, sizeof(ipv6_devconf), GFP_KERNEL);
GFP_KERNEL 4376 net/ipv6/addrconf.c dflt = kmemdup(dflt, sizeof(ipv6_devconf_dflt), GFP_KERNEL);
GFP_KERNEL 231 net/ipv6/addrlabel.c newp = kmalloc(sizeof(*newp), GFP_KERNEL);
GFP_KERNEL 582 net/ipv6/addrlabel.c if (!(skb = nlmsg_new(ip6addrlbl_msgsize(), GFP_KERNEL))) {
GFP_KERNEL 157 net/ipv6/af_inet6.c sk = sk_alloc(net, PF_INET6, GFP_KERNEL, answer_prot);
GFP_KERNEL 440 net/ipv6/ah6.c ahp = kzalloc(sizeof(*ahp), GFP_KERNEL);
GFP_KERNEL 475 net/ipv6/ah6.c ahp->work_icv = kmalloc(ahp->icv_full_len, GFP_KERNEL);
GFP_KERNEL 73 net/ipv6/anycast.c pac = sock_kmalloc(sk, sizeof(struct ipv6_ac_socklist), GFP_KERNEL);
GFP_KERNEL 444 net/ipv6/esp6.c key = kmalloc(keylen, GFP_KERNEL);
GFP_KERNEL 502 net/ipv6/esp6.c esp = kzalloc(sizeof(*esp), GFP_KERNEL);
GFP_KERNEL 271 net/ipv6/fib6_rules.c GFP_KERNEL);
GFP_KERNEL 808 net/ipv6/icmp.c kzalloc(nr_cpu_ids * sizeof(struct sock *), GFP_KERNEL);
GFP_KERNEL 970 net/ipv6/icmp.c GFP_KERNEL);
GFP_KERNEL 1481 net/ipv6/ip6_fib.c net->ipv6.rt6_stats = kzalloc(sizeof(*net->ipv6.rt6_stats), GFP_KERNEL);
GFP_KERNEL 1487 net/ipv6/ip6_fib.c GFP_KERNEL);
GFP_KERNEL 1492 net/ipv6/ip6_fib.c GFP_KERNEL);
GFP_KERNEL 1503 net/ipv6/ip6_fib.c GFP_KERNEL);
GFP_KERNEL 332 net/ipv6/ip6_flowlabel.c fl = kzalloc(sizeof(*fl), GFP_KERNEL);
GFP_KERNEL 343 net/ipv6/ip6_flowlabel.c fl->opt = kmalloc(sizeof(*fl->opt) + olen, GFP_KERNEL);
GFP_KERNEL 527 net/ipv6/ip6_flowlabel.c sfl1 = kmalloc(sizeof(*sfl1), GFP_KERNEL);
GFP_KERNEL 1414 net/ipv6/ip6_tunnel.c ip6n = kzalloc(sizeof(struct ip6_tnl_net), GFP_KERNEL);
GFP_KERNEL 686 net/ipv6/ip6mr.c struct mfc6_cache *c = kmem_cache_alloc(mrt_cachep, GFP_KERNEL);
GFP_KERNEL 70 net/ipv6/ipv6_sockglue.c new_ra = (sel>=0) ? kmalloc(sizeof(*new_ra), GFP_KERNEL) : NULL;
GFP_KERNEL 413 net/ipv6/ipv6_sockglue.c opt = sock_kmalloc(sk, sizeof(*opt) + optlen, GFP_KERNEL);
GFP_KERNEL 604 net/ipv6/ipv6_sockglue.c gsf = kmalloc(optlen,GFP_KERNEL);
GFP_KERNEL 196 net/ipv6/mcast.c mc_lst = sock_kmalloc(sk, sizeof(struct ipv6_mc_socklist), GFP_KERNEL);
GFP_KERNEL 687 net/ipv6/reassembly.c table = kmemdup(table, sizeof(ip6_frags_ns_ctl_table), GFP_KERNEL);
GFP_KERNEL 2313 net/ipv6/route.c skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
GFP_KERNEL 2595 net/ipv6/route.c GFP_KERNEL);
GFP_KERNEL 2619 net/ipv6/route.c GFP_KERNEL);
GFP_KERNEL 2626 net/ipv6/route.c GFP_KERNEL);
GFP_KERNEL 2636 net/ipv6/route.c GFP_KERNEL);
GFP_KERNEL 2645 net/ipv6/route.c GFP_KERNEL);
GFP_KERNEL 241 net/ipv6/sit.c kcalloc(cmax, sizeof(*kp), GFP_KERNEL) :
GFP_KERNEL 311 net/ipv6/sit.c p = kzalloc(sizeof(struct ip_tunnel_prl_entry), GFP_KERNEL);
GFP_KERNEL 1009 net/ipv6/sit.c sitn = kzalloc(sizeof(struct sit_net), GFP_KERNEL);
GFP_KERNEL 71 net/ipv6/sysctl_net_ipv6.c GFP_KERNEL);
GFP_KERNEL 723 net/ipv6/tcp_ipv6.c p = kzalloc(sizeof(struct tcp_md5sig_info), GFP_KERNEL);
GFP_KERNEL 731 net/ipv6/tcp_ipv6.c newkey = kmemdup(cmd.tcpm_key, cmd.tcpm_keylen, GFP_KERNEL);
GFP_KERNEL 1372 net/ipx/af_ipx.c sk = sk_alloc(net, PF_IPX, GFP_KERNEL, &ipx_proto);
GFP_KERNEL 382 net/irda/ircomm/ircomm_tty.c self = kzalloc(sizeof(struct ircomm_tty_cb), GFP_KERNEL);
GFP_KERNEL 119 net/irda/irlap.c self = kzalloc(sizeof(struct irlap_cb), GFP_KERNEL);
GFP_KERNEL 81 net/irda/irlmp.c irlmp = kzalloc( sizeof(struct irlmp_cb), GFP_KERNEL);
GFP_KERNEL 292 net/irda/irlmp.c lap = kzalloc(sizeof(struct lap_cb), GFP_KERNEL);
GFP_KERNEL 479 net/irda/irnet/irnet_ppp.c ap = kzalloc(sizeof(*ap), GFP_KERNEL);
GFP_KERNEL 90 net/irda/irnetlink.c msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
GFP_KERNEL 89 net/irda/irttp.c irttp = kzalloc(sizeof(struct irttp_cb), GFP_KERNEL);
GFP_KERNEL 251 net/iucv/af_iucv.c sk = iucv_sock_alloc(sock, protocol, GFP_KERNEL);
GFP_KERNEL 484 net/iucv/af_iucv.c IPRMDATA, GFP_KERNEL);
GFP_KERNEL 323 net/iucv/iucv.c param = kzalloc(sizeof(union iucv_param), GFP_KERNEL|GFP_DMA);
GFP_KERNEL 519 net/iucv/iucv.c iucv_path_table = kzalloc(alloc_size, GFP_KERNEL);
GFP_KERNEL 565 net/iucv/iucv.c GFP_KERNEL|GFP_DMA, cpu_to_node(cpu));
GFP_KERNEL 569 net/iucv/iucv.c GFP_KERNEL|GFP_DMA, cpu_to_node(cpu));
GFP_KERNEL 1621 net/iucv/iucv.c GFP_KERNEL|GFP_DMA, cpu_to_node(cpu));
GFP_KERNEL 1629 net/iucv/iucv.c GFP_KERNEL|GFP_DMA, cpu_to_node(cpu));
GFP_KERNEL 188 net/key/af_key.c sk = sk_alloc(net, PF_KEY, GFP_KERNEL, &key_proto);
GFP_KERNEL 346 net/key/af_key.c struct sk_buff *skb = alloc_skb(sizeof(struct sadb_msg) + 16, GFP_KERNEL);
GFP_KERNEL 370 net/key/af_key.c pfkey_broadcast(skb, GFP_KERNEL, BROADCAST_ONE, sk);
GFP_KERNEL 475 net/key/af_key.c uctx = kmalloc((sizeof(*uctx)+ctx_size), GFP_KERNEL);
GFP_KERNEL 1178 net/key/af_key.c x->aalg = kmalloc(sizeof(*x->aalg) + keysize, GFP_KERNEL);
GFP_KERNEL 1197 net/key/af_key.c x->calg = kmalloc(sizeof(*x->calg), GFP_KERNEL);
GFP_KERNEL 1212 net/key/af_key.c x->ealg = kmalloc(sizeof(*x->ealg) + keysize, GFP_KERNEL);
GFP_KERNEL 1261 net/key/af_key.c x->encap = kmalloc(sizeof(*x->encap), GFP_KERNEL);
GFP_KERNEL 1392 net/key/af_key.c pfkey_broadcast(resp_skb, GFP_KERNEL, BROADCAST_ONE, sk);
GFP_KERNEL 1686 net/key/af_key.c supp_skb = compose_sadb_supported(hdr, GFP_KERNEL);
GFP_KERNEL 1694 net/key/af_key.c pfkey_broadcast(supp_skb, GFP_KERNEL, BROADCAST_REGISTERED, sk);
GFP_KERNEL 1820 net/key/af_key.c pfkey_broadcast(skb_clone(skb, GFP_KERNEL), GFP_KERNEL, BROADCAST_ALL, NULL);
GFP_KERNEL 2178 net/key/af_key.c xp = xfrm_policy_alloc(GFP_KERNEL);
GFP_KERNEL 2735 net/key/af_key.c pfkey_broadcast(skb_clone(skb, GFP_KERNEL), GFP_KERNEL,
GFP_KERNEL 3528 net/key/af_key.c skb = alloc_skb(len, GFP_KERNEL);
GFP_KERNEL 164 net/llc/af_llc.c sk = llc_sk_alloc(net, PF_LLC, GFP_KERNEL, &llc_proto);
GFP_KERNEL 436 net/mac80211/cfg.c new = kzalloc(size, GFP_KERNEL);
GFP_KERNEL 688 net/mac80211/cfg.c sta = sta_info_alloc(sdata, mac, GFP_KERNEL);
GFP_KERNEL 171 net/mac80211/debugfs_key.c char *buf = kmalloc(bufsize, GFP_KERNEL);
GFP_KERNEL 245 net/mac80211/iface.c GFP_KERNEL);
GFP_KERNEL 270 net/mac80211/key.c key = kzalloc(sizeof(struct ieee80211_key) + key_len, GFP_KERNEL);
GFP_KERNEL 58 net/mac80211/led.c local->rx_led = kzalloc(sizeof(struct led_trigger), GFP_KERNEL);
GFP_KERNEL 69 net/mac80211/led.c local->tx_led = kzalloc(sizeof(struct led_trigger), GFP_KERNEL);
GFP_KERNEL 80 net/mac80211/led.c local->assoc_led = kzalloc(sizeof(struct led_trigger), GFP_KERNEL);
GFP_KERNEL 91 net/mac80211/led.c local->radio_led = kzalloc(sizeof(struct led_trigger), GFP_KERNEL);
GFP_KERNEL 128 net/mac80211/mesh.c sdata->u.mesh.rmc = kmalloc(sizeof(struct mesh_rmc), GFP_KERNEL);
GFP_KERNEL 293 net/mac80211/mesh.c newtbl = kmalloc(sizeof(struct mesh_table), GFP_KERNEL);
GFP_KERNEL 298 net/mac80211/mesh.c (1 << size_order), GFP_KERNEL);
GFP_KERNEL 306 net/mac80211/mesh.c (1 << size_order), GFP_KERNEL);
GFP_KERNEL 637 net/mac80211/mesh_hwmp.c preq_node = kmalloc(sizeof(struct mesh_preq_queue), GFP_KERNEL);
GFP_KERNEL 189 net/mac80211/mesh_pathtbl.c new_mpath = kzalloc(sizeof(struct mesh_path), GFP_KERNEL);
GFP_KERNEL 193 net/mac80211/mesh_pathtbl.c new_node = kmalloc(sizeof(struct mpath_node), GFP_KERNEL);
GFP_KERNEL 277 net/mac80211/mesh_pathtbl.c new_mpath = kzalloc(sizeof(struct mesh_path), GFP_KERNEL);
GFP_KERNEL 281 net/mac80211/mesh_pathtbl.c new_node = kmalloc(sizeof(struct mpath_node), GFP_KERNEL);
GFP_KERNEL 434 net/mac80211/mlme.c ifsta->assocreq_ies = kmalloc(ifsta->assocreq_ies_len, GFP_KERNEL);
GFP_KERNEL 662 net/mac80211/mlme.c ifsta->assocresp_ies_len), GFP_KERNEL);
GFP_KERNEL 1252 net/mac80211/mlme.c ifsta->assocresp_ies = kmalloc(ifsta->assocresp_ies_len, GFP_KERNEL);
GFP_KERNEL 1782 net/mac80211/mlme.c skb = skb_copy(ifsta->probe_resp, GFP_KERNEL);
GFP_KERNEL 2504 net/mac80211/mlme.c ifsta->extra_ie = kmalloc(len, GFP_KERNEL);
GFP_KERNEL 47 net/mac80211/rate.c alg = kzalloc(sizeof(*alg), GFP_KERNEL);
GFP_KERNEL 154 net/mac80211/rate.c ref = kmalloc(sizeof(struct rate_control_ref), GFP_KERNEL);
GFP_KERNEL 69 net/mac80211/rc80211_minstrel_debugfs.c ms = kmalloc(sizeof(*ms), GFP_KERNEL);
GFP_KERNEL 91 net/mac80211/rc80211_pid_debugfs.c file_info = kmalloc(sizeof(*file_info), GFP_KERNEL);
GFP_KERNEL 78 net/netfilter/ipvs/ip_vs_app.c inc = kmemdup(app, sizeof(*inc), GFP_KERNEL);
GFP_KERNEL 3189 net/netfilter/ipvs/ip_vs_ctl.c msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
GFP_KERNEL 864 net/netfilter/ipvs/ip_vs_sync.c buf = kmalloc(sync_recv_mesg_maxlen, GFP_KERNEL);
GFP_KERNEL 869 net/netfilter/ipvs/ip_vs_sync.c tinfo = kmalloc(sizeof(*tinfo), GFP_KERNEL);
GFP_KERNEL 71 net/netfilter/nf_conntrack_acct.c GFP_KERNEL);
GFP_KERNEL 211 net/netfilter/nf_conntrack_amanda.c GFP_KERNEL, TS_AUTOLOAD);
GFP_KERNEL 1069 net/netfilter/nf_conntrack_core.c hash = (void*)__get_free_pages(GFP_KERNEL|__GFP_NOWARN,
GFP_KERNEL 551 net/netfilter/nf_conntrack_ftp.c ftp_buffer = kmalloc(65536, GFP_KERNEL);
GFP_KERNEL 1781 net/netfilter/nf_conntrack_h323_main.c h323_buffer = kmalloc(65536, GFP_KERNEL);
GFP_KERNEL 243 net/netfilter/nf_conntrack_irc.c irc_buffer = kmalloc(65536, GFP_KERNEL);
GFP_KERNEL 857 net/netfilter/nf_conntrack_netlink.c skb2 = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
GFP_KERNEL 1128 net/netfilter/nf_conntrack_netlink.c ct = nf_conntrack_alloc(&init_net, otuple, rtuple, GFP_KERNEL);
GFP_KERNEL 1168 net/netfilter/nf_conntrack_netlink.c nf_ct_acct_ext_add(ct, GFP_KERNEL);
GFP_KERNEL 1546 net/netfilter/nf_conntrack_netlink.c skb2 = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
GFP_KERNEL 292 net/netfilter/nf_conntrack_proto.c GFP_KERNEL);
GFP_KERNEL 306 net/netfilter/nf_conntrack_proto_gre.c net_gre = kmalloc(sizeof(struct netns_proto_gre), GFP_KERNEL);
GFP_KERNEL 193 net/netfilter/nf_conntrack_sane.c sane_buffer = kmalloc(65536, GFP_KERNEL);
GFP_KERNEL 418 net/netfilter/nf_conntrack_standalone.c GFP_KERNEL);
GFP_KERNEL 368 net/netfilter/x_tables.c tmp = kmalloc(sizeof(struct compat_delta), GFP_KERNEL);
GFP_KERNEL 581 net/netfilter/x_tables.c newinfo = kzalloc(XT_TABLE_INFO_SZ, GFP_KERNEL);
GFP_KERNEL 590 net/netfilter/x_tables.c GFP_KERNEL,
GFP_KERNEL 694 net/netfilter/x_tables.c table = kmemdup(table, sizeof(struct xt_table), GFP_KERNEL);
GFP_KERNEL 1043 net/netfilter/x_tables.c xt = kmalloc(sizeof(struct xt_af) * NFPROTO_NUMPROTO, GFP_KERNEL);
GFP_KERNEL 112 net/netfilter/xt_RATEEST.c est = kzalloc(sizeof(*est), GFP_KERNEL);
GFP_KERNEL 236 net/netfilter/xt_connlimit.c info->data = kmalloc(sizeof(struct xt_connlimit_data), GFP_KERNEL);
GFP_KERNEL 161 net/netfilter/xt_dccp.c dccp_optbuf = kmalloc(256 * 4, GFP_KERNEL);
GFP_KERNEL 312 net/netfilter/xt_recent.c GFP_KERNEL);
GFP_KERNEL 64 net/netfilter/xt_string.c GFP_KERNEL, flags);
GFP_KERNEL 159 net/netlabel/netlabel_cipso_v4.c doi_def = kmalloc(sizeof(*doi_def), GFP_KERNEL);
GFP_KERNEL 162 net/netlabel/netlabel_cipso_v4.c doi_def->map.std = kzalloc(sizeof(*doi_def->map.std), GFP_KERNEL);
GFP_KERNEL 206 net/netlabel/netlabel_cipso_v4.c GFP_KERNEL);
GFP_KERNEL 213 net/netlabel/netlabel_cipso_v4.c GFP_KERNEL);
GFP_KERNEL 280 net/netlabel/netlabel_cipso_v4.c GFP_KERNEL);
GFP_KERNEL 288 net/netlabel/netlabel_cipso_v4.c GFP_KERNEL);
GFP_KERNEL 348 net/netlabel/netlabel_cipso_v4.c doi_def = kmalloc(sizeof(*doi_def), GFP_KERNEL);
GFP_KERNEL 385 net/netlabel/netlabel_cipso_v4.c doi_def = kmalloc(sizeof(*doi_def), GFP_KERNEL);
GFP_KERNEL 498 net/netlabel/netlabel_cipso_v4.c ans_skb = nlmsg_new(NLMSG_DEFAULT_SIZE * nlsze_mult, GFP_KERNEL);
GFP_KERNEL 265 net/netlabel/netlabel_domainhash.c hsh_tbl = kmalloc(sizeof(*hsh_tbl), GFP_KERNEL);
GFP_KERNEL 271 net/netlabel/netlabel_domainhash.c GFP_KERNEL);
GFP_KERNEL 101 net/netlabel/netlabel_mgmt.c entry = kzalloc(sizeof(*entry), GFP_KERNEL);
GFP_KERNEL 109 net/netlabel/netlabel_mgmt.c entry->domain = kmalloc(tmp_size, GFP_KERNEL);
GFP_KERNEL 145 net/netlabel/netlabel_mgmt.c addrmap = kzalloc(sizeof(*addrmap), GFP_KERNEL);
GFP_KERNEL 166 net/netlabel/netlabel_mgmt.c map = kzalloc(sizeof(*map), GFP_KERNEL);
GFP_KERNEL 192 net/netlabel/netlabel_mgmt.c addrmap = kzalloc(sizeof(*addrmap), GFP_KERNEL);
GFP_KERNEL 213 net/netlabel/netlabel_mgmt.c map = kzalloc(sizeof(*map), GFP_KERNEL);
GFP_KERNEL 567 net/netlabel/netlabel_mgmt.c ans_skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
GFP_KERNEL 683 net/netlabel/netlabel_mgmt.c ans_skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
GFP_KERNEL 934 net/netlabel/netlabel_unlabeled.c ans_skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
GFP_KERNEL 1520 net/netlabel/netlabel_unlabeled.c hsh_tbl = kmalloc(sizeof(*hsh_tbl), GFP_KERNEL);
GFP_KERNEL 1526 net/netlabel/netlabel_unlabeled.c GFP_KERNEL);
GFP_KERNEL 1631 net/netlabel/netlabel_unlabeled.c entry = kzalloc(sizeof(*entry), GFP_KERNEL);
GFP_KERNEL 402 net/netlink/af_netlink.c sk = sk_alloc(net, PF_NETLINK, GFP_KERNEL, &netlink_proto);
GFP_KERNEL 1245 net/netlink/af_netlink.c skb = alloc_skb(len, GFP_KERNEL);
GFP_KERNEL 1276 net/netlink/af_netlink.c netlink_broadcast(sk, skb, dst_pid, dst_group, GFP_KERNEL);
GFP_KERNEL 1391 net/netlink/af_netlink.c listeners = kzalloc(NLGRPSZ(groups), GFP_KERNEL);
GFP_KERNEL 1531 net/netlink/af_netlink.c skb = sock_rmalloc(sk, NLMSG_GOODSIZE, 0, GFP_KERNEL);
GFP_KERNEL 1595 net/netlink/af_netlink.c cb = kzalloc(sizeof(*cb), GFP_KERNEL);
GFP_KERNEL 1643 net/netlink/af_netlink.c skb = nlmsg_new(payload, GFP_KERNEL);
GFP_KERNEL 1954 net/netlink/af_netlink.c nl_table = kcalloc(MAX_LINKS, sizeof(*nl_table), GFP_KERNEL);
GFP_KERNEL 159 net/netlink/genetlink.c new_groups = kzalloc(nlen, GFP_KERNEL);
GFP_KERNEL 167 net/netlink/genetlink.c new_groups = krealloc(mc_groups, nlen, GFP_KERNEL);
GFP_KERNEL 364 net/netlink/genetlink.c sizeof(struct nlattr *), GFP_KERNEL);
GFP_KERNEL 638 net/netlink/genetlink.c skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
GFP_KERNEL 657 net/netlink/genetlink.c skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
GFP_KERNEL 725 net/netlink/genetlink.c genlmsg_multicast(msg, 0, GENL_ID_CTRL, GFP_KERNEL);
GFP_KERNEL 733 net/netlink/genetlink.c genlmsg_multicast(msg, 0, GENL_ID_CTRL, GFP_KERNEL);
GFP_KERNEL 1424 net/netrom/af_netrom.c dev_nr = kzalloc(nr_ndevs * sizeof(struct net_device *), GFP_KERNEL);
GFP_KERNEL 160 net/netrom/nr_route.c GFP_KERNEL);
GFP_KERNEL 438 net/netrom/nr_route.c GFP_KERNEL);
GFP_KERNEL 398 net/packet/af_packet.c skb = sock_wmalloc(sk, len + LL_RESERVED_SPACE(dev), 0, GFP_KERNEL);
GFP_KERNEL 1049 net/packet/af_packet.c sk = sk_alloc(net, PF_PACKET, GFP_KERNEL, &packet_proto);
GFP_KERNEL 1294 net/packet/af_packet.c i = kmalloc(sizeof(*i), GFP_KERNEL);
GFP_KERNEL 1757 net/packet/af_packet.c return (char *) __get_free_pages(GFP_KERNEL | __GFP_COMP | __GFP_ZERO,
GFP_KERNEL 1767 net/packet/af_packet.c pg_vec = kzalloc(block_nr * sizeof(char *), GFP_KERNEL);
GFP_KERNEL 82 net/phonet/af_phonet.c sk = sk_alloc(net, PF_PHONET, GFP_KERNEL, pnp->prot);
GFP_KERNEL 129 net/phonet/pep.c GFP_KERNEL);
GFP_KERNEL 977 net/phonet/pep.c GFP_KERNEL);
GFP_KERNEL 41 net/phonet/pn_netlink.c nla_total_size(1), GFP_KERNEL);
GFP_KERNEL 51 net/phonet/pn_netlink.c RTNLGRP_PHONET_IFADDR, NULL, GFP_KERNEL);
GFP_KERNEL 169 net/rfkill/rfkill-input.c handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);
GFP_KERNEL 675 net/rfkill/rfkill.c rfkill = kzalloc(sizeof(struct rfkill), GFP_KERNEL);
GFP_KERNEL 1568 net/rose/af_rose.c dev_rose = kzalloc(rose_ndevs * sizeof(struct net_device *), GFP_KERNEL);
GFP_KERNEL 110 net/rose/rose_route.c if ((rose_neigh->digipeat = kmalloc(sizeof(ax25_digi), GFP_KERNEL)) == NULL) {
GFP_KERNEL 367 net/rose/rose_route.c rose_loopback_neigh = kmalloc(sizeof(struct rose_neigh), GFP_KERNEL);
GFP_KERNEL 415 net/rxrpc/af_rxrpc.c GFP_KERNEL);
GFP_KERNEL 465 net/rxrpc/af_rxrpc.c m->msg_namelen, 0, GFP_KERNEL);
GFP_KERNEL 630 net/rxrpc/af_rxrpc.c sk = sk_alloc(net, PF_RXRPC, GFP_KERNEL, &rxrpc_proto);
GFP_KERNEL 136 net/rxrpc/ar-key.c upayload = kmalloc(plen, GFP_KERNEL);
GFP_KERNEL 222 net/rxrpc/ar-key.c description = kmalloc(optlen + 1, GFP_KERNEL);
GFP_KERNEL 259 net/rxrpc/ar-key.c description = kmalloc(optlen + 1, GFP_KERNEL);
GFP_KERNEL 34 net/rxrpc/ar-local.c local = kzalloc(sizeof(struct rxrpc_local), GFP_KERNEL);
GFP_KERNEL 161 net/rxrpc/ar-output.c GFP_KERNEL);
GFP_KERNEL 167 net/rxrpc/ar-output.c abort_code == 0, GFP_KERNEL);
GFP_KERNEL 219 net/sched/act_api.c struct tcf_common *p = kzalloc(size, GFP_KERNEL);
GFP_KERNEL 520 net/sched/act_api.c a = kzalloc(sizeof(*a), GFP_KERNEL);
GFP_KERNEL 665 net/sched/act_api.c skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
GFP_KERNEL 695 net/sched/act_api.c a = kzalloc(sizeof(struct tc_action), GFP_KERNEL);
GFP_KERNEL 734 net/sched/act_api.c act = kzalloc(sizeof(*act), GFP_KERNEL);
GFP_KERNEL 761 net/sched/act_api.c skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
GFP_KERNEL 856 net/sched/act_api.c skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
GFP_KERNEL 892 net/sched/act_api.c skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
GFP_KERNEL 153 net/sched/act_ipt.c tname = kmalloc(IFNAMSIZ, GFP_KERNEL);
GFP_KERNEL 160 net/sched/act_ipt.c t = kmemdup(td, td->u.target_size, GFP_KERNEL);
GFP_KERNEL 74 net/sched/act_pedit.c keys = kmalloc(ksize, GFP_KERNEL);
GFP_KERNEL 87 net/sched/act_pedit.c keys = kmalloc(ksize, GFP_KERNEL);
GFP_KERNEL 171 net/sched/act_police.c police = kzalloc(sizeof(*police), GFP_KERNEL);
GFP_KERNEL 75 net/sched/act_simple.c d->tcfd_defdata = kstrndup(defdata, SIMP_MAX_DATA, GFP_KERNEL);
GFP_KERNEL 224 net/sched/cls_api.c tp = kzalloc(sizeof(*tp), GFP_KERNEL);
GFP_KERNEL 366 net/sched/cls_api.c skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
GFP_KERNEL 86 net/sched/cls_basic.c head = kzalloc(sizeof(*head), GFP_KERNEL);
GFP_KERNEL 190 net/sched/cls_basic.c f = kzalloc(sizeof(*f), GFP_KERNEL);
GFP_KERNEL 489 net/sched/cls_flow.c f = kzalloc(sizeof(*f), GFP_KERNEL);
GFP_KERNEL 571 net/sched/cls_flow.c head = kzalloc(sizeof(*head), GFP_KERNEL);
GFP_KERNEL 269 net/sched/cls_fw.c head = kzalloc(sizeof(struct fw_head), GFP_KERNEL);
GFP_KERNEL 279 net/sched/cls_fw.c f = kzalloc(sizeof(struct fw_filter), GFP_KERNEL);
GFP_KERNEL 384 net/sched/cls_route.c b = kzalloc(sizeof(struct route4_bucket), GFP_KERNEL);
GFP_KERNEL 463 net/sched/cls_route.c head = kzalloc(sizeof(struct route4_head), GFP_KERNEL);
GFP_KERNEL 472 net/sched/cls_route.c f = kzalloc(sizeof(struct route4_filter), GFP_KERNEL);
GFP_KERNEL 243 net/sched/cls_rsvp.h data = kzalloc(sizeof(struct rsvp_head), GFP_KERNEL);
GFP_KERNEL 458 net/sched/cls_rsvp.h f = kzalloc(sizeof(struct rsvp_filter), GFP_KERNEL);
GFP_KERNEL 530 net/sched/cls_rsvp.h s = kzalloc(sizeof(struct rsvp_session), GFP_KERNEL);
GFP_KERNEL 137 net/sched/cls_tcindex.c p = kzalloc(sizeof(struct tcindex_data), GFP_KERNEL);
GFP_KERNEL 278 net/sched/cls_tcindex.c cp.perfect = kcalloc(cp.hash, sizeof(*r), GFP_KERNEL);
GFP_KERNEL 283 net/sched/cls_tcindex.c cp.h = kcalloc(cp.hash, sizeof(f), GFP_KERNEL);
GFP_KERNEL 296 net/sched/cls_tcindex.c f = kzalloc(sizeof(*f), GFP_KERNEL);
GFP_KERNEL 289 net/sched/cls_u32.c root_ht = kzalloc(sizeof(*root_ht), GFP_KERNEL);
GFP_KERNEL 299 net/sched/cls_u32.c tp_c = kzalloc(sizeof(*tp_c), GFP_KERNEL);
GFP_KERNEL 561 net/sched/cls_u32.c ht = kzalloc(sizeof(*ht) + divisor*sizeof(void*), GFP_KERNEL);
GFP_KERNEL 605 net/sched/cls_u32.c n = kzalloc(sizeof(*n) + s->nkeys*sizeof(struct tc_u32_key), GFP_KERNEL);
GFP_KERNEL 610 net/sched/cls_u32.c n->pf = kzalloc(sizeof(struct tc_u32_pcnt) + s->nkeys*sizeof(u64), GFP_KERNEL);
GFP_KERNEL 566 net/sched/em_meta.c dst->val = (unsigned long)kmemdup(nla_data(nla), len, GFP_KERNEL);
GFP_KERNEL 794 net/sched/em_meta.c meta = kzalloc(sizeof(*meta), GFP_KERNEL);
GFP_KERNEL 36 net/sched/em_nbyte.c em->data = (unsigned long)kmemdup(data, em->datalen, GFP_KERNEL);
GFP_KERNEL 68 net/sched/em_text.c conf->pattern_len, GFP_KERNEL, flags);
GFP_KERNEL 85 net/sched/em_text.c tm = kmalloc(sizeof(*tm), GFP_KERNEL);
GFP_KERNEL 266 net/sched/ematch.c void *v = kmemdup(data, data_len, GFP_KERNEL);
GFP_KERNEL 337 net/sched/ematch.c tree->matches = kzalloc(matches_len, GFP_KERNEL);
GFP_KERNEL 305 net/sched/sch_api.c rtab = kmalloc(sizeof(*rtab), GFP_KERNEL);
GFP_KERNEL 383 net/sched/sch_api.c stab = kmalloc(sizeof(*stab) + tsize * sizeof(u16), GFP_KERNEL);
GFP_KERNEL 505 net/sched/sch_api.c h = kmalloc(size, GFP_KERNEL);
GFP_KERNEL 508 net/sched/sch_api.c __get_free_pages(GFP_KERNEL, get_order(size));
GFP_KERNEL 1202 net/sched/sch_api.c skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
GFP_KERNEL 1489 net/sched/sch_api.c skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
GFP_KERNEL 292 net/sched/sch_atm.c flow = kzalloc(sizeof(struct atm_flow_data) + hdr_len, GFP_KERNEL);
GFP_KERNEL 1887 net/sched/sch_cbq.c cl = kzalloc(sizeof(*cl), GFP_KERNEL);
GFP_KERNEL 380 net/sched/sch_dsmark.c mask = kmalloc(indices * 2, GFP_KERNEL);
GFP_KERNEL 121 net/sched/sch_fifo.c nla = kmalloc(nla_attr_size(sizeof(struct tc_fifo_qopt)), GFP_KERNEL);
GFP_KERNEL 477 net/sched/sch_generic.c p = kzalloc(size, GFP_KERNEL);
GFP_KERNEL 408 net/sched/sch_gred.c table->tab[dp] = kzalloc(sizeof(*q), GFP_KERNEL);
GFP_KERNEL 1071 net/sched/sch_hfsc.c cl = kzalloc(sizeof(struct hfsc_class), GFP_KERNEL);
GFP_KERNEL 1371 net/sched/sch_htb.c if ((cl = kzalloc(sizeof(*cl), GFP_KERNEL)) == NULL)
GFP_KERNEL 267 net/sched/sch_multiq.c q->queues = kcalloc(q->max_bands, sizeof(struct Qdisc *), GFP_KERNEL);
GFP_KERNEL 336 net/sched/sch_netem.c d = kmalloc(sizeof(*d) + n*sizeof(d->table[0]), GFP_KERNEL);
GFP_KERNEL 842 net/sctp/auth.c GFP_KERNEL);
GFP_KERNEL 848 net/sctp/auth.c key = sctp_auth_create_key(auth_key->sca_keylength, GFP_KERNEL);
GFP_KERNEL 900 net/sctp/auth.c sctp_auth_asoc_init_active_key(asoc, GFP_KERNEL);
GFP_KERNEL 166 net/sctp/chunk.c msg = sctp_datamsg_new(GFP_KERNEL);
GFP_KERNEL 159 net/sctp/endpointola.c null_key = sctp_auth_shkey_create(0, GFP_KERNEL);
GFP_KERNEL 644 net/sctp/ipv6.c newsk = sk_alloc(sock_net(sk), PF_INET6, GFP_KERNEL, sk->sk_prot);
GFP_KERNEL 72 net/sctp/primitive.c arg, GFP_KERNEL); \
GFP_KERNEL 590 net/sctp/protocol.c struct sock *newsk = sk_alloc(sock_net(sk), PF_INET, GFP_KERNEL,
GFP_KERNEL 1238 net/sctp/protocol.c kmalloc(64 * sizeof(struct sctp_hashbucket), GFP_KERNEL);
GFP_KERNEL 944 net/sctp/sm_make_chunk.c payload = kmalloc(paylen, GFP_KERNEL);
GFP_KERNEL 906 net/sctp/socket.c kaddrs = kmalloc(addrs_size, GFP_KERNEL);
GFP_KERNEL 1078 net/sctp/socket.c asoc = sctp_association_new(ep, sk, scope, GFP_KERNEL);
GFP_KERNEL 1086 net/sctp/socket.c transport = sctp_assoc_add_peer(asoc, &to, GFP_KERNEL,
GFP_KERNEL 1098 net/sctp/socket.c err = sctp_assoc_set_bind_addr_from_ep(asoc, GFP_KERNEL);
GFP_KERNEL 1220 net/sctp/socket.c kaddrs = kmalloc(addrs_size, GFP_KERNEL);
GFP_KERNEL 1648 net/sctp/socket.c new_asoc = sctp_association_new(ep, sk, scope, GFP_KERNEL);
GFP_KERNEL 1678 net/sctp/socket.c transport = sctp_assoc_add_peer(asoc, &to, GFP_KERNEL, SCTP_UNKNOWN);
GFP_KERNEL 1683 net/sctp/socket.c err = sctp_assoc_set_bind_addr_from_ep(asoc, GFP_KERNEL);
GFP_KERNEL 3098 net/sctp/socket.c hmacs = kmalloc(optlen, GFP_KERNEL);
GFP_KERNEL 3140 net/sctp/socket.c authkey = kmalloc(optlen, GFP_KERNEL);
GFP_KERNEL 3608 net/sctp/socket.c ep = sctp_endpoint_new(sk, GFP_KERNEL);
GFP_KERNEL 4595 net/sctp/socket.c GFP_KERNEL);
GFP_KERNEL 4688 net/sctp/socket.c addrs = kmalloc(space_left, GFP_KERNEL);
GFP_KERNEL 6607 net/sctp/socket.c &oldsp->ep->base.bind_addr, GFP_KERNEL);
GFP_KERNEL 247 net/socket.c ei = kmem_cache_alloc(sock_inode_cachep, GFP_KERNEL);
GFP_KERNEL 717 net/socket.c siocb = kmalloc(sizeof(*siocb), GFP_KERNEL);
GFP_KERNEL 1020 net/socket.c fna = kmalloc(sizeof(struct fasync_struct), GFP_KERNEL);
GFP_KERNEL 1919 net/socket.c iov = sock_kmalloc(sock->sk, iov_size, GFP_KERNEL);
GFP_KERNEL 1952 net/socket.c ctl_buf = sock_kmalloc(sock->sk, ctl_len, GFP_KERNEL);
GFP_KERNEL 2028 net/socket.c iov = sock_kmalloc(sock->sk, iov_size, GFP_KERNEL);
GFP_KERNEL 149 net/sunrpc/auth.c new = kmalloc(sizeof(*new), GFP_KERNEL);
GFP_KERNEL 85 net/sunrpc/auth_generic.c gcred = kmalloc(sizeof(*gcred), GFP_KERNEL);
GFP_KERNEL 605 net/sunrpc/auth_gss/auth_gss.c if (!(gss_auth = kmalloc(sizeof(*gss_auth), GFP_KERNEL)))
GFP_KERNEL 74 net/sunrpc/auth_gss/gss_mech_switch.c new = kmalloc(strlen(name) + strlen(prefix) + 1, GFP_KERNEL);
GFP_KERNEL 254 net/sunrpc/auth_gss/gss_mech_switch.c if (!(*ctx_id = kzalloc(sizeof(**ctx_id), GFP_KERNEL)))
GFP_KERNEL 115 net/sunrpc/auth_gss/svcauth_gss.c dst->data = (len ? kmemdup(src, len, GFP_KERNEL) : NULL);
GFP_KERNEL 166 net/sunrpc/auth_gss/svcauth_gss.c struct rsi *rsii = kmalloc(sizeof(*rsii), GFP_KERNEL);
GFP_KERNEL 405 net/sunrpc/auth_gss/svcauth_gss.c struct rsc *rsci = kmalloc(sizeof(*rsci), GFP_KERNEL);
GFP_KERNEL 758 net/sunrpc/auth_gss/svcauth_gss.c new = kmalloc(sizeof(*new), GFP_KERNEL);
GFP_KERNEL 762 net/sunrpc/auth_gss/svcauth_gss.c new->h.name = kstrdup(name, GFP_KERNEL);
GFP_KERNEL 823 net/sunrpc/auth_gss/svcauth_gss.c mic.data = kmalloc(mic.len, GFP_KERNEL);
GFP_KERNEL 1063 net/sunrpc/auth_gss/svcauth_gss.c svcdata = kmalloc(sizeof(*svcdata), GFP_KERNEL);
GFP_KERNEL 868 net/sunrpc/cache.c rp = kmalloc(sizeof(*rp), GFP_KERNEL);
GFP_KERNEL 1052 net/sunrpc/cache.c buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
GFP_KERNEL 1056 net/sunrpc/cache.c crq = kmalloc(sizeof (*crq), GFP_KERNEL);
GFP_KERNEL 158 net/sunrpc/clnt.c clnt = kzalloc(sizeof(*clnt), GFP_KERNEL);
GFP_KERNEL 165 net/sunrpc/clnt.c char *buf = kmalloc(len, GFP_KERNEL);
GFP_KERNEL 345 net/sunrpc/clnt.c new = kmemdup(clnt, sizeof(*new), GFP_KERNEL);
GFP_KERNEL 156 net/sunrpc/rpc_pipe.c rpci = (struct rpc_inode *)kmem_cache_alloc(rpc_inode_cachep, GFP_KERNEL);
GFP_KERNEL 119 net/sunrpc/stats.c new = kcalloc(clnt->cl_maxproc, sizeof(struct rpc_iostats), GFP_KERNEL);
GFP_KERNEL 157 net/sunrpc/svc.c m->to_pool = kcalloc(maxpools, sizeof(unsigned int), GFP_KERNEL);
GFP_KERNEL 160 net/sunrpc/svc.c m->pool_to = kcalloc(maxpools, sizeof(unsigned int), GFP_KERNEL);
GFP_KERNEL 369 net/sunrpc/svc.c if (!(serv = kzalloc(sizeof(*serv), GFP_KERNEL)))
GFP_KERNEL 403 net/sunrpc/svc.c GFP_KERNEL);
GFP_KERNEL 512 net/sunrpc/svc.c struct page *p = alloc_page(GFP_KERNEL);
GFP_KERNEL 539 net/sunrpc/svc.c rqstp = kzalloc(sizeof(*rqstp), GFP_KERNEL);
GFP_KERNEL 553 net/sunrpc/svc.c rqstp->rq_argp = kmalloc(serv->sv_xdrsize, GFP_KERNEL);
GFP_KERNEL 557 net/sunrpc/svc.c rqstp->rq_resp = kmalloc(serv->sv_xdrsize, GFP_KERNEL);
GFP_KERNEL 592 net/sunrpc/svc_xprt.c struct page *p = alloc_page(GFP_KERNEL);
GFP_KERNEL 944 net/sunrpc/svc_xprt.c dr = kmalloc(size, GFP_KERNEL);
GFP_KERNEL 53 net/sunrpc/svcauth_unix.c new = kmalloc(sizeof(*new), GFP_KERNEL);
GFP_KERNEL 57 net/sunrpc/svcauth_unix.c new->h.name = kstrdup(name, GFP_KERNEL);
GFP_KERNEL 150 net/sunrpc/svcauth_unix.c struct ip_map *i = kmalloc(sizeof(*i), GFP_KERNEL);
GFP_KERNEL 517 net/sunrpc/svcauth_unix.c struct unix_gid *g = kmalloc(sizeof(*g), GFP_KERNEL);
GFP_KERNEL 1120 net/sunrpc/svcsock.c if (!(svsk = kzalloc(sizeof(*svsk), GFP_KERNEL))) {
GFP_KERNEL 869 net/sunrpc/xdr.c elem = kmalloc(desc->elem_size, GFP_KERNEL);
GFP_KERNEL 908 net/sunrpc/xdr.c GFP_KERNEL);
GFP_KERNEL 948 net/sunrpc/xdr.c GFP_KERNEL);
GFP_KERNEL 95 net/sunrpc/xprtrdma/svc_rdma_transport.c ctxt = kmem_cache_alloc(svc_rdma_ctxt_cachep, GFP_KERNEL);
GFP_KERNEL 156 net/sunrpc/xprtrdma/svc_rdma_transport.c map = kmem_cache_alloc(svc_rdma_map_cachep, GFP_KERNEL);
GFP_KERNEL 443 net/sunrpc/xprtrdma/svc_rdma_transport.c struct svcxprt_rdma *cma_xprt = kzalloc(sizeof *cma_xprt, GFP_KERNEL);
GFP_KERNEL 477 net/sunrpc/xprtrdma/svc_rdma_transport.c while ((page = alloc_page(GFP_KERNEL)) == NULL) {
GFP_KERNEL 727 net/sunrpc/xprtrdma/svc_rdma_transport.c frmr = kmalloc(sizeof(*frmr), GFP_KERNEL);
GFP_KERNEL 170 net/sunrpc/xprtrdma/transport.c buf = kzalloc(20, GFP_KERNEL);
GFP_KERNEL 175 net/sunrpc/xprtrdma/transport.c buf = kzalloc(8, GFP_KERNEL);
GFP_KERNEL 182 net/sunrpc/xprtrdma/transport.c buf = kzalloc(48, GFP_KERNEL);
GFP_KERNEL 189 net/sunrpc/xprtrdma/transport.c buf = kzalloc(10, GFP_KERNEL);
GFP_KERNEL 195 net/sunrpc/xprtrdma/transport.c buf = kzalloc(8, GFP_KERNEL);
GFP_KERNEL 200 net/sunrpc/xprtrdma/transport.c buf = kzalloc(30, GFP_KERNEL);
GFP_KERNEL 321 net/sunrpc/xprtrdma/transport.c xprt = kzalloc(sizeof(struct rpcrdma_xprt), GFP_KERNEL);
GFP_KERNEL 330 net/sunrpc/xprtrdma/transport.c sizeof(struct rpc_rqst), GFP_KERNEL);
GFP_KERNEL 899 net/sunrpc/xprtrdma/verbs.c p = kzalloc(len, GFP_KERNEL);
GFP_KERNEL 988 net/sunrpc/xprtrdma/verbs.c req = kmalloc(len, GFP_KERNEL);
GFP_KERNEL 1009 net/sunrpc/xprtrdma/verbs.c rep = kmalloc(len, GFP_KERNEL);
GFP_KERNEL 284 net/sunrpc/xprtsock.c buf = kzalloc(20, GFP_KERNEL);
GFP_KERNEL 291 net/sunrpc/xprtsock.c buf = kzalloc(8, GFP_KERNEL);
GFP_KERNEL 300 net/sunrpc/xprtsock.c buf = kzalloc(48, GFP_KERNEL);
GFP_KERNEL 309 net/sunrpc/xprtsock.c buf = kzalloc(10, GFP_KERNEL);
GFP_KERNEL 316 net/sunrpc/xprtsock.c buf = kzalloc(8, GFP_KERNEL);
GFP_KERNEL 323 net/sunrpc/xprtsock.c buf = kzalloc(30, GFP_KERNEL);
GFP_KERNEL 342 net/sunrpc/xprtsock.c buf = kzalloc(40, GFP_KERNEL);
GFP_KERNEL 349 net/sunrpc/xprtsock.c buf = kzalloc(8, GFP_KERNEL);
GFP_KERNEL 358 net/sunrpc/xprtsock.c buf = kzalloc(64, GFP_KERNEL);
GFP_KERNEL 367 net/sunrpc/xprtsock.c buf = kzalloc(36, GFP_KERNEL);
GFP_KERNEL 374 net/sunrpc/xprtsock.c buf = kzalloc(8, GFP_KERNEL);
GFP_KERNEL 381 net/sunrpc/xprtsock.c buf = kzalloc(50, GFP_KERNEL);
GFP_KERNEL 1883 net/sunrpc/xprtsock.c new = kzalloc(sizeof(*new), GFP_KERNEL);
GFP_KERNEL 1892 net/sunrpc/xprtsock.c xprt->slot = kcalloc(xprt->max_reqs, sizeof(struct rpc_rqst), GFP_KERNEL);
GFP_KERNEL 114 net/tipc/ref.c GFP_KERNEL | __GFP_HIGHMEM | __GFP_ZERO, PAGE_KERNEL);
GFP_KERNEL 222 net/tipc/socket.c sk = sk_alloc(net, AF_TIPC, GFP_KERNEL, &tipc_proto);
GFP_KERNEL 591 net/unix/af_unix.c sk = sk_alloc(net, PF_UNIX, GFP_KERNEL, &unix_proto);
GFP_KERNEL 675 net/unix/af_unix.c addr = kzalloc(sizeof(*addr) + sizeof(short) + 16, GFP_KERNEL);
GFP_KERNEL 797 net/unix/af_unix.c addr = kmalloc(sizeof(*addr)+addr_len, GFP_KERNEL);
GFP_KERNEL 1041 net/unix/af_unix.c skb = sock_wmalloc(newsk, 1, 0, GFP_KERNEL);
GFP_KERNEL 39 net/unix/sysctl_net_unix.c table = kmemdup(unix_table, sizeof(unix_table), GFP_KERNEL);
GFP_KERNEL 435 net/wanrouter/wanmain.c conf = kmalloc(sizeof(wandev_conf_t), GFP_KERNEL);
GFP_KERNEL 574 net/wanrouter/wanmain.c cnf = kmalloc(sizeof(wanif_conf_t), GFP_KERNEL);
GFP_KERNEL 592 net/wanrouter/wanmain.c dev = kzalloc(sizeof(struct net_device), GFP_KERNEL);
GFP_KERNEL 217 net/wireless/core.c drv = kzalloc(alloc_size, GFP_KERNEL);
GFP_KERNEL 254 net/wireless/nl80211.c msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
GFP_KERNEL 365 net/wireless/nl80211.c msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
GFP_KERNEL 611 net/wireless/nl80211.c msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
GFP_KERNEL 1100 net/wireless/nl80211.c msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
GFP_KERNEL 1459 net/wireless/nl80211.c msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
GFP_KERNEL 1718 net/wireless/nl80211.c rd = kzalloc(size_of_regd, GFP_KERNEL);
GFP_KERNEL 1918 net/wireless/nl80211.c msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
GFP_KERNEL 1927 net/wireless/nl80211.c genlmsg_multicast(msg, 0, nl80211_config_mcgrp.id, GFP_KERNEL);
GFP_KERNEL 604 net/wireless/reg.c GFP_KERNEL);
GFP_KERNEL 777 net/wireless/wext.c extra = kzalloc(extra_size, GFP_KERNEL);
GFP_KERNEL 950 net/wireless/wext.c extra = kmalloc(extra_size, GFP_KERNEL);
GFP_KERNEL 20 net/xfrm/xfrm_hash.c n = kzalloc(sz, GFP_KERNEL);
GFP_KERNEL 22 net/xfrm/xfrm_hash.c n = __vmalloc(sz, GFP_KERNEL | __GFP_ZERO, PAGE_KERNEL);
GFP_KERNEL 25 net/xfrm/xfrm_hash.c __get_free_pages(GFP_KERNEL | __GFP_NOWARN | __GFP_ZERO,
GFP_KERNEL 292 net/xfrm/xfrm_ipcomp.c pos = kmalloc(sizeof(*pos), GFP_KERNEL);
GFP_KERNEL 353 net/xfrm/xfrm_ipcomp.c ipcd = kzalloc(sizeof(*ipcd), GFP_KERNEL);
GFP_KERNEL 1163 net/xfrm/xfrm_state.c x->encap = kmemdup(orig->encap, sizeof(*x->encap), GFP_KERNEL);
GFP_KERNEL 1170 net/xfrm/xfrm_state.c GFP_KERNEL);
GFP_KERNEL 1867 net/xfrm/xfrm_state.c data = kmalloc(optlen, GFP_KERNEL);
GFP_KERNEL 223 net/xfrm/xfrm_user.c p = kmemdup(ualg, xfrm_alg_len(ualg), GFP_KERNEL);
GFP_KERNEL 248 net/xfrm/xfrm_user.c p = kmemdup(ualg, aead_len(ualg), GFP_KERNEL);
GFP_KERNEL 349 net/xfrm/xfrm_user.c sizeof(*x->encap), GFP_KERNEL);
GFP_KERNEL 356 net/xfrm/xfrm_user.c sizeof(*x->coaddr), GFP_KERNEL);
GFP_KERNEL 1083 net/xfrm/xfrm_user.c struct xfrm_policy *xp = xfrm_policy_alloc(GFP_KERNEL);
GFP_KERNEL 1294 net/xfrm/xfrm_user.c skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
GFP_KERNEL 2294 net/xfrm/xfrm_user.c xp = xfrm_policy_alloc(GFP_KERNEL);
GFP_KERNEL 112 samples/firmware_class/firmware_sample_firmware_class.c fw_priv = kzalloc(sizeof(struct firmware_priv), GFP_KERNEL);
GFP_KERNEL 182 samples/firmware_class/firmware_sample_firmware_class.c class_dev = kmalloc(sizeof(struct class_device), GFP_KERNEL);
GFP_KERNEL 196 samples/kobject/kset-example.c foo = kzalloc(sizeof(*foo), GFP_KERNEL);
GFP_KERNEL 87 security/device_cgroup.c new = kmalloc(sizeof(*wh), GFP_KERNEL);
GFP_KERNEL 117 security/device_cgroup.c whcopy = kmalloc(sizeof(*whcopy), GFP_KERNEL);
GFP_KERNEL 190 security/device_cgroup.c dev_cgroup = kzalloc(sizeof(*dev_cgroup), GFP_KERNEL);
GFP_KERNEL 198 security/device_cgroup.c wh = kmalloc(sizeof(*wh), GFP_KERNEL);
GFP_KERNEL 93 security/keys/key.c candidate = kmalloc(sizeof(struct key_user), GFP_KERNEL);
GFP_KERNEL 263 security/keys/key.c key = kmem_cache_alloc(key_jar, GFP_KERNEL);
GFP_KERNEL 268 security/keys/key.c key->description = kmemdup(desc, desclen, GFP_KERNEL);
GFP_KERNEL 90 security/keys/keyctl.c payload = kmalloc(plen, GFP_KERNEL);
GFP_KERNEL 301 security/keys/keyctl.c payload = kmalloc(plen, GFP_KERNEL);
GFP_KERNEL 489 security/keys/keyctl.c tmpbuf = kmalloc(PAGE_SIZE, GFP_KERNEL);
GFP_KERNEL 869 security/keys/keyctl.c payload = kmalloc(plen, GFP_KERNEL);
GFP_KERNEL 733 security/keys/keyring.c nklist = kmemdup(klist, size, GFP_KERNEL);
GFP_KERNEL 787 security/keys/keyring.c nklist = kmalloc(size, GFP_KERNEL);
GFP_KERNEL 881 security/keys/keyring.c GFP_KERNEL);
GFP_KERNEL 175 security/keys/request_key.c cons = kmalloc(sizeof(*cons), GFP_KERNEL);
GFP_KERNEL 152 security/keys/request_key_auth.c rka = kmalloc(sizeof(*rka), GFP_KERNEL);
GFP_KERNEL 157 security/keys/request_key_auth.c rka->callout_info = kmalloc(callout_len, GFP_KERNEL);
GFP_KERNEL 56 security/keys/user_defined.c upayload = kmalloc(sizeof(*upayload) + datalen, GFP_KERNEL);
GFP_KERNEL 103 security/keys/user_defined.c upayload = kmalloc(sizeof(*upayload) + datalen, GFP_KERNEL);
GFP_KERNEL 244 security/selinux/avc.c audit_log(current->audit_context, GFP_KERNEL, AUDIT_KERNEL, "AVC INITIALIZED\n");
GFP_KERNEL 164 security/selinux/hooks.c tsec = kzalloc(sizeof(struct task_security_struct), GFP_KERNEL);
GFP_KERNEL 220 security/selinux/hooks.c fsec = kzalloc(sizeof(struct file_security_struct), GFP_KERNEL);
GFP_KERNEL 242 security/selinux/hooks.c sbsec = kzalloc(sizeof(struct superblock_security_struct), GFP_KERNEL);
GFP_KERNEL 1125 security/selinux/hooks.c buffer = (char *)__get_free_page(GFP_KERNEL);
GFP_KERNEL 1820 security/selinux/hooks.c buffer = (char *)__get_free_page(GFP_KERNEL);
GFP_KERNEL 1996 security/selinux/hooks.c bsec = kzalloc(sizeof(struct bprm_security_struct), GFP_KERNEL);
GFP_KERNEL 2409 security/selinux/hooks.c nosec = (char *)get_zeroed_page(GFP_KERNEL);
GFP_KERNEL 4389 security/selinux/hooks.c audit_log(current->audit_context, GFP_KERNEL, AUDIT_SELINUX_ERR,
GFP_KERNEL 4772 security/selinux/hooks.c isec = kzalloc(sizeof(struct ipc_security_struct), GFP_KERNEL);
GFP_KERNEL 4794 security/selinux/hooks.c msec = kzalloc(sizeof(struct msg_security_struct), GFP_KERNEL);
GFP_KERNEL 5413 security/selinux/hooks.c ksec = kzalloc(sizeof(struct key_security_struct), GFP_KERNEL);
GFP_KERNEL 163 security/selinux/selinuxfs.c page = (char *)get_zeroed_page(GFP_KERNEL);
GFP_KERNEL 178 security/selinux/selinuxfs.c audit_log(current->audit_context, GFP_KERNEL, AUDIT_MAC_STATUS,
GFP_KERNEL 235 security/selinux/selinuxfs.c page = (char *)get_zeroed_page(GFP_KERNEL);
GFP_KERNEL 250 security/selinux/selinuxfs.c audit_log(current->audit_context, GFP_KERNEL, AUDIT_MAC_STATUS,
GFP_KERNEL 359 security/selinux/selinuxfs.c audit_log(current->audit_context, GFP_KERNEL, AUDIT_MAC_POLICY_LOAD,
GFP_KERNEL 432 security/selinux/selinuxfs.c page = (char *)get_zeroed_page(GFP_KERNEL);
GFP_KERNEL 481 security/selinux/selinuxfs.c page = (char *)get_zeroed_page(GFP_KERNEL);
GFP_KERNEL 568 security/selinux/selinuxfs.c scon = kzalloc(size+1, GFP_KERNEL);
GFP_KERNEL 572 security/selinux/selinuxfs.c tcon = kzalloc(size+1, GFP_KERNEL);
GFP_KERNEL 617 security/selinux/selinuxfs.c scon = kzalloc(size+1, GFP_KERNEL);
GFP_KERNEL 621 security/selinux/selinuxfs.c tcon = kzalloc(size+1, GFP_KERNEL);
GFP_KERNEL 676 security/selinux/selinuxfs.c scon = kzalloc(size+1, GFP_KERNEL);
GFP_KERNEL 680 security/selinux/selinuxfs.c tcon = kzalloc(size+1, GFP_KERNEL);
GFP_KERNEL 733 security/selinux/selinuxfs.c con = kzalloc(size+1, GFP_KERNEL);
GFP_KERNEL 737 security/selinux/selinuxfs.c user = kzalloc(size+1, GFP_KERNEL);
GFP_KERNEL 794 security/selinux/selinuxfs.c scon = kzalloc(size+1, GFP_KERNEL);
GFP_KERNEL 798 security/selinux/selinuxfs.c tcon = kzalloc(size+1, GFP_KERNEL);
GFP_KERNEL 874 security/selinux/selinuxfs.c page = (char *)get_zeroed_page(GFP_KERNEL);
GFP_KERNEL 926 security/selinux/selinuxfs.c page = (char *)get_zeroed_page(GFP_KERNEL);
GFP_KERNEL 980 security/selinux/selinuxfs.c page = (char *)get_zeroed_page(GFP_KERNEL);
GFP_KERNEL 1057 security/selinux/selinuxfs.c page = (char *)get_zeroed_page(GFP_KERNEL);
GFP_KERNEL 1147 security/selinux/selinuxfs.c page = (char *)get_zeroed_page(GFP_KERNEL);
GFP_KERNEL 1182 security/selinux/selinuxfs.c page = (char *)__get_free_page(GFP_KERNEL);
GFP_KERNEL 1386 security/selinux/selinuxfs.c page = (char *)__get_free_page(GFP_KERNEL);
GFP_KERNEL 1410 security/selinux/selinuxfs.c page = (char *)__get_free_page(GFP_KERNEL);
GFP_KERNEL 40 security/selinux/ss/avtab.c newnode = kmem_cache_zalloc(avtab_node_cachep, GFP_KERNEL);
GFP_KERNEL 273 security/selinux/ss/avtab.c h->htable = kcalloc(nslot, sizeof(*(h->htable)), GFP_KERNEL);
GFP_KERNEL 175 security/selinux/ss/conditional.c kmalloc(p->p_bools.nprim * sizeof(struct cond_bool_datum *), GFP_KERNEL);
GFP_KERNEL 220 security/selinux/ss/conditional.c booldatum = kzalloc(sizeof(struct cond_bool_datum), GFP_KERNEL);
GFP_KERNEL 236 security/selinux/ss/conditional.c key = kmalloc(len + 1, GFP_KERNEL);
GFP_KERNEL 319 security/selinux/ss/conditional.c list = kzalloc(sizeof(struct cond_av_list), GFP_KERNEL);
GFP_KERNEL 411 security/selinux/ss/conditional.c expr = kzalloc(sizeof(struct cond_expr), GFP_KERNEL);
GFP_KERNEL 458 security/selinux/ss/conditional.c node = kzalloc(sizeof(struct cond_node), GFP_KERNEL);
GFP_KERNEL 405 security/selinux/ss/ebitmap.c tmp = kzalloc(sizeof(*tmp), GFP_KERNEL);
GFP_KERNEL 18 security/selinux/ss/hashtab.c p = kzalloc(sizeof(*p), GFP_KERNEL);
GFP_KERNEL 26 security/selinux/ss/hashtab.c p->htable = kmalloc(sizeof(*(p->htable)) * size, GFP_KERNEL);
GFP_KERNEL 57 security/selinux/ss/hashtab.c newnode = kzalloc(sizeof(*newnode), GFP_KERNEL);
GFP_KERNEL 151 security/selinux/ss/policydb.c role = kzalloc(sizeof(*role), GFP_KERNEL);
GFP_KERNEL 161 security/selinux/ss/policydb.c key = kmalloc(strlen(OBJECT_R)+1, GFP_KERNEL);
GFP_KERNEL 367 security/selinux/ss/policydb.c kmalloc(p->p_commons.nprim * sizeof(char *), GFP_KERNEL);
GFP_KERNEL 378 security/selinux/ss/policydb.c kmalloc(p->p_classes.nprim * sizeof(*(p->class_val_to_struct)), GFP_KERNEL);
GFP_KERNEL 385 security/selinux/ss/policydb.c kmalloc(p->p_classes.nprim * sizeof(char *), GFP_KERNEL);
GFP_KERNEL 440 security/selinux/ss/policydb.c GFP_KERNEL);
GFP_KERNEL 448 security/selinux/ss/policydb.c GFP_KERNEL);
GFP_KERNEL 456 security/selinux/ss/policydb.c GFP_KERNEL);
GFP_KERNEL 469 security/selinux/ss/policydb.c kmalloc(p->symtab[i].nprim * sizeof(char *), GFP_KERNEL);
GFP_KERNEL 936 security/selinux/ss/policydb.c perdatum = kzalloc(sizeof(*perdatum), GFP_KERNEL);
GFP_KERNEL 949 security/selinux/ss/policydb.c key = kmalloc(len + 1, GFP_KERNEL);
GFP_KERNEL 977 security/selinux/ss/policydb.c comdatum = kzalloc(sizeof(*comdatum), GFP_KERNEL);
GFP_KERNEL 996 security/selinux/ss/policydb.c key = kmalloc(len + 1, GFP_KERNEL);
GFP_KERNEL 1033 security/selinux/ss/policydb.c c = kzalloc(sizeof(*c), GFP_KERNEL);
GFP_KERNEL 1050 security/selinux/ss/policydb.c e = kzalloc(sizeof(*e), GFP_KERNEL);
GFP_KERNEL 1112 security/selinux/ss/policydb.c cladatum = kzalloc(sizeof(*cladatum), GFP_KERNEL);
GFP_KERNEL 1134 security/selinux/ss/policydb.c key = kmalloc(len + 1, GFP_KERNEL);
GFP_KERNEL 1145 security/selinux/ss/policydb.c cladatum->comkey = kmalloc(len2 + 1, GFP_KERNEL);
GFP_KERNEL 1205 security/selinux/ss/policydb.c role = kzalloc(sizeof(*role), GFP_KERNEL);
GFP_KERNEL 1223 security/selinux/ss/policydb.c key = kmalloc(len + 1, GFP_KERNEL);
GFP_KERNEL 1270 security/selinux/ss/policydb.c typdatum = kzalloc(sizeof(*typdatum), GFP_KERNEL);
GFP_KERNEL 1298 security/selinux/ss/policydb.c key = kmalloc(len + 1, GFP_KERNEL);
GFP_KERNEL 1357 security/selinux/ss/policydb.c usrdatum = kzalloc(sizeof(*usrdatum), GFP_KERNEL);
GFP_KERNEL 1375 security/selinux/ss/policydb.c key = kmalloc(len + 1, GFP_KERNEL);
GFP_KERNEL 1686 security/selinux/ss/policydb.c policydb_str = kmalloc(len + 1, GFP_KERNEL);
GFP_KERNEL 1804 security/selinux/ss/policydb.c tr = kzalloc(sizeof(*tr), GFP_KERNEL);
GFP_KERNEL 1834 security/selinux/ss/policydb.c ra = kzalloc(sizeof(*ra), GFP_KERNEL);
GFP_KERNEL 1871 security/selinux/ss/policydb.c c = kzalloc(sizeof(*c), GFP_KERNEL);
GFP_KERNEL 1898 security/selinux/ss/policydb.c c->u.name = kmalloc(len + 1, GFP_KERNEL);
GFP_KERNEL 1943 security/selinux/ss/policydb.c c->u.name = kmalloc(len + 1, GFP_KERNEL);
GFP_KERNEL 1985 security/selinux/ss/policydb.c newgenfs = kzalloc(sizeof(*newgenfs), GFP_KERNEL);
GFP_KERNEL 1991 security/selinux/ss/policydb.c newgenfs->fstype = kmalloc(len + 1, GFP_KERNEL);
GFP_KERNEL 2031 security/selinux/ss/policydb.c newc = kzalloc(sizeof(*newc), GFP_KERNEL);
GFP_KERNEL 2037 security/selinux/ss/policydb.c newc->u.name = kmalloc(len + 1, GFP_KERNEL);
GFP_KERNEL 2084 security/selinux/ss/policydb.c rt = kzalloc(sizeof(*rt), GFP_KERNEL);
GFP_KERNEL 2122 security/selinux/ss/policydb.c p->type_attr_map = kmalloc(p->p_types.nprim*sizeof(struct ebitmap), GFP_KERNEL);
GFP_KERNEL 1064 security/selinux/ss/services.c sid, SECSID_NULL, GFP_KERNEL, 0);
GFP_KERNEL 1096 security/selinux/ss/services.c sid, SECSID_NULL, GFP_KERNEL, 1);
GFP_KERNEL 1348 security/selinux/ss/services.c p->undefined_perms = kcalloc(num_classes, sizeof(u32), GFP_KERNEL);
GFP_KERNEL 1526 security/selinux/ss/services.c s = kstrdup(c->str, GFP_KERNEL);
GFP_KERNEL 2010 security/selinux/ss/services.c mysids2 = kcalloc(mynel, sizeof(*mysids2), GFP_KERNEL);
GFP_KERNEL 2621 security/selinux/ss/services.c tmprule = kzalloc(sizeof(struct selinux_audit_rule), GFP_KERNEL);
GFP_KERNEL 219 security/selinux/xfrm.c GFP_KERNEL);
GFP_KERNEL 312 security/selinux/xfrm.c GFP_KERNEL);
GFP_KERNEL 226 security/smack/smack_access.c skp = kzalloc(sizeof(struct smack_known), GFP_KERNEL);
GFP_KERNEL 73 security/smack/smack_lsm.c isp = kzalloc(sizeof(struct inode_smack), GFP_KERNEL);
GFP_KERNEL 174 security/smack/smack_lsm.c sbsp = kzalloc(sizeof(struct superblock_smack), GFP_KERNEL);
GFP_KERNEL 217 security/smack/smack_lsm.c otheropts = (char *)get_zeroed_page(GFP_KERNEL);
GFP_KERNEL 410 security/smack/smack_lsm.c *name = kstrdup(XATTR_SMACK_SUFFIX, GFP_KERNEL);
GFP_KERNEL 416 security/smack/smack_lsm.c *value = kstrdup(isp, GFP_KERNEL);
GFP_KERNEL 2012 security/smack/smack_lsm.c cp = kstrdup(p->security, GFP_KERNEL);
GFP_KERNEL 2495 security/smack/smack_lsm.c audit_log(actx, GFP_KERNEL, AUDIT_SELINUX_ERR,
GFP_KERNEL 204 security/smack/smackfs.c newp = kzalloc(sizeof(struct smk_list_entry), GFP_KERNEL);
GFP_KERNEL 249 security/smack/smackfs.c data = kzalloc(count, GFP_KERNEL);
GFP_KERNEL 346 security/smack/smackfs.c doip = kmalloc(sizeof(struct cipso_v4_doi), GFP_KERNEL);
GFP_KERNEL 513 security/smack/smackfs.c data = kzalloc(count + 1, GFP_KERNEL);
GFP_KERNEL 559 security/smack/smackfs.c scp = kzalloc(sizeof(struct smack_cipso), GFP_KERNEL);
GFP_KERNEL 903 sound/aoa/codecs/snd-aoa-codec-onyx.c onyx->codec_info = kmalloc(sizeof(struct codec_info), GFP_KERNEL);
GFP_KERNEL 914 sound/aoa/codecs/snd-aoa-codec-onyx.c onyx->codec_info = kmalloc(sizeof(struct codec_info), GFP_KERNEL);
GFP_KERNEL 1008 sound/aoa/codecs/snd-aoa-codec-onyx.c onyx = kzalloc(sizeof(struct onyx), GFP_KERNEL);
GFP_KERNEL 893 sound/aoa/codecs/snd-aoa-codec-tas.c tas = kzalloc(sizeof(struct tas), GFP_KERNEL);
GFP_KERNEL 125 sound/aoa/codecs/snd-aoa-codec-toonie.c toonie = kzalloc(sizeof(struct toonie), GFP_KERNEL);
GFP_KERNEL 184 sound/aoa/core/snd-aoa-gpio-pmf.c GFP_KERNEL);
GFP_KERNEL 969 sound/aoa/fabrics/snd-aoa-fabric-layout.c ldev = kzalloc(sizeof(struct layout_dev), GFP_KERNEL);
GFP_KERNEL 23 sound/aoa/soundbus/i2sbus/i2sbus-control.c *c = kzalloc(sizeof(struct i2sbus_control), GFP_KERNEL);
GFP_KERNEL 51 sound/aoa/soundbus/i2sbus/i2sbus-core.c GFP_KERNEL);
GFP_KERNEL 177 sound/aoa/soundbus/i2sbus/i2sbus-core.c dev = kzalloc(sizeof(struct i2sbus_dev), GFP_KERNEL);
GFP_KERNEL 931 sound/aoa/soundbus/i2sbus/i2sbus-pcm.c cii = kzalloc(sizeof(struct codec_info_item), GFP_KERNEL);
GFP_KERNEL 51 sound/arm/devdma.c buf = kmalloc(sizeof(struct snd_dma_buffer), GFP_KERNEL);
GFP_KERNEL 57 sound/arm/devdma.c buf->area = dma_alloc_coherent(dev, size, &buf->addr, GFP_KERNEL);
GFP_KERNEL 197 sound/arm/pxa2xx-pcm-lib.c rtd = kmalloc(sizeof(*rtd), GFP_KERNEL);
GFP_KERNEL 202 sound/arm/pxa2xx-pcm-lib.c &rtd->dma_desc_array_phys, GFP_KERNEL);
GFP_KERNEL 248 sound/arm/pxa2xx-pcm-lib.c &buf->addr, GFP_KERNEL);
GFP_KERNEL 67 sound/core/control.c ctl = kzalloc(sizeof(*ctl), GFP_KERNEL);
GFP_KERNEL 194 sound/core/control.c kctl = kzalloc(sizeof(*kctl) + sizeof(struct snd_kcontrol_volatile) * control->count, GFP_KERNEL);
GFP_KERNEL 549 sound/core/control.c info = kzalloc(sizeof(*info), GFP_KERNEL);
GFP_KERNEL 723 sound/core/control.c control = kmalloc(sizeof(*control), GFP_KERNEL);
GFP_KERNEL 783 sound/core/control.c control = kmalloc(sizeof(*control), GFP_KERNEL);
GFP_KERNEL 915 sound/core/control.c new_data = kmalloc(size, GFP_KERNEL);
GFP_KERNEL 1020 sound/core/control.c ue = kzalloc(sizeof(struct user_element) + private_size, GFP_KERNEL);
GFP_KERNEL 1303 sound/core/control.c pn = kzalloc(sizeof(struct snd_kctl_ioctl), GFP_KERNEL);
GFP_KERNEL 97 sound/core/control_compat.c data = kzalloc(sizeof(*data), GFP_KERNEL);
GFP_KERNEL 185 sound/core/control_compat.c info = kzalloc(sizeof(*info), GFP_KERNEL);
GFP_KERNEL 290 sound/core/control_compat.c data = kzalloc(sizeof(*data), GFP_KERNEL);
GFP_KERNEL 316 sound/core/control_compat.c data = kzalloc(sizeof(*data), GFP_KERNEL);
GFP_KERNEL 343 sound/core/control_compat.c data = kzalloc(sizeof(*data), GFP_KERNEL);
GFP_KERNEL 50 sound/core/device.c dev = kzalloc(sizeof(*dev), GFP_KERNEL);
GFP_KERNEL 360 sound/core/hwdep.c hwdep = kzalloc(sizeof(*hwdep), GFP_KERNEL);
GFP_KERNEL 91 sound/core/info.c nbuf = kmalloc(nsize, GFP_KERNEL);
GFP_KERNEL 336 sound/core/info.c data = kzalloc(sizeof(*data), GFP_KERNEL);
GFP_KERNEL 345 sound/core/info.c buffer = kzalloc(sizeof(*buffer), GFP_KERNEL);
GFP_KERNEL 350 sound/core/info.c buffer->buffer = kmalloc(buffer->len, GFP_KERNEL);
GFP_KERNEL 355 sound/core/info.c buffer = kzalloc(sizeof(*buffer), GFP_KERNEL);
GFP_KERNEL 360 sound/core/info.c buffer->buffer = kmalloc(buffer->len, GFP_KERNEL);
GFP_KERNEL 780 sound/core/info.c entry = kzalloc(sizeof(*entry), GFP_KERNEL);
GFP_KERNEL 783 sound/core/info.c entry->name = kstrdup(name, GFP_KERNEL);
GFP_KERNEL 57 sound/core/info_oss.c x = kstrdup(string, GFP_KERNEL);
GFP_KERNEL 143 sound/core/init.c card = kzalloc(sizeof(*card) + extra_size, GFP_KERNEL);
GFP_KERNEL 735 sound/core/init.c mfile = kmalloc(sizeof(*mfile), GFP_KERNEL);
GFP_KERNEL 86 sound/core/jack.c jack = kzalloc(sizeof(struct snd_jack), GFP_KERNEL);
GFP_KERNEL 137 sound/core/memalloc.c gfp_flags = GFP_KERNEL
GFP_KERNEL 333 sound/core/memalloc.c mem = kmalloc(sizeof(*mem), GFP_KERNEL);
GFP_KERNEL 55 sound/core/oss/mixer_oss.c fmixer = kzalloc(sizeof(*fmixer), GFP_KERNEL);
GFP_KERNEL 517 sound/core/oss/mixer_oss.c uinfo = kzalloc(sizeof(*uinfo), GFP_KERNEL);
GFP_KERNEL 518 sound/core/oss/mixer_oss.c uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);
GFP_KERNEL 555 sound/core/oss/mixer_oss.c uinfo = kzalloc(sizeof(*uinfo), GFP_KERNEL);
GFP_KERNEL 556 sound/core/oss/mixer_oss.c uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);
GFP_KERNEL 618 sound/core/oss/mixer_oss.c uinfo = kzalloc(sizeof(*uinfo), GFP_KERNEL);
GFP_KERNEL 619 sound/core/oss/mixer_oss.c uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);
GFP_KERNEL 659 sound/core/oss/mixer_oss.c uinfo = kzalloc(sizeof(*uinfo), GFP_KERNEL);
GFP_KERNEL 660 sound/core/oss/mixer_oss.c uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);
GFP_KERNEL 780 sound/core/oss/mixer_oss.c uinfo = kzalloc(sizeof(*uinfo), GFP_KERNEL);
GFP_KERNEL 781 sound/core/oss/mixer_oss.c uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);
GFP_KERNEL 830 sound/core/oss/mixer_oss.c uinfo = kzalloc(sizeof(*uinfo), GFP_KERNEL);
GFP_KERNEL 831 sound/core/oss/mixer_oss.c uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);
GFP_KERNEL 891 sound/core/oss/mixer_oss.c info = kmalloc(sizeof(*info), GFP_KERNEL);
GFP_KERNEL 1018 sound/core/oss/mixer_oss.c uinfo = kzalloc(sizeof(*uinfo), GFP_KERNEL);
GFP_KERNEL 1053 sound/core/oss/mixer_oss.c pslot = kmalloc(sizeof(slot), GFP_KERNEL);
GFP_KERNEL 1180 sound/core/oss/mixer_oss.c tbl = kmalloc(sizeof(*tbl), GFP_KERNEL);
GFP_KERNEL 1186 sound/core/oss/mixer_oss.c tbl->name = kstrdup(str, GFP_KERNEL);
GFP_KERNEL 1314 sound/core/oss/mixer_oss.c mixer = kcalloc(2, sizeof(*mixer), GFP_KERNEL);
GFP_KERNEL 424 sound/core/oss/pcm_oss.c save = kmalloc(sizeof(*save), GFP_KERNEL);
GFP_KERNEL 436 sound/core/oss/pcm_oss.c params1 = kmalloc(sizeof(*params1), GFP_KERNEL);
GFP_KERNEL 797 sound/core/oss/pcm_oss.c save = kmalloc(sizeof(*save), GFP_KERNEL);
GFP_KERNEL 845 sound/core/oss/pcm_oss.c sw_params = kmalloc(sizeof(*sw_params), GFP_KERNEL);
GFP_KERNEL 846 sound/core/oss/pcm_oss.c params = kmalloc(sizeof(*params), GFP_KERNEL);
GFP_KERNEL 847 sound/core/oss/pcm_oss.c sparams = kmalloc(sizeof(*sparams), GFP_KERNEL);
GFP_KERNEL 1772 sound/core/oss/pcm_oss.c params = kmalloc(sizeof(*params), GFP_KERNEL);
GFP_KERNEL 2291 sound/core/oss/pcm_oss.c pcm_oss_file = kzalloc(sizeof(*pcm_oss_file), GFP_KERNEL);
GFP_KERNEL 2872 sound/core/oss/pcm_oss.c setup = kmalloc(sizeof(*setup), GFP_KERNEL);
GFP_KERNEL 2885 sound/core/oss/pcm_oss.c template.task_name = kstrdup(task_name, GFP_KERNEL);
GFP_KERNEL 160 sound/core/oss/pcm_plugin.c plugin = kzalloc(sizeof(*plugin) + extra, GFP_KERNEL);
GFP_KERNEL 177 sound/core/oss/pcm_plugin.c plugin->buf_channels = kcalloc(channels, sizeof(*plugin->buf_channels), GFP_KERNEL);
GFP_KERNEL 323 sound/core/pcm.c info = kmalloc(sizeof(*info), GFP_KERNEL);
GFP_KERNEL 638 sound/core/pcm.c substream = kzalloc(sizeof(*substream), GFP_KERNEL);
GFP_KERNEL 711 sound/core/pcm.c pcm = kzalloc(sizeof(*pcm), GFP_KERNEL);
GFP_KERNEL 872 sound/core/pcm.c runtime = kzalloc(sizeof(*runtime), GFP_KERNEL);
GFP_KERNEL 877 sound/core/pcm.c runtime->status = snd_malloc_pages(size, GFP_KERNEL);
GFP_KERNEL 885 sound/core/pcm.c runtime->control = snd_malloc_pages(size, GFP_KERNEL);
GFP_KERNEL 235 sound/core/pcm_compat.c data = kmalloc(sizeof(*data), GFP_KERNEL);
GFP_KERNEL 338 sound/core/pcm_compat.c bufs = kmalloc(sizeof(void __user *) * ch, GFP_KERNEL);
GFP_KERNEL 878 sound/core/pcm_lib.c new = kcalloc(new_rules, sizeof(*c), GFP_KERNEL);
GFP_KERNEL 390 sound/core/pcm_memory.c dmab = kzalloc(sizeof(*dmab), GFP_KERNEL);
GFP_KERNEL 125 sound/core/pcm_native.c info = kmalloc(sizeof(*info), GFP_KERNEL);
GFP_KERNEL 330 sound/core/pcm_native.c params = kmalloc(sizeof(*params), GFP_KERNEL);
GFP_KERNEL 468 sound/core/pcm_native.c params = kmalloc(sizeof(*params), GFP_KERNEL);
GFP_KERNEL 1436 sound/core/pcm_native.c drec = kmalloc(substream->group->count * sizeof(*drec), GFP_KERNEL);
GFP_KERNEL 2080 sound/core/pcm_native.c pcm_file = kzalloc(sizeof(*pcm_file), GFP_KERNEL);
GFP_KERNEL 2605 sound/core/pcm_native.c bufs = kmalloc(sizeof(void *) * runtime->channels, GFP_KERNEL);
GFP_KERNEL 2687 sound/core/pcm_native.c bufs = kmalloc(sizeof(void *) * runtime->channels, GFP_KERNEL);
GFP_KERNEL 2855 sound/core/pcm_native.c bufs = kmalloc(sizeof(void *) * nr_segs, GFP_KERNEL);
GFP_KERNEL 2889 sound/core/pcm_native.c bufs = kmalloc(sizeof(void *) * nr_segs, GFP_KERNEL);
GFP_KERNEL 3325 sound/core/pcm_native.c params = kmalloc(sizeof(*params), GFP_KERNEL);
GFP_KERNEL 3330 sound/core/pcm_native.c oparams = kmalloc(sizeof(*oparams), GFP_KERNEL);
GFP_KERNEL 3360 sound/core/pcm_native.c params = kmalloc(sizeof(*params), GFP_KERNEL);
GFP_KERNEL 3365 sound/core/pcm_native.c oparams = kmalloc(sizeof(*oparams), GFP_KERNEL);
GFP_KERNEL 111 sound/core/rawmidi.c if ((runtime = kzalloc(sizeof(*runtime), GFP_KERNEL)) == NULL)
GFP_KERNEL 130 sound/core/rawmidi.c if ((runtime->buffer = kmalloc(runtime->buffer_size, GFP_KERNEL)) == NULL) {
GFP_KERNEL 411 sound/core/rawmidi.c rawmidi_file = kmalloc(sizeof(*rawmidi_file), GFP_KERNEL);
GFP_KERNEL 624 sound/core/rawmidi.c newbuf = kmalloc(params->buffer_size, GFP_KERNEL);
GFP_KERNEL 651 sound/core/rawmidi.c newbuf = kmalloc(params->buffer_size, GFP_KERNEL);
GFP_KERNEL 1384 sound/core/rawmidi.c substream = kzalloc(sizeof(*substream), GFP_KERNEL);
GFP_KERNEL 1429 sound/core/rawmidi.c rmidi = kzalloc(sizeof(*rmidi), GFP_KERNEL);
GFP_KERNEL 71 sound/core/seq/oss/seq_oss_init.c port = kmalloc(sizeof(*port), GFP_KERNEL);
GFP_KERNEL 179 sound/core/seq/oss/seq_oss_init.c dp = kzalloc(sizeof(*dp), GFP_KERNEL);
GFP_KERNEL 79 sound/core/seq/oss/seq_oss_midi.c clinfo = kzalloc(sizeof(*clinfo), GFP_KERNEL);
GFP_KERNEL 80 sound/core/seq/oss/seq_oss_midi.c pinfo = kzalloc(sizeof(*pinfo), GFP_KERNEL);
GFP_KERNEL 175 sound/core/seq/oss/seq_oss_midi.c if ((mdev = kzalloc(sizeof(*mdev), GFP_KERNEL)) == NULL) {
GFP_KERNEL 49 sound/core/seq/oss/seq_oss_readq.c if ((q = kzalloc(sizeof(*q), GFP_KERNEL)) == NULL) {
GFP_KERNEL 54 sound/core/seq/oss/seq_oss_readq.c if ((q->q = kcalloc(maxlen, sizeof(union evrec), GFP_KERNEL)) == NULL) {
GFP_KERNEL 106 sound/core/seq/oss/seq_oss_synth.c if ((rec = kzalloc(sizeof(*rec), GFP_KERNEL)) == NULL) {
GFP_KERNEL 247 sound/core/seq/oss/seq_oss_synth.c info->ch = kcalloc(info->nr_voices, sizeof(struct seq_oss_chinfo), GFP_KERNEL);
GFP_KERNEL 509 sound/core/seq/oss/seq_oss_synth.c sysex = kzalloc(sizeof(*sysex), GFP_KERNEL);
GFP_KERNEL 49 sound/core/seq/oss/seq_oss_timer.c rec = kzalloc(sizeof(*rec), GFP_KERNEL);
GFP_KERNEL 41 sound/core/seq/oss/seq_oss_writeq.c if ((q = kzalloc(sizeof(*q), GFP_KERNEL)) == NULL)
GFP_KERNEL 225 sound/core/seq/seq_clientmgr.c client = kzalloc(sizeof(*client), GFP_KERNEL);
GFP_KERNEL 51 sound/core/seq/seq_compat.c data = kmalloc(sizeof(*data), GFP_KERNEL);
GFP_KERNEL 197 sound/core/seq/seq_device.c dev = kzalloc(sizeof(*dev)*2 + argsize, GFP_KERNEL);
GFP_KERNEL 359 sound/core/seq/seq_device.c ops = kzalloc(sizeof(*ops), GFP_KERNEL);
GFP_KERNEL 156 sound/core/seq/seq_dummy.c if ((rec = kzalloc(sizeof(*rec), GFP_KERNEL)) == NULL)
GFP_KERNEL 35 sound/core/seq/seq_fifo.c f = kzalloc(sizeof(*f), GFP_KERNEL);
GFP_KERNEL 464 sound/core/seq/seq_memory.c pool = kzalloc(sizeof(*pool), GFP_KERNEL);
GFP_KERNEL 294 sound/core/seq/seq_midi.c info = kmalloc(sizeof(*info), GFP_KERNEL);
GFP_KERNEL 320 sound/core/seq/seq_midi.c client = kzalloc(sizeof(*client), GFP_KERNEL);
GFP_KERNEL 338 sound/core/seq/seq_midi.c msynth = kcalloc(ports, sizeof(struct seq_midisynth), GFP_KERNEL);
GFP_KERNEL 339 sound/core/seq/seq_midi.c port = kmalloc(sizeof(*port), GFP_KERNEL);
GFP_KERNEL 654 sound/core/seq/seq_midi_emul.c chan = kmalloc(n * sizeof(struct snd_midi_channel), GFP_KERNEL);
GFP_KERNEL 692 sound/core/seq/seq_midi_emul.c chset = kmalloc(sizeof(*chset), GFP_KERNEL);
GFP_KERNEL 119 sound/core/seq/seq_midi_event.c dev = kzalloc(sizeof(*dev), GFP_KERNEL);
GFP_KERNEL 123 sound/core/seq/seq_midi_event.c dev->buf = kmalloc(bufsize, GFP_KERNEL);
GFP_KERNEL 197 sound/core/seq/seq_midi_event.c new_buf = kmalloc(bufsize, GFP_KERNEL);
GFP_KERNEL 142 sound/core/seq/seq_ports.c new_port = kzalloc(sizeof(*new_port), GFP_KERNEL);
GFP_KERNEL 502 sound/core/seq/seq_ports.c subs = kzalloc(sizeof(*subs), GFP_KERNEL);
GFP_KERNEL 61 sound/core/seq/seq_prioq.c f = kzalloc(sizeof(*f), GFP_KERNEL);
GFP_KERNEL 113 sound/core/seq/seq_queue.c q = kzalloc(sizeof(*q), GFP_KERNEL);
GFP_KERNEL 125 sound/core/seq/seq_system.c port = kzalloc(sizeof(*port), GFP_KERNEL);
GFP_KERNEL 59 sound/core/seq/seq_timer.c tmr = kzalloc(sizeof(*tmr), GFP_KERNEL);
GFP_KERNEL 206 sound/core/seq/seq_virmidi.c vmidi = kzalloc(sizeof(*vmidi), GFP_KERNEL);
GFP_KERNEL 234 sound/core/seq/seq_virmidi.c vmidi = kzalloc(sizeof(*vmidi), GFP_KERNEL);
GFP_KERNEL 365 sound/core/seq/seq_virmidi.c pinfo = kzalloc(sizeof(*pinfo), GFP_KERNEL);
GFP_KERNEL 502 sound/core/seq/seq_virmidi.c rdev = kzalloc(sizeof(*rdev), GFP_KERNEL);
GFP_KERNEL 77 sound/core/sgbuf.c dmab->private_data = sgbuf = kzalloc(sizeof(*sgbuf), GFP_KERNEL);
GFP_KERNEL 83 sound/core/sgbuf.c table = kcalloc(sgbuf->tblsize, sizeof(*table), GFP_KERNEL);
GFP_KERNEL 87 sound/core/sgbuf.c pgtable = kcalloc(sgbuf->tblsize, sizeof(*pgtable), GFP_KERNEL);
GFP_KERNEL 255 sound/core/sound.c preg = kmalloc(sizeof *preg, GFP_KERNEL);
GFP_KERNEL 117 sound/core/sound_oss.c preg = kmalloc(sizeof(struct snd_minor), GFP_KERNEL);
GFP_KERNEL 101 sound/core/timer.c timeri = kzalloc(sizeof(*timeri), GFP_KERNEL);
GFP_KERNEL 104 sound/core/timer.c timeri->owner = kstrdup(owner, GFP_KERNEL);
GFP_KERNEL 768 sound/core/timer.c timer = kzalloc(sizeof(*timer), GFP_KERNEL);
GFP_KERNEL 1020 sound/core/timer.c priv = kzalloc(sizeof(*priv), GFP_KERNEL);
GFP_KERNEL 1241 sound/core/timer.c tu = kzalloc(sizeof(*tu), GFP_KERNEL);
GFP_KERNEL 1250 sound/core/timer.c GFP_KERNEL);
GFP_KERNEL 1399 sound/core/timer.c ginfo = kmalloc(sizeof(*ginfo), GFP_KERNEL);
GFP_KERNEL 1531 sound/core/timer.c GFP_KERNEL);
GFP_KERNEL 1536 sound/core/timer.c GFP_KERNEL);
GFP_KERNEL 1572 sound/core/timer.c info = kzalloc(sizeof(*info), GFP_KERNEL);
GFP_KERNEL 1647 sound/core/timer.c GFP_KERNEL);
GFP_KERNEL 1655 sound/core/timer.c GFP_KERNEL);
GFP_KERNEL 66 sound/core/vmaster.c uinfo = kmalloc(sizeof(*uinfo), GFP_KERNEL);
GFP_KERNEL 88 sound/core/vmaster.c uctl = kmalloc(sizeof(*uctl), GFP_KERNEL);
GFP_KERNEL 238 sound/core/vmaster.c slave->count * sizeof(*slave->vd), GFP_KERNEL);
GFP_KERNEL 305 sound/core/vmaster.c uval = kmalloc(sizeof(*uval), GFP_KERNEL);
GFP_KERNEL 345 sound/core/vmaster.c master = kzalloc(sizeof(*master), GFP_KERNEL);
GFP_KERNEL 339 sound/drivers/dummy.c dpcm = kzalloc(sizeof(*dpcm), GFP_KERNEL);
GFP_KERNEL 449 sound/drivers/dummy.c snd_dma_continuous_data(GFP_KERNEL),
GFP_KERNEL 1123 sound/drivers/ml403-ac97cr.c ml403_ac97cr = kzalloc(sizeof(*ml403_ac97cr), GFP_KERNEL);
GFP_KERNEL 1262 sound/drivers/ml403-ac97cr.c snd_dma_continuous_data(GFP_KERNEL),
GFP_KERNEL 545 sound/drivers/mpu401/mpu401_uart.c mpu = kzalloc(sizeof(*mpu), GFP_KERNEL);
GFP_KERNEL 92 sound/drivers/mts64.c mts = kzalloc(sizeof(struct mts64), GFP_KERNEL);
GFP_KERNEL 356 sound/drivers/opl3/opl3_lib.c opl3 = kzalloc(sizeof(*opl3), GFP_KERNEL);
GFP_KERNEL 326 sound/drivers/opl3/opl3_synth.c patch = kzalloc(sizeof(*patch), GFP_KERNEL);
GFP_KERNEL 209 sound/drivers/opl4/opl4_lib.c opl4 = kzalloc(sizeof(*opl4), GFP_KERNEL);
GFP_KERNEL 316 sound/drivers/pcsp/pcsp_lib.c (GFP_KERNEL), PCSP_BUFFER_SIZE,
GFP_KERNEL 105 sound/drivers/portman2x4.c pm = kzalloc(sizeof(struct portman), GFP_KERNEL);
GFP_KERNEL 800 sound/drivers/serial-u16550.c if ((uart = kzalloc(sizeof(*uart), GFP_KERNEL)) == NULL)
GFP_KERNEL 787 sound/drivers/vx/vx_core.c chip = kzalloc(sizeof(*chip) + extra_size, GFP_KERNEL);
GFP_KERNEL 175 sound/drivers/vx/vx_hwdep.c fw = kmalloc(sizeof(*fw), GFP_KERNEL);
GFP_KERNEL 479 sound/drivers/vx/vx_pcm.c pipe = kzalloc(sizeof(*pipe), GFP_KERNEL);
GFP_KERNEL 1257 sound/drivers/vx/vx_pcm.c chip->playback_pipes = kcalloc(chip->audio_outs, sizeof(struct vx_pipe *), GFP_KERNEL);
GFP_KERNEL 1260 sound/drivers/vx/vx_pcm.c chip->capture_pipes = kcalloc(chip->audio_ins, sizeof(struct vx_pipe *), GFP_KERNEL);
GFP_KERNEL 222 sound/i2c/cs8427.c chip = device->private_data = kzalloc(sizeof(*chip), GFP_KERNEL);
GFP_KERNEL 88 sound/i2c/i2c.c bus = kzalloc(sizeof(*bus), GFP_KERNEL);
GFP_KERNEL 119 sound/i2c/i2c.c device = kzalloc(sizeof(*device), GFP_KERNEL);
GFP_KERNEL 777 sound/i2c/l3/uda1341.c clnt = kzalloc(sizeof(*clnt), GFP_KERNEL);
GFP_KERNEL 815 sound/i2c/l3/uda1341.c uda = kzalloc(sizeof(*uda), 0, GFP_KERNEL);
GFP_KERNEL 94 sound/i2c/other/ak4114.c chip = kzalloc(sizeof(*chip), GFP_KERNEL);
GFP_KERNEL 85 sound/i2c/other/ak4117.c chip = kzalloc(sizeof(*chip), GFP_KERNEL);
GFP_KERNEL 301 sound/i2c/tea6330t.c tea = kzalloc(sizeof(*tea), GFP_KERNEL);
GFP_KERNEL 589 sound/isa/ad1816a/ad1816a_lib.c chip = kzalloc(sizeof(*chip), GFP_KERNEL);
GFP_KERNEL 650 sound/isa/es1688/es1688_lib.c chip = kzalloc(sizeof(*chip), GFP_KERNEL);
GFP_KERNEL 1805 sound/isa/es18xx.c chip = kzalloc(sizeof(*chip), GFP_KERNEL);
GFP_KERNEL 199 sound/isa/gus/gus_dma.c block = kmalloc(sizeof(*block), atomic ? GFP_ATOMIC : GFP_KERNEL);
GFP_KERNEL 147 sound/isa/gus/gus_main.c gus = kzalloc(sizeof(*gus), GFP_KERNEL);
GFP_KERNEL 47 sound/isa/gus/gus_mem.c nblock = kmalloc(sizeof(struct snd_gf1_mem_block), GFP_KERNEL);
GFP_KERNEL 215 sound/isa/gus/gus_mem.c block.name = kstrdup(name, GFP_KERNEL);
GFP_KERNEL 255 sound/isa/gus/gus_mem.c block.name = kstrdup("InterWave LFOs", GFP_KERNEL);
GFP_KERNEL 261 sound/isa/gus/gus_mem.c block.name = kstrdup("Voice default (NULL's)", GFP_KERNEL);
GFP_KERNEL 100 sound/isa/gus/gus_mem_proc.c priv = kzalloc(sizeof(*priv), GFP_KERNEL);
GFP_KERNEL 117 sound/isa/gus/gus_mem_proc.c priv = kzalloc(sizeof(*priv), GFP_KERNEL);
GFP_KERNEL 671 sound/isa/gus/gus_pcm.c pcmp = kzalloc(sizeof(*pcmp), GFP_KERNEL);
GFP_KERNEL 1089 sound/isa/sb/emu8000.c hw = kzalloc(sizeof(*hw), GFP_KERNEL);
GFP_KERNEL 233 sound/isa/sb/emu8000_pcm.c rec = kzalloc(sizeof(*rec), GFP_KERNEL);
GFP_KERNEL 131 sound/isa/sb/sb16_csp.c if ((p = kzalloc(sizeof(*p), GFP_KERNEL)) == NULL) {
GFP_KERNEL 688 sound/isa/sb/sb16_csp.c unsigned char *kbuf = kmalloc(size, GFP_KERNEL);
GFP_KERNEL 225 sound/isa/sb/sb_common.c chip = kzalloc(sizeof(*chip), GFP_KERNEL);
GFP_KERNEL 213 sound/isa/wavefront/wavefront_fx.c page_data = kmalloc(r.data[2] * sizeof(short), GFP_KERNEL);
GFP_KERNEL 1197 sound/isa/wavefront/wavefront_synth.c msample_hdr = kmalloc(sizeof(WF_MSAMPLE_BYTES), GFP_KERNEL);
GFP_KERNEL 1360 sound/isa/wavefront/wavefront_synth.c header = kmalloc(sizeof(*header), GFP_KERNEL);
GFP_KERNEL 1667 sound/isa/wavefront/wavefront_synth.c wc = kmalloc(sizeof(*wc), GFP_KERNEL);
GFP_KERNEL 1714 sound/isa/wss/wss_lib.c chip = kzalloc(sizeof(*chip), GFP_KERNEL);
GFP_KERNEL 170 sound/mips/au1x00.c stream->buffer = kmalloc(sizeof(struct au1000_period), GFP_KERNEL);
GFP_KERNEL 178 sound/mips/au1x00.c pointer->next = kmalloc(sizeof(struct au1000_period), GFP_KERNEL);
GFP_KERNEL 452 sound/mips/au1x00.c snd_dma_continuous_data(GFP_KERNEL), 128*1024, 128*1024);
GFP_KERNEL 647 sound/mips/au1x00.c au1000->stream[PLAYBACK] = kmalloc(sizeof(struct audio_stream), GFP_KERNEL);
GFP_KERNEL 648 sound/mips/au1x00.c au1000->stream[CAPTURE ] = kmalloc(sizeof(struct audio_stream), GFP_KERNEL);
GFP_KERNEL 459 sound/mips/hal2.c &buffer_dma, GFP_KERNEL);
GFP_KERNEL 463 sound/mips/hal2.c &desc_dma, GFP_KERNEL);
GFP_KERNEL 753 sound/mips/hal2.c snd_dma_continuous_data(GFP_KERNEL),
GFP_KERNEL 813 sound/mips/hal2.c hal2 = kzalloc(sizeof(struct snd_hal2), GFP_KERNEL);
GFP_KERNEL 866 sound/mips/sgio2audio.c chip = kzalloc(sizeof(struct snd_sgio2audio), GFP_KERNEL);
GFP_KERNEL 634 sound/oss/ac97_codec.c struct ac97_codec *codec = kzalloc(sizeof(struct ac97_codec), GFP_KERNEL);
GFP_KERNEL 1995 sound/oss/ad1848.c portc = kmalloc(sizeof(ad1848_port_info), GFP_KERNEL);
GFP_KERNEL 644 sound/oss/au1550_ac97.c db->rawbuf = kmalloc((PAGE_SIZE << db->buforder), GFP_KERNEL);
GFP_KERNEL 404 sound/oss/dmasound/dmasound_core.c sq->buffers = kmalloc (num * sizeof(char *), GFP_KERNEL);
GFP_KERNEL 408 sound/oss/dmasound/dmasound_core.c sq->buffers[i] = dmasound.mach.dma_alloc(size, GFP_KERNEL);
GFP_KERNEL 142 sound/oss/kahlua.c hw_config = kzalloc(sizeof(struct address_info), GFP_KERNEL);
GFP_KERNEL 1027 sound/oss/mpu401.c mpu401_synth_operations[m] = kmalloc(sizeof(struct synth_operations), GFP_KERNEL);
GFP_KERNEL 889 sound/oss/msnd_pinnacle.c char *page = (char *)__get_free_page(GFP_KERNEL);
GFP_KERNEL 947 sound/oss/msnd_pinnacle.c char *page = (char *)__get_free_page(GFP_KERNEL);
GFP_KERNEL 167 sound/oss/opl3.c devc = kzalloc(sizeof(*devc), GFP_KERNEL);
GFP_KERNEL 140 sound/oss/sb_card.c if((legacy = kzalloc(sizeof(struct sb_card_config), GFP_KERNEL)) == NULL) {
GFP_KERNEL 249 sound/oss/sb_card.c if((scc = kzalloc(sizeof(struct sb_card_config), GFP_KERNEL)) == NULL) {
GFP_KERNEL 628 sound/oss/sb_common.c detected_devc = kmalloc(sizeof(sb_devc), GFP_KERNEL);
GFP_KERNEL 176 sound/oss/sb_midi.c midi_devs[dev] = kmalloc(sizeof(struct midi_operations), GFP_KERNEL);
GFP_KERNEL 192 sound/oss/sb_midi.c midi_devs[dev]->converter = kmalloc(sizeof(struct synth_operations), GFP_KERNEL);
GFP_KERNEL 737 sound/oss/sb_mixer.c mixer_devs[m] = kmalloc(sizeof(struct mixer_operations), GFP_KERNEL);
GFP_KERNEL 299 sound/oss/sh_dac_audio.c data_buffer = kmalloc(BUFFER_SIZE, GFP_KERNEL);
GFP_KERNEL 618 sound/oss/swarm_cs4297a.c dma->descrtab = kzalloc(dma->ringsz * sizeof(serdma_descr_t), GFP_KERNEL);
GFP_KERNEL 629 sound/oss/swarm_cs4297a.c dma->dma_buf = kzalloc(DMA_BUF_SIZE, GFP_KERNEL);
GFP_KERNEL 639 sound/oss/swarm_cs4297a.c dma->sample_buf = kmalloc(dma->sbufsz, GFP_KERNEL);
GFP_KERNEL 2619 sound/oss/swarm_cs4297a.c if (!(s = kzalloc(sizeof(struct cs4297a_state), GFP_KERNEL))) {
GFP_KERNEL 309 sound/oss/uart401.c devc = kmalloc(sizeof(uart401_devc), GFP_KERNEL);
GFP_KERNEL 354 sound/oss/uart401.c midi_devs[devc->my_dev] = kmalloc(sizeof(struct midi_operations), GFP_KERNEL);
GFP_KERNEL 365 sound/oss/uart401.c midi_devs[devc->my_dev]->converter = kmalloc(sizeof(struct synth_operations), GFP_KERNEL);
GFP_KERNEL 186 sound/oss/v_midi.c m = kmalloc(sizeof(struct vmidi_memory), GFP_KERNEL);
GFP_KERNEL 471 sound/oss/vidc.c dma_buf[i] = get_zeroed_page(GFP_KERNEL);
GFP_KERNEL 3301 sound/oss/vwsnd.c devc = kmalloc(sizeof (vwsnd_dev_t), GFP_KERNEL);
GFP_KERNEL 3312 sound/oss/vwsnd.c devc->rport.hwbuf_vaddr = __get_free_pages(GFP_KERNEL, HWBUF_ORDER);
GFP_KERNEL 3335 sound/oss/vwsnd.c devc->wport.hwbuf_vaddr = __get_free_pages(GFP_KERNEL, HWBUF_ORDER);
GFP_KERNEL 1270 sound/oss/waveartist.c portc = kzalloc(sizeof(wavnc_port_info), GFP_KERNEL);
GFP_KERNEL 927 sound/parisc/harmony.c h = kzalloc(sizeof(*h), GFP_KERNEL);
GFP_KERNEL 1895 sound/pci/ac97/ac97_codec.c bus = kzalloc(sizeof(*bus), GFP_KERNEL);
GFP_KERNEL 2005 sound/pci/ac97/ac97_codec.c ac97 = kzalloc(sizeof(*ac97), GFP_KERNEL);
GFP_KERNEL 457 sound/pci/ac97/ac97_pcm.c rpcms = kcalloc(pcms_count, sizeof(struct ac97_pcm), GFP_KERNEL);
GFP_KERNEL 920 sound/pci/ad1889.c if ((chip = kzalloc(sizeof(*chip), GFP_KERNEL)) == NULL) {
GFP_KERNEL 399 sound/pci/ak4531_codec.c ak4531 = kzalloc(sizeof(*ak4531), GFP_KERNEL);
GFP_KERNEL 2197 sound/pci/ali5451/ali5451.c codec = kzalloc(sizeof(*codec), GFP_KERNEL);
GFP_KERNEL 2288 sound/pci/ali5451/ali5451.c codec->image = kmalloc(sizeof(*codec->image), GFP_KERNEL);
GFP_KERNEL 388 sound/pci/als300.c GFP_KERNEL);
GFP_KERNEL 419 sound/pci/als300.c GFP_KERNEL);
GFP_KERNEL 700 sound/pci/als300.c chip = kzalloc(sizeof(*chip), GFP_KERNEL);
GFP_KERNEL 1595 sound/pci/atiixp.c chip = kzalloc(sizeof(*chip), GFP_KERNEL);
GFP_KERNEL 1238 sound/pci/atiixp_modem.c chip = kzalloc(sizeof(*chip), GFP_KERNEL);
GFP_KERNEL 161 sound/pci/au88x0/au88x0.c chip = kzalloc(sizeof(*chip), GFP_KERNEL);
GFP_KERNEL 288 sound/pci/aw2/aw2-alsa.c chip = kzalloc(sizeof(*chip), GFP_KERNEL);
GFP_KERNEL 2117 sound/pci/azt3328.c chip = kzalloc(sizeof(*chip), GFP_KERNEL);
GFP_KERNEL 737 sound/pci/bt87x.c chip = kzalloc(sizeof(*chip), GFP_KERNEL);
GFP_KERNEL 492 sound/pci/ca0106/ca0106_main.c epcm = kzalloc(sizeof(*epcm), GFP_KERNEL);
GFP_KERNEL 579 sound/pci/ca0106/ca0106_main.c epcm = kzalloc(sizeof(*epcm), GFP_KERNEL);
GFP_KERNEL 1328 sound/pci/ca0106/ca0106_main.c chip = kzalloc(sizeof(*chip), GFP_KERNEL);
GFP_KERNEL 1168 sound/pci/cmipci.c val = kmalloc(sizeof(*val), GFP_KERNEL);
GFP_KERNEL 3031 sound/pci/cmipci.c cm = kzalloc(sizeof(*cm), GFP_KERNEL);
GFP_KERNEL 1361 sound/pci/cs4281.c chip = kzalloc(sizeof(*chip), GFP_KERNEL);
GFP_KERNEL 1316 sound/pci/cs46xx/cs46xx_lib.c cpcm = kzalloc(sizeof(*cpcm), GFP_KERNEL);
GFP_KERNEL 3727 sound/pci/cs46xx/cs46xx_lib.c chip = kzalloc(sizeof(*chip), GFP_KERNEL);
GFP_KERNEL 3860 sound/pci/cs46xx/cs46xx_lib.c ARRAY_SIZE(saved_regs), GFP_KERNEL);
GFP_KERNEL 226 sound/pci/cs46xx/dsp_spos.c struct dsp_spos_instance * ins = kzalloc(sizeof(struct dsp_spos_instance), GFP_KERNEL);
GFP_KERNEL 244 sound/pci/cs46xx/dsp_spos.c ins->code.data = kmalloc(DSP_CODE_BYTE_SIZE, GFP_KERNEL);
GFP_KERNEL 255 sound/pci/cs46xx/dsp_spos.c ins->modules = kmalloc(sizeof(struct dsp_module_desc) * DSP_MAX_MODULES, GFP_KERNEL);
GFP_KERNEL 259 sound/pci/cs46xx/dsp_spos_scb_lib.c scb_info = kmalloc(sizeof(struct proc_scb_info), GFP_KERNEL);
GFP_KERNEL 118 sound/pci/cs5530.c chip = kzalloc(sizeof(*chip), GFP_KERNEL);
GFP_KERNEL 285 sound/pci/cs5535audio/cs5535audio.c cs5535au = kzalloc(sizeof(*cs5535au), GFP_KERNEL);
GFP_KERNEL 240 sound/pci/echoaudio/echoaudio.c pipe = kzalloc(sizeof(struct audiopipe), GFP_KERNEL);
GFP_KERNEL 1910 sound/pci/echoaudio/echoaudio.c chip = kzalloc(sizeof(*chip), GFP_KERNEL);
GFP_KERNEL 309 sound/pci/echoaudio/layla24_dsp.c MONITOR_ARRAY_SIZE, GFP_KERNEL);
GFP_KERNEL 1725 sound/pci/emu10k1/emu10k1_main.c emu = kzalloc(sizeof(*emu), GFP_KERNEL);
GFP_KERNEL 394 sound/pci/emu10k1/emu10k1x.c epcm = kzalloc(sizeof(*epcm), GFP_KERNEL);
GFP_KERNEL 570 sound/pci/emu10k1/emu10k1x.c epcm = kzalloc(sizeof(*epcm), GFP_KERNEL);
GFP_KERNEL 907 sound/pci/emu10k1/emu10k1x.c chip = kzalloc(sizeof(*chip), GFP_KERNEL);
GFP_KERNEL 670 sound/pci/emu10k1/emufx.c tlv = kmalloc(data[1] + sizeof(data), GFP_KERNEL);
GFP_KERNEL 727 sound/pci/emu10k1/emufx.c gctl = kmalloc(sizeof(*gctl), GFP_KERNEL);
GFP_KERNEL 786 sound/pci/emu10k1/emufx.c val = kmalloc(sizeof(*val), GFP_KERNEL);
GFP_KERNEL 787 sound/pci/emu10k1/emufx.c gctl = kmalloc(sizeof(*gctl), GFP_KERNEL);
GFP_KERNEL 788 sound/pci/emu10k1/emufx.c nctl = kmalloc(sizeof(*nctl), GFP_KERNEL);
GFP_KERNEL 834 sound/pci/emu10k1/emufx.c ctl = kmalloc(sizeof(*ctl), GFP_KERNEL);
GFP_KERNEL 898 sound/pci/emu10k1/emufx.c gctl = kmalloc(sizeof(*gctl), GFP_KERNEL);
GFP_KERNEL 1162 sound/pci/emu10k1/emufx.c if ((icode = kzalloc(sizeof(*icode), GFP_KERNEL)) == NULL ||
GFP_KERNEL 1165 sound/pci/emu10k1/emufx.c GFP_KERNEL)) == NULL ||
GFP_KERNEL 1167 sound/pci/emu10k1/emufx.c sizeof(*controls), GFP_KERNEL)) == NULL) {
GFP_KERNEL 1790 sound/pci/emu10k1/emufx.c if ((icode = kzalloc(sizeof(*icode), GFP_KERNEL)) == NULL)
GFP_KERNEL 1794 sound/pci/emu10k1/emufx.c GFP_KERNEL)) == NULL ||
GFP_KERNEL 1797 sound/pci/emu10k1/emufx.c GFP_KERNEL)) == NULL ||
GFP_KERNEL 1798 sound/pci/emu10k1/emufx.c (ipcm = kzalloc(sizeof(*ipcm), GFP_KERNEL)) == NULL) {
GFP_KERNEL 2480 sound/pci/emu10k1/emufx.c info = kmalloc(sizeof(*info), GFP_KERNEL);
GFP_KERNEL 2493 sound/pci/emu10k1/emufx.c icode = kmalloc(sizeof(*icode), GFP_KERNEL);
GFP_KERNEL 2504 sound/pci/emu10k1/emufx.c icode = kmalloc(sizeof(*icode), GFP_KERNEL);
GFP_KERNEL 2519 sound/pci/emu10k1/emufx.c ipcm = kmalloc(sizeof(*ipcm), GFP_KERNEL);
GFP_KERNEL 2530 sound/pci/emu10k1/emufx.c ipcm = kzalloc(sizeof(*ipcm), GFP_KERNEL);
GFP_KERNEL 2642 sound/pci/emu10k1/emufx.c emu->saved_gpr = kmalloc(len * 4, GFP_KERNEL);
GFP_KERNEL 2646 sound/pci/emu10k1/emufx.c emu->tram_val_saved = kmalloc(len * 4, GFP_KERNEL);
GFP_KERNEL 2647 sound/pci/emu10k1/emufx.c emu->tram_addr_saved = kmalloc(len * 4, GFP_KERNEL);
GFP_KERNEL 1063 sound/pci/emu10k1/emupcm.c epcm = kzalloc(sizeof(*epcm), GFP_KERNEL);
GFP_KERNEL 1096 sound/pci/emu10k1/emupcm.c epcm = kzalloc(sizeof(*epcm), GFP_KERNEL);
GFP_KERNEL 1141 sound/pci/emu10k1/emupcm.c epcm = kzalloc(sizeof(*epcm), GFP_KERNEL);
GFP_KERNEL 1177 sound/pci/emu10k1/emupcm.c epcm = kzalloc(sizeof(*epcm), GFP_KERNEL);
GFP_KERNEL 1217 sound/pci/emu10k1/emupcm.c epcm = kzalloc(sizeof(*epcm), GFP_KERNEL);
GFP_KERNEL 371 sound/pci/emu10k1/emuproc.c if ((tmp = kmalloc(size + 8, GFP_KERNEL)) == NULL)
GFP_KERNEL 463 sound/pci/emu10k1/memory.c struct page *p = alloc_page(GFP_KERNEL | GFP_DMA32 |
GFP_KERNEL 185 sound/pci/emu10k1/p16v.c epcm = kzalloc(sizeof(*epcm), GFP_KERNEL);
GFP_KERNEL 226 sound/pci/emu10k1/p16v.c epcm = kzalloc(sizeof(*epcm), GFP_KERNEL);
GFP_KERNEL 2090 sound/pci/ens1370.c ensoniq = kzalloc(sizeof(*ensoniq), GFP_KERNEL);
GFP_KERNEL 1618 sound/pci/es1938.c chip = kzalloc(sizeof(*chip), GFP_KERNEL);
GFP_KERNEL 1361 sound/pci/es1968.c struct esm_memory *chunk = kmalloc(sizeof(*chunk), GFP_KERNEL);
GFP_KERNEL 1446 sound/pci/es1968.c chunk = kmalloc(sizeof(*chunk), GFP_KERNEL);
GFP_KERNEL 1548 sound/pci/es1968.c es = kzalloc(sizeof(*es), GFP_KERNEL);
GFP_KERNEL 1590 sound/pci/es1968.c es = kzalloc(sizeof(*es), GFP_KERNEL);
GFP_KERNEL 2549 sound/pci/es1968.c chip = kzalloc(sizeof(*chip), GFP_KERNEL);
GFP_KERNEL 1401 sound/pci/fm801.c chip = kzalloc(sizeof(*chip), GFP_KERNEL);
GFP_KERNEL 82 sound/pci/hda/hda_beep.c beep = kzalloc(sizeof(*beep), GFP_KERNEL);
GFP_KERNEL 354 sound/pci/hda/hda_codec.c unsol = kzalloc(sizeof(*unsol), GFP_KERNEL);
GFP_KERNEL 422 sound/pci/hda/hda_codec.c bus = kzalloc(sizeof(*bus), GFP_KERNEL);
GFP_KERNEL 546 sound/pci/hda/hda_codec.c codec->wcaps = kmalloc(codec->num_nodes * 4, GFP_KERNEL);
GFP_KERNEL 608 sound/pci/hda/hda_codec.c codec = kzalloc(sizeof(*codec), GFP_KERNEL);
GFP_KERNEL 788 sound/pci/hda/hda_codec.c new_buffer = kcalloc(new_size, cache->record_size, GFP_KERNEL);
GFP_KERNEL 120 sound/pci/hda/hda_generic.c node = kzalloc(sizeof(*node), GFP_KERNEL);
GFP_KERNEL 134 sound/pci/hda/hda_generic.c GFP_KERNEL);
GFP_KERNEL 1077 sound/pci/hda/hda_generic.c spec = kzalloc(sizeof(*spec), GFP_KERNEL);
GFP_KERNEL 1747 sound/pci/hda/hda_intel.c apcm = kmalloc(sizeof(*apcm), GFP_KERNEL);
GFP_KERNEL 2110 sound/pci/hda/hda_intel.c chip = kzalloc(sizeof(*chip), GFP_KERNEL);
GFP_KERNEL 2214 sound/pci/hda/hda_intel.c GFP_KERNEL);
GFP_KERNEL 987 sound/pci/hda/patch_analog.c spec = kzalloc(sizeof(*spec), GFP_KERNEL);
GFP_KERNEL 1234 sound/pci/hda/patch_analog.c spec = kzalloc(sizeof(*spec), GFP_KERNEL);
GFP_KERNEL 1635 sound/pci/hda/patch_analog.c spec = kzalloc(sizeof(*spec), GFP_KERNEL);
GFP_KERNEL 2478 sound/pci/hda/patch_analog.c knew = kcalloc(num + 1, sizeof(*knew), GFP_KERNEL); /* array + terminator */
GFP_KERNEL 2491 sound/pci/hda/patch_analog.c knew->name = kstrdup(name, GFP_KERNEL);
GFP_KERNEL 2896 sound/pci/hda/patch_analog.c spec = kzalloc(sizeof(*spec), GFP_KERNEL);
GFP_KERNEL 3203 sound/pci/hda/patch_analog.c spec = kzalloc(sizeof(*spec), GFP_KERNEL);
GFP_KERNEL 3872 sound/pci/hda/patch_analog.c spec = kzalloc(sizeof(*spec), GFP_KERNEL);
GFP_KERNEL 4208 sound/pci/hda/patch_analog.c spec = kzalloc(sizeof(*spec), GFP_KERNEL);
GFP_KERNEL 168 sound/pci/hda/patch_atihdmi.c spec = kzalloc(sizeof(*spec), GFP_KERNEL);
GFP_KERNEL 630 sound/pci/hda/patch_cmedia.c spec = kzalloc(sizeof(*spec), GFP_KERNEL);
GFP_KERNEL 929 sound/pci/hda/patch_conexant.c spec = kzalloc(sizeof(*spec), GFP_KERNEL);
GFP_KERNEL 1482 sound/pci/hda/patch_conexant.c spec = kzalloc(sizeof(*spec), GFP_KERNEL);
GFP_KERNEL 1740 sound/pci/hda/patch_conexant.c spec = kzalloc(sizeof(*spec), GFP_KERNEL);
GFP_KERNEL 140 sound/pci/hda/patch_nvhdmi.c spec = kzalloc(sizeof(*spec), GFP_KERNEL);
GFP_KERNEL 3450 sound/pci/hda/patch_realtek.c knew = kcalloc(num + 1, sizeof(*knew), GFP_KERNEL);
GFP_KERNEL 3464 sound/pci/hda/patch_realtek.c knew->name = kstrdup(name, GFP_KERNEL);
GFP_KERNEL 3824 sound/pci/hda/patch_realtek.c spec = kzalloc(sizeof(*spec), GFP_KERNEL);
GFP_KERNEL 5415 sound/pci/hda/patch_realtek.c spec = kzalloc(sizeof(*spec), GFP_KERNEL);
GFP_KERNEL 6642 sound/pci/hda/patch_realtek.c spec = kzalloc(sizeof(*spec), GFP_KERNEL);
GFP_KERNEL 8769 sound/pci/hda/patch_realtek.c spec = kzalloc(sizeof(*spec), GFP_KERNEL);
GFP_KERNEL 10573 sound/pci/hda/patch_realtek.c spec = kzalloc(sizeof(*spec), GFP_KERNEL);
GFP_KERNEL 11599 sound/pci/hda/patch_realtek.c spec = kcalloc(1, sizeof(*spec), GFP_KERNEL);
GFP_KERNEL 12284 sound/pci/hda/patch_realtek.c spec = kzalloc(sizeof(*spec), GFP_KERNEL);
GFP_KERNEL 13451 sound/pci/hda/patch_realtek.c spec = kzalloc(sizeof(*spec), GFP_KERNEL);
GFP_KERNEL 14404 sound/pci/hda/patch_realtek.c spec = kzalloc(sizeof(*spec), GFP_KERNEL);
GFP_KERNEL 16234 sound/pci/hda/patch_realtek.c spec = kzalloc(sizeof(*spec), GFP_KERNEL);
GFP_KERNEL 275 sound/pci/hda/patch_si3054.c struct si3054_spec *spec = kzalloc(sizeof(*spec), GFP_KERNEL);
GFP_KERNEL 2171 sound/pci/hda/patch_sigmatel.c sizeof(*spec->bios_pin_configs), GFP_KERNEL);
GFP_KERNEL 2598 sound/pci/hda/patch_sigmatel.c knew = kcalloc(num + 1, sizeof(*knew), GFP_KERNEL); /* array + terminator */
GFP_KERNEL 2612 sound/pci/hda/patch_sigmatel.c knew->name = kstrdup(name, GFP_KERNEL);
GFP_KERNEL 3918 sound/pci/hda/patch_sigmatel.c spec = kzalloc(sizeof(*spec), GFP_KERNEL);
GFP_KERNEL 3979 sound/pci/hda/patch_sigmatel.c spec = kzalloc(sizeof(*spec), GFP_KERNEL);
GFP_KERNEL 4066 sound/pci/hda/patch_sigmatel.c spec = kzalloc(sizeof(*spec), GFP_KERNEL);
GFP_KERNEL 4218 sound/pci/hda/patch_sigmatel.c spec = kzalloc(sizeof(*spec), GFP_KERNEL);
GFP_KERNEL 4349 sound/pci/hda/patch_sigmatel.c spec = kzalloc(sizeof(*spec), GFP_KERNEL);
GFP_KERNEL 4506 sound/pci/hda/patch_sigmatel.c spec = kzalloc(sizeof(*spec), GFP_KERNEL);
GFP_KERNEL 4613 sound/pci/hda/patch_sigmatel.c spec = kzalloc(sizeof(*spec), GFP_KERNEL);
GFP_KERNEL 4741 sound/pci/hda/patch_sigmatel.c spec = kzalloc(sizeof(*spec), GFP_KERNEL);
GFP_KERNEL 5035 sound/pci/hda/patch_sigmatel.c spec = kzalloc(sizeof(*spec), GFP_KERNEL);
GFP_KERNEL 279 sound/pci/hda/patch_via.c knew = kcalloc(num + 1, sizeof(*knew), GFP_KERNEL);
GFP_KERNEL 293 sound/pci/hda/patch_via.c knew->name = kstrdup(name, GFP_KERNEL);
GFP_KERNEL 1405 sound/pci/hda/patch_via.c spec = kzalloc(sizeof(*spec), GFP_KERNEL);
GFP_KERNEL 1876 sound/pci/hda/patch_via.c spec = kzalloc(sizeof(*spec), GFP_KERNEL);
GFP_KERNEL 1969 sound/pci/hda/patch_via.c spec = kzalloc(sizeof(*spec), GFP_KERNEL);
GFP_KERNEL 2420 sound/pci/hda/patch_via.c spec = kzalloc(sizeof(*spec), GFP_KERNEL);
GFP_KERNEL 2471 sound/pci/hda/patch_via.c spec = kzalloc(sizeof(*spec), GFP_KERNEL);
GFP_KERNEL 2885 sound/pci/hda/patch_via.c spec = kzalloc(sizeof(*spec), GFP_KERNEL);
GFP_KERNEL 3206 sound/pci/hda/patch_via.c spec = kzalloc(sizeof(*spec), GFP_KERNEL);
GFP_KERNEL 130 sound/pci/ice1712/ak4xxx.c priv = kmalloc(sizeof(*priv), GFP_KERNEL);
GFP_KERNEL 2070 sound/pci/ice1712/aureon.c spec = kzalloc(sizeof(*spec), GFP_KERNEL);
GFP_KERNEL 2085 sound/pci/ice1712/aureon.c ice->akm = kzalloc(sizeof(struct snd_akm4xxx), GFP_KERNEL);
GFP_KERNEL 625 sound/pci/ice1712/delta.c ak = ice->akm = kmalloc(sizeof(struct snd_akm4xxx), GFP_KERNEL);
GFP_KERNEL 453 sound/pci/ice1712/ews.c spec = kzalloc(sizeof(*spec), GFP_KERNEL);
GFP_KERNEL 547 sound/pci/ice1712/ews.c ak = ice->akm = kzalloc(sizeof(struct snd_akm4xxx), GFP_KERNEL);
GFP_KERNEL 178 sound/pci/ice1712/hoontech.c spec = kzalloc(sizeof(*spec), GFP_KERNEL);
GFP_KERNEL 303 sound/pci/ice1712/hoontech.c ak = ice->akm = kmalloc(sizeof(struct snd_akm4xxx), GFP_KERNEL);
GFP_KERNEL 2543 sound/pci/ice1712/ice1712.c ice = kzalloc(sizeof(*ice), GFP_KERNEL);
GFP_KERNEL 2366 sound/pci/ice1712/ice1724.c ice = kzalloc(sizeof(*ice), GFP_KERNEL);
GFP_KERNEL 595 sound/pci/ice1712/juli.c spec = kzalloc(sizeof(*spec), GFP_KERNEL);
GFP_KERNEL 629 sound/pci/ice1712/juli.c ice->akm = kzalloc(sizeof(struct snd_akm4xxx), GFP_KERNEL);
GFP_KERNEL 143 sound/pci/ice1712/phase.c ice->akm = kzalloc(sizeof(struct snd_akm4xxx), GFP_KERNEL);
GFP_KERNEL 430 sound/pci/ice1712/phase.c spec = kzalloc(sizeof(*spec), GFP_KERNEL);
GFP_KERNEL 436 sound/pci/ice1712/phase.c ice->akm = kzalloc(sizeof(struct snd_akm4xxx), GFP_KERNEL);
GFP_KERNEL 772 sound/pci/ice1712/pontis.c ice->akm = kzalloc(sizeof(struct snd_akm4xxx), GFP_KERNEL);
GFP_KERNEL 749 sound/pci/ice1712/prodigy192.c spec = kzalloc(sizeof(*spec), GFP_KERNEL);
GFP_KERNEL 1051 sound/pci/ice1712/prodigy_hifi.c ice->akm = kzalloc(sizeof(struct snd_akm4xxx), GFP_KERNEL);
GFP_KERNEL 1056 sound/pci/ice1712/prodigy_hifi.c spec = kzalloc(sizeof(*spec), GFP_KERNEL);
GFP_KERNEL 1105 sound/pci/ice1712/prodigy_hifi.c ice->akm = kzalloc(sizeof(struct snd_akm4xxx), GFP_KERNEL);
GFP_KERNEL 1110 sound/pci/ice1712/prodigy_hifi.c spec = kzalloc(sizeof(*spec), GFP_KERNEL);
GFP_KERNEL 164 sound/pci/ice1712/revo.c spec = kzalloc(sizeof(*spec), GFP_KERNEL);
GFP_KERNEL 525 sound/pci/ice1712/revo.c ak = ice->akm = kcalloc(2, sizeof(struct snd_akm4xxx), GFP_KERNEL);
GFP_KERNEL 685 sound/pci/ice1712/se.c spec = kzalloc(sizeof(*spec), GFP_KERNEL);
GFP_KERNEL 2837 sound/pci/intel8x0.c chip = kzalloc(sizeof(*chip), GFP_KERNEL);
GFP_KERNEL 1126 sound/pci/intel8x0m.c chip = kzalloc(sizeof(*chip), GFP_KERNEL);
GFP_KERNEL 2173 sound/pci/korg1212/korg1212.c korg1212 = kzalloc(sizeof(*korg1212), GFP_KERNEL);
GFP_KERNEL 2540 sound/pci/maestro3.c chip = kzalloc(sizeof(*chip), GFP_KERNEL);
GFP_KERNEL 2591 sound/pci/maestro3.c GFP_KERNEL);
GFP_KERNEL 256 sound/pci/mixart/mixart.c buf = kmalloc(sizeof(*buf), GFP_KERNEL);
GFP_KERNEL 1013 sound/pci/mixart/mixart.c mgr->chip[idx] = chip = kzalloc(sizeof(*chip), GFP_KERNEL);
GFP_KERNEL 1300 sound/pci/mixart/mixart.c mgr = kzalloc(sizeof(*mgr), GFP_KERNEL);
GFP_KERNEL 147 sound/pci/mixart/mixart_hwdep.c connector = kmalloc(sizeof(*connector), GFP_KERNEL);
GFP_KERNEL 148 sound/pci/mixart/mixart_hwdep.c audio_info_req = kmalloc(sizeof(*audio_info_req), GFP_KERNEL);
GFP_KERNEL 149 sound/pci/mixart/mixart_hwdep.c audio_info = kmalloc(sizeof(*audio_info), GFP_KERNEL);
GFP_KERNEL 1311 sound/pci/nm256/nm256.c sizeof(short), GFP_KERNEL);
GFP_KERNEL 1484 sound/pci/nm256/nm256.c chip = kzalloc(sizeof(*chip), GFP_KERNEL);
GFP_KERNEL 1027 sound/pci/pcxhr/pcxhr.c mgr->chip[idx] = chip = kzalloc(sizeof(*chip), GFP_KERNEL);
GFP_KERNEL 1226 sound/pci/pcxhr/pcxhr.c mgr = kzalloc(sizeof(*mgr), GFP_KERNEL);
GFP_KERNEL 1276 sound/pci/pcxhr/pcxhr.c GFP_KERNEL);
GFP_KERNEL 1640 sound/pci/riptide/riptide.c data = kzalloc(sizeof(struct pcmhw), GFP_KERNEL);
GFP_KERNEL 1660 sound/pci/riptide/riptide.c data = kzalloc(sizeof(struct pcmhw), GFP_KERNEL);
GFP_KERNEL 1817 sound/pci/riptide/riptide.c if ((cif = kzalloc(sizeof(struct cmdif), GFP_KERNEL)) == NULL)
GFP_KERNEL 1884 sound/pci/riptide/riptide.c if (!(chip = kzalloc(sizeof(struct snd_riptide), GFP_KERNEL)))
GFP_KERNEL 1383 sound/pci/rme32.c snd_dma_continuous_data(GFP_KERNEL),
GFP_KERNEL 1415 sound/pci/rme32.c snd_dma_continuous_data(GFP_KERNEL),
GFP_KERNEL 4433 sound/pci/rme9652/hdspm.c hdspm->mixer = kzalloc(sizeof(struct hdspm_mixer), GFP_KERNEL);
GFP_KERNEL 1279 sound/pci/sis7019.c sis->suspend_state[i] = kmalloc(4096, GFP_KERNEL);
GFP_KERNEL 1239 sound/pci/sonicvibes.c sonic = kzalloc(sizeof(*sonic), GFP_KERNEL);
GFP_KERNEL 2981 sound/pci/trident/trident_main.c uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);
GFP_KERNEL 3564 sound/pci/trident/trident_main.c trident = kzalloc(sizeof(*trident), GFP_KERNEL);
GFP_KERNEL 435 sound/pci/via82xx.c dev->idx_table = kmalloc(sizeof(*dev->idx_table) * VIA_TABLE_SIZE, GFP_KERNEL);
GFP_KERNEL 2278 sound/pci/via82xx.c if ((chip = kzalloc(sizeof(*chip), GFP_KERNEL)) == NULL) {
GFP_KERNEL 295 sound/pci/via82xx_modem.c dev->idx_table = kmalloc(sizeof(*dev->idx_table) * VIA_TABLE_SIZE, GFP_KERNEL);
GFP_KERNEL 1112 sound/pci/via82xx_modem.c if ((chip = kzalloc(sizeof(*chip), GFP_KERNEL)) == NULL) {
GFP_KERNEL 891 sound/pci/ymfpci/ymfpci_main.c ypcm = kzalloc(sizeof(*ypcm), GFP_KERNEL);
GFP_KERNEL 1007 sound/pci/ymfpci/ymfpci_main.c ypcm = kzalloc(sizeof(*ypcm), GFP_KERNEL);
GFP_KERNEL 2343 sound/pci/ymfpci/ymfpci_main.c chip = kzalloc(sizeof(*chip), GFP_KERNEL);
GFP_KERNEL 153 sound/pcmcia/pdaudiocf/pdaudiocf_core.c chip = kzalloc(sizeof(*chip), GFP_KERNEL);
GFP_KERNEL 901 sound/ppc/awacs.c struct awacs_amp *amp = kzalloc(sizeof(*amp), GFP_KERNEL);
GFP_KERNEL 226 sound/ppc/beep.c beep = kzalloc(sizeof(*beep), GFP_KERNEL);
GFP_KERNEL 230 sound/ppc/beep.c &beep->addr, GFP_KERNEL);
GFP_KERNEL 254 sound/ppc/daca.c mix = kzalloc(sizeof(*mix), GFP_KERNEL);
GFP_KERNEL 63 sound/ppc/keywest.c new_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
GFP_KERNEL 67 sound/ppc/pmac.c &rec->dma_base, GFP_KERNEL);
GFP_KERNEL 1190 sound/ppc/pmac.c chip = kzalloc(sizeof(*chip), GFP_KERNEL);
GFP_KERNEL 945 sound/ppc/snd_ps3.c GFP_KERNEL))) {
GFP_KERNEL 1350 sound/ppc/tumbler.c mix = kzalloc(sizeof(*mix), GFP_KERNEL);
GFP_KERNEL 361 sound/sh/aica.c channel = kmalloc(sizeof(struct aica_channel), GFP_KERNEL);
GFP_KERNEL 475 sound/sh/aica.c (GFP_KERNEL),
GFP_KERNEL 609 sound/sh/aica.c dreamcastcard = kmalloc(sizeof(struct snd_card_aica), GFP_KERNEL);
GFP_KERNEL 88 sound/soc/at32/at32-pcm.c &dmabuf->addr, GFP_KERNEL);
GFP_KERNEL 316 sound/soc/at32/at32-pcm.c prtd = kzalloc(sizeof(*prtd), GFP_KERNEL);
GFP_KERNEL 251 sound/soc/at91/at91-pcm.c prtd = kzalloc(sizeof(struct at91_runtime_data), GFP_KERNEL);
GFP_KERNEL 304 sound/soc/at91/at91-pcm.c &buf->addr, GFP_KERNEL);
GFP_KERNEL 344 sound/soc/au1x/dbdma2.c = kzalloc(sizeof(struct au1xpsc_audio_dmadata), GFP_KERNEL);
GFP_KERNEL 357 sound/soc/au1x/dbdma2.c = kzalloc(sizeof(struct au1xpsc_audio_dmadata), GFP_KERNEL);
GFP_KERNEL 249 sound/soc/au1x/psc-ac97.c kzalloc(sizeof(struct au1xpsc_audio_data), GFP_KERNEL);
GFP_KERNEL 274 sound/soc/au1x/psc-i2s.c kzalloc(sizeof(struct au1xpsc_audio_data), GFP_KERNEL);
GFP_KERNEL 116 sound/soc/au1x/sample-ac97.c ARRAY_SIZE(au1xpsc_psc1_res), GFP_KERNEL);
GFP_KERNEL 327 sound/soc/blackfin/bf5xx-ac97-pcm.c &buf->addr, GFP_KERNEL);
GFP_KERNEL 351 sound/soc/blackfin/bf5xx-ac97-pcm.c size, &sport_handle->tx_dma_phy, GFP_KERNEL);
GFP_KERNEL 364 sound/soc/blackfin/bf5xx-ac97-pcm.c size, &sport_handle->rx_dma_phy, GFP_KERNEL);
GFP_KERNEL 307 sound/soc/blackfin/bf5xx-ac97.c cmd_count = (int *)get_zeroed_page(GFP_KERNEL);
GFP_KERNEL 208 sound/soc/blackfin/bf5xx-i2s-pcm.c &buf->addr, GFP_KERNEL);
GFP_KERNEL 825 sound/soc/blackfin/bf5xx-sport.c sport = kmalloc(sizeof(struct sport_device), GFP_KERNEL);
GFP_KERNEL 878 sound/soc/blackfin/bf5xx-sport.c sport->dummy_buf = kmalloc(dummy_count * 2, GFP_KERNEL);
GFP_KERNEL 86 sound/soc/codecs/ac97.c socdev->codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL);
GFP_KERNEL 198 sound/soc/codecs/ad1980.c socdev->codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL);
GFP_KERNEL 205 sound/soc/codecs/ad1980.c kzalloc(sizeof(u16) * ARRAY_SIZE(ad1980_reg), GFP_KERNEL);
GFP_KERNEL 52 sound/soc/codecs/ad73311.c codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL);
GFP_KERNEL 499 sound/soc/codecs/ak4535.c codec->reg_cache = kmemdup(ak4535_reg, sizeof(ak4535_reg), GFP_KERNEL);
GFP_KERNEL 629 sound/soc/codecs/ak4535.c codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL);
GFP_KERNEL 633 sound/soc/codecs/ak4535.c ak4535 = kzalloc(sizeof(struct ak4535_priv), GFP_KERNEL);
GFP_KERNEL 559 sound/soc/codecs/cs4270.c codec->reg_cache = kzalloc(CS4270_NUMREGS, GFP_KERNEL);
GFP_KERNEL 660 sound/soc/codecs/cs4270.c sizeof(struct cs4270_private), GFP_KERNEL);
GFP_KERNEL 573 sound/soc/codecs/ssm2602.c GFP_KERNEL);
GFP_KERNEL 716 sound/soc/codecs/ssm2602.c codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL);
GFP_KERNEL 720 sound/soc/codecs/ssm2602.c ssm2602 = kzalloc(sizeof(struct ssm2602_priv), GFP_KERNEL);
GFP_KERNEL 540 sound/soc/codecs/tlv320aic23.c kmemdup(tlv320aic23_reg, sizeof(tlv320aic23_reg), GFP_KERNEL);
GFP_KERNEL 666 sound/soc/codecs/tlv320aic23.c codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL);
GFP_KERNEL 435 sound/soc/codecs/tlv320aic26.c aic26 = kzalloc(sizeof *aic26, GFP_KERNEL);
GFP_KERNEL 1065 sound/soc/codecs/tlv320aic3x.c codec->reg_cache = kmemdup(aic3x_reg, sizeof(aic3x_reg), GFP_KERNEL);
GFP_KERNEL 1277 sound/soc/codecs/tlv320aic3x.c codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL);
GFP_KERNEL 1281 sound/soc/codecs/tlv320aic3x.c aic3x = kzalloc(sizeof(struct aic3x_priv), GFP_KERNEL);
GFP_KERNEL 654 sound/soc/codecs/uda1380.c GFP_KERNEL);
GFP_KERNEL 795 sound/soc/codecs/uda1380.c codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL);
GFP_KERNEL 643 sound/soc/codecs/wm8510.c codec->reg_cache = kmemdup(wm8510_reg, sizeof(wm8510_reg), GFP_KERNEL);
GFP_KERNEL 832 sound/soc/codecs/wm8510.c codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL);
GFP_KERNEL 849 sound/soc/codecs/wm8580.c GFP_KERNEL);
GFP_KERNEL 925 sound/soc/codecs/wm8580.c i2c = kmemdup(&client_template, sizeof(client_template), GFP_KERNEL);
GFP_KERNEL 995 sound/soc/codecs/wm8580.c codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL);
GFP_KERNEL 999 sound/soc/codecs/wm8580.c wm8580 = kzalloc(sizeof(struct wm8580_priv), GFP_KERNEL);
GFP_KERNEL 519 sound/soc/codecs/wm8731.c codec->reg_cache = kmemdup(wm8731_reg, sizeof(wm8731_reg), GFP_KERNEL);
GFP_KERNEL 722 sound/soc/codecs/wm8731.c codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL);
GFP_KERNEL 726 sound/soc/codecs/wm8731.c wm8731 = kzalloc(sizeof(struct wm8731_priv), GFP_KERNEL);
GFP_KERNEL 784 sound/soc/codecs/wm8750.c codec->reg_cache = kmemdup(wm8750_reg, sizeof(wm8750_reg), GFP_KERNEL);
GFP_KERNEL 996 sound/soc/codecs/wm8750.c codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL);
GFP_KERNEL 1000 sound/soc/codecs/wm8750.c wm8750 = kzalloc(sizeof(struct wm8750_priv), GFP_KERNEL);
GFP_KERNEL 1565 sound/soc/codecs/wm8753.c codec->reg_cache = kmemdup(wm8753_reg, sizeof(wm8753_reg), GFP_KERNEL);
GFP_KERNEL 1789 sound/soc/codecs/wm8753.c codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL);
GFP_KERNEL 1793 sound/soc/codecs/wm8753.c wm8753 = kzalloc(sizeof(struct wm8753_priv), GFP_KERNEL);
GFP_KERNEL 1256 sound/soc/codecs/wm8900.c GFP_KERNEL);
GFP_KERNEL 1305 sound/soc/codecs/wm8900.c sizeof(wm8900_reg_defaults), GFP_KERNEL);
GFP_KERNEL 1317 sound/soc/codecs/wm8900.c codec->private_data = kzalloc(sizeof(struct wm8900_priv), GFP_KERNEL);
GFP_KERNEL 1416 sound/soc/codecs/wm8900.c i2c = kmemdup(&client_template, sizeof(client_template), GFP_KERNEL);
GFP_KERNEL 1485 sound/soc/codecs/wm8900.c codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL);
GFP_KERNEL 1545 sound/soc/codecs/wm8903.c GFP_KERNEL);
GFP_KERNEL 1592 sound/soc/codecs/wm8903.c GFP_KERNEL);
GFP_KERNEL 1727 sound/soc/codecs/wm8903.c codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL);
GFP_KERNEL 1731 sound/soc/codecs/wm8903.c wm8903 = kzalloc(sizeof(struct wm8903_priv), GFP_KERNEL);
GFP_KERNEL 707 sound/soc/codecs/wm8971.c codec->reg_cache = kmemdup(wm8971_reg, sizeof(wm8971_reg), GFP_KERNEL);
GFP_KERNEL 866 sound/soc/codecs/wm8971.c codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL);
GFP_KERNEL 870 sound/soc/codecs/wm8971.c wm8971 = kzalloc(sizeof(struct wm8971_priv), GFP_KERNEL);
GFP_KERNEL 1419 sound/soc/codecs/wm8990.c codec->reg_cache = kmemdup(wm8990_reg, sizeof(wm8990_reg), GFP_KERNEL);
GFP_KERNEL 1572 sound/soc/codecs/wm8990.c codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL);
GFP_KERNEL 1576 sound/soc/codecs/wm8990.c wm8990 = kzalloc(sizeof(struct wm8990_priv), GFP_KERNEL);
GFP_KERNEL 653 sound/soc/codecs/wm9712.c socdev->codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL);
GFP_KERNEL 659 sound/soc/codecs/wm9712.c codec->reg_cache = kmemdup(wm9712_reg, sizeof(wm9712_reg), GFP_KERNEL);
GFP_KERNEL 1199 sound/soc/codecs/wm9713.c socdev->codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL);
GFP_KERNEL 1205 sound/soc/codecs/wm9713.c codec->reg_cache = kmemdup(wm9713_reg, sizeof(wm9713_reg), GFP_KERNEL);
GFP_KERNEL 1213 sound/soc/codecs/wm9713.c codec->private_data = kzalloc(sizeof(struct wm9713_priv), GFP_KERNEL);
GFP_KERNEL 322 sound/soc/davinci/davinci-i2s.c dev = kzalloc(sizeof(struct davinci_mcbsp_dev), GFP_KERNEL);
GFP_KERNEL 240 sound/soc/davinci/davinci-pcm.c prtd = kzalloc(sizeof(struct davinci_runtime_data), GFP_KERNEL);
GFP_KERNEL 317 sound/soc/davinci/davinci-pcm.c &buf->addr, GFP_KERNEL);
GFP_KERNEL 421 sound/soc/fsl/fsl_dma.c sizeof(struct fsl_dma_private), &ld_buf_phys, GFP_KERNEL);
GFP_KERNEL 639 sound/soc/fsl/fsl_ssi.c ssi_private = kzalloc(sizeof(struct fsl_ssi_private), GFP_KERNEL);
GFP_KERNEL 742 sound/soc/fsl/mpc5200_psc_i2s.c psc_i2s = kzalloc(sizeof *psc_i2s, GFP_KERNEL);
GFP_KERNEL 232 sound/soc/fsl/mpc8610_hpcd.c machine_data = kzalloc(sizeof(struct mpc8610_hpcd_data), GFP_KERNEL);
GFP_KERNEL 54 sound/soc/fsl/soc-of-simple.c of_soc = kzalloc(sizeof(struct of_snd_soc_device), GFP_KERNEL);
GFP_KERNEL 236 sound/soc/omap/omap-pcm.c prtd = kzalloc(sizeof(prtd), GFP_KERNEL);
GFP_KERNEL 292 sound/soc/omap/omap-pcm.c &buf->addr, GFP_KERNEL);
GFP_KERNEL 337 sound/soc/s3c24xx/s3c24xx-pcm.c prtd = kzalloc(sizeof(struct s3c24xx_runtime_data), GFP_KERNEL);
GFP_KERNEL 399 sound/soc/s3c24xx/s3c24xx-pcm.c &buf->addr, GFP_KERNEL);
GFP_KERNEL 337 sound/soc/sh/dma-sh7760.c snd_dma_continuous_data(GFP_KERNEL),
GFP_KERNEL 908 sound/soc/soc-core.c rtd = kzalloc(sizeof(struct snd_soc_pcm_runtime), GFP_KERNEL);
GFP_KERNEL 1019 sound/soc/soc-core.c codec->ac97 = kzalloc(sizeof(struct snd_ac97), GFP_KERNEL);
GFP_KERNEL 1025 sound/soc/soc-core.c codec->ac97->bus = kzalloc(sizeof(struct snd_ac97_bus), GFP_KERNEL);
GFP_KERNEL 98 sound/soc/soc-dapm.c return kmemdup(_widget, sizeof(*_widget), GFP_KERNEL);
GFP_KERNEL 311 sound/soc/soc-dapm.c path->long_name = kstrdup (name, GFP_KERNEL);
GFP_KERNEL 927 sound/soc/soc-dapm.c path = kzalloc(sizeof(struct snd_soc_dapm_path), GFP_KERNEL);
GFP_KERNEL 206 sound/sound_core.c struct sound_unit *s = kmalloc(sizeof(*s), GFP_KERNEL);
GFP_KERNEL 779 sound/sparc/amd7930.c snd_dma_continuous_data(GFP_KERNEL),
GFP_KERNEL 946 sound/sparc/amd7930.c amd = kzalloc(sizeof(*amd), GFP_KERNEL);
GFP_KERNEL 2238 sound/sparc/dbri.c snd_dma_continuous_data(GFP_KERNEL),
GFP_KERNEL 41 sound/synth/emux/emux.c emu = kzalloc(sizeof(*emu), GFP_KERNEL);
GFP_KERNEL 102 sound/synth/emux/emux.c emu->name = kstrdup(name, GFP_KERNEL);
GFP_KERNEL 104 sound/synth/emux/emux.c GFP_KERNEL);
GFP_KERNEL 284 sound/synth/emux/emux_effect.c sizeof(struct snd_emux_effect_table), GFP_KERNEL);
GFP_KERNEL 149 sound/synth/emux/emux_seq.c if ((p = kzalloc(sizeof(*p), GFP_KERNEL)) == NULL) {
GFP_KERNEL 153 sound/synth/emux/emux_seq.c p->chset.channels = kcalloc(max_channels, sizeof(struct snd_midi_channel), GFP_KERNEL);
GFP_KERNEL 360 sound/synth/emux/emux_seq.c emu->vmidi = kcalloc(emu->midi_ports, sizeof(struct snd_rawmidi *), GFP_KERNEL);
GFP_KERNEL 281 sound/synth/emux/soundfont.c sf = kzalloc(sizeof(*sf), GFP_KERNEL);
GFP_KERNEL 362 sound/synth/emux/soundfont.c if ((zp = kzalloc(sizeof(*zp), GFP_KERNEL)) == NULL)
GFP_KERNEL 394 sound/synth/emux/soundfont.c if ((sp = kzalloc(sizeof(*sp), GFP_KERNEL)) == NULL)
GFP_KERNEL 1392 sound/synth/emux/soundfont.c if ((sflist = kzalloc(sizeof(*sflist), GFP_KERNEL)) == NULL)
GFP_KERNEL 41 sound/synth/util_mem.c hdr = kzalloc(sizeof(*hdr), GFP_KERNEL);
GFP_KERNEL 115 sound/synth/util_mem.c GFP_KERNEL);
GFP_KERNEL 531 sound/usb/caiaq/caiaq-audio.c urbs = kmalloc(N_URBS * sizeof(*urbs), GFP_KERNEL);
GFP_KERNEL 539 sound/usb/caiaq/caiaq-audio.c urbs[i] = usb_alloc_urb(FRAMES_PER_URB, GFP_KERNEL);
GFP_KERNEL 547 sound/usb/caiaq/caiaq-audio.c kmalloc(FRAMES_PER_URB * BYTES_PER_FRAME, GFP_KERNEL);
GFP_KERNEL 656 sound/usb/caiaq/caiaq-audio.c snd_dma_continuous_data(GFP_KERNEL),
GFP_KERNEL 661 sound/usb/caiaq/caiaq-audio.c GFP_KERNEL);
GFP_KERNEL 396 sound/usb/caiaq/caiaq-device.c if (usb_submit_urb(&dev->ep1_in_urb, GFP_KERNEL) != 0)
GFP_KERNEL 1141 sound/usb/usbaudio.c u->urb = usb_alloc_urb(u->packets, GFP_KERNEL);
GFP_KERNEL 1145 sound/usb/usbaudio.c usb_buffer_alloc(subs->dev, u->buffer_size, GFP_KERNEL,
GFP_KERNEL 1159 sound/usb/usbaudio.c GFP_KERNEL, &subs->sync_dma);
GFP_KERNEL 1167 sound/usb/usbaudio.c u->urb = usb_alloc_urb(1, GFP_KERNEL);
GFP_KERNEL 1767 sound/usb/usbaudio.c channels = kcalloc(MAX_MASK, sizeof(u32), GFP_KERNEL);
GFP_KERNEL 1768 sound/usb/usbaudio.c rates = kcalloc(MAX_MASK, sizeof(u32), GFP_KERNEL);
GFP_KERNEL 1864 sound/usb/usbaudio.c subs->rate_list.list = kmalloc(sizeof(int) * count, GFP_KERNEL);
GFP_KERNEL 2096 sound/usb/usbaudio.c buf = kmemdup(data, size, GFP_KERNEL);
GFP_KERNEL 2366 sound/usb/usbaudio.c as = kzalloc(sizeof(*as), GFP_KERNEL);
GFP_KERNEL 2529 sound/usb/usbaudio.c fp->rate_table = kmalloc(sizeof(int) * nr_rates, GFP_KERNEL);
GFP_KERNEL 2767 sound/usb/usbaudio.c fp = kzalloc(sizeof(*fp), GFP_KERNEL);
GFP_KERNEL 2939 sound/usb/usbaudio.c fp = kmemdup(quirk->data, sizeof(*fp), GFP_KERNEL);
GFP_KERNEL 2945 sound/usb/usbaudio.c rate_table = kmalloc(sizeof(int) * fp->nr_rates, GFP_KERNEL);
GFP_KERNEL 3054 sound/usb/usbaudio.c fp = kmalloc(sizeof(*fp), GFP_KERNEL);
GFP_KERNEL 3121 sound/usb/usbaudio.c fp = kmemdup(&ua1000_format, sizeof(*fp), GFP_KERNEL);
GFP_KERNEL 3173 sound/usb/usbaudio.c fp = kmemdup(&ua101_format, sizeof(*fp), GFP_KERNEL);
GFP_KERNEL 3472 sound/usb/usbaudio.c chip = kzalloc(sizeof(*chip), GFP_KERNEL);
GFP_KERNEL 334 sound/usb/usbmidi.c void *buf = kmemdup(data, len, GFP_KERNEL);
GFP_KERNEL 948 sound/usb/usbmidi.c ep = kzalloc(sizeof(*ep), GFP_KERNEL);
GFP_KERNEL 953 sound/usb/usbmidi.c ep->urb = usb_alloc_urb(0, GFP_KERNEL);
GFP_KERNEL 963 sound/usb/usbmidi.c buffer = usb_buffer_alloc(umidi->chip->dev, length, GFP_KERNEL,
GFP_KERNEL 1019 sound/usb/usbmidi.c ep = kzalloc(sizeof(*ep), GFP_KERNEL);
GFP_KERNEL 1024 sound/usb/usbmidi.c ep->urb = usb_alloc_urb(0, GFP_KERNEL);
GFP_KERNEL 1039 sound/usb/usbmidi.c GFP_KERNEL, &ep->urb->transfer_dma);
GFP_KERNEL 1712 sound/usb/usbmidi.c snd_usbmidi_submit_urb(urb, GFP_KERNEL);
GFP_KERNEL 1741 sound/usb/usbmidi.c umidi = kzalloc(sizeof(*umidi), GFP_KERNEL);
GFP_KERNEL 890 sound/usb/usbmixer.c cval = kzalloc(sizeof(*cval), GFP_KERNEL);
GFP_KERNEL 1069 sound/usb/usbmixer.c cval = kzalloc(sizeof(*cval), GFP_KERNEL);
GFP_KERNEL 1316 sound/usb/usbmixer.c cval = kzalloc(sizeof(*cval), GFP_KERNEL);
GFP_KERNEL 1503 sound/usb/usbmixer.c cval = kzalloc(sizeof(*cval), GFP_KERNEL);
GFP_KERNEL 1517 sound/usb/usbmixer.c namelist = kmalloc(sizeof(char *) * num_ins, GFP_KERNEL);
GFP_KERNEL 1527 sound/usb/usbmixer.c namelist[i] = kmalloc(MAX_ITEM_NAME_LEN, GFP_KERNEL);
GFP_KERNEL 1764 sound/usb/usbmixer.c transfer_buffer = kmalloc(buffer_length, GFP_KERNEL);
GFP_KERNEL 1767 sound/usb/usbmixer.c mixer->urb = usb_alloc_urb(0, GFP_KERNEL);
GFP_KERNEL 1776 sound/usb/usbmixer.c usb_submit_urb(mixer->urb, GFP_KERNEL);
GFP_KERNEL 1875 sound/usb/usbmixer.c mixer->rc_urb = usb_alloc_urb(0, GFP_KERNEL);
GFP_KERNEL 1878 sound/usb/usbmixer.c mixer->rc_setup_packet = kmalloc(sizeof(*mixer->rc_setup_packet), GFP_KERNEL);
GFP_KERNEL 2028 sound/usb/usbmixer.c mixer = kzalloc(sizeof(*mixer), GFP_KERNEL);
GFP_KERNEL 2034 sound/usb/usbmixer.c mixer->id_elems = kcalloc(256, sizeof(*mixer->id_elems), GFP_KERNEL);
GFP_KERNEL 82 sound/usb/usx2y/us122l.c buf = kmemdup(data, size, GFP_KERNEL);
GFP_KERNEL 351 sound/usb/usx2y/us122l.c cfg = kmalloc(sizeof(*cfg), GFP_KERNEL);
GFP_KERNEL 81 sound/usb/usx2y/usX2Yhwdep.c if(!(us428->us428ctls_sharedmem = snd_malloc_pages(sizeof(struct us428ctls_sharedmem), GFP_KERNEL)))
GFP_KERNEL 219 sound/usb/usx2y/usX2Yhwdep.c char *buf = kmalloc(dsp->length, GFP_KERNEL);
GFP_KERNEL 108 sound/usb/usx2y/usb_stream.c sk->inurb[u] = usb_alloc_urb(sk->n_o_ps, GFP_KERNEL);
GFP_KERNEL 109 sound/usb/usx2y/usb_stream.c sk->outurb[u] = usb_alloc_urb(sk->n_o_ps, GFP_KERNEL);
GFP_KERNEL 200 sound/usb/usx2y/usb_stream.c sk->s = (void *) __get_free_pages(GFP_KERNEL|__GFP_COMP|__GFP_ZERO, pg);
GFP_KERNEL 220 sound/usb/usx2y/usb_stream.c (void *)__get_free_pages(GFP_KERNEL|__GFP_COMP|__GFP_ZERO, pg);
GFP_KERNEL 268 sound/usb/usx2y/usbusx2y.c if (NULL == (usX2Y->AS04.buffer = kmalloc(URB_DataLen_AsyncSeq*URBS_AsyncSeq, GFP_KERNEL))) {
GFP_KERNEL 272 sound/usb/usx2y/usbusx2y.c if (NULL == (usX2Y->AS04.urb[i] = usb_alloc_urb(0, GFP_KERNEL))) {
GFP_KERNEL 287 sound/usb/usx2y/usbusx2y.c if (! (usX2Y->In04urb = usb_alloc_urb(0, GFP_KERNEL)))
GFP_KERNEL 290 sound/usb/usx2y/usbusx2y.c if (! (usX2Y->In04Buf = kmalloc(21, GFP_KERNEL))) {
GFP_KERNEL 300 sound/usb/usx2y/usbusx2y.c return usb_submit_urb(usX2Y->In04urb, GFP_KERNEL);
GFP_KERNEL 435 sound/usb/usx2y/usbusx2yaudio.c subs->tmpbuf = kcalloc(nr_of_packs(), subs->maxpacksize, GFP_KERNEL);
GFP_KERNEL 448 sound/usb/usx2y/usbusx2yaudio.c *purb = usb_alloc_urb(nr_of_packs(), GFP_KERNEL);
GFP_KERNEL 455 sound/usb/usx2y/usbusx2yaudio.c (*purb)->transfer_buffer = kmalloc(subs->maxpacksize * nr_of_packs(), GFP_KERNEL);
GFP_KERNEL 677 sound/usb/usx2y/usbusx2yaudio.c us = kzalloc(sizeof(*us) + sizeof(struct urb*) * NOOF_SETRATE_URBS, GFP_KERNEL);
GFP_KERNEL 682 sound/usb/usx2y/usbusx2yaudio.c usbdata = kmalloc(sizeof(int) * NOOF_SETRATE_URBS, GFP_KERNEL);
GFP_KERNEL 688 sound/usb/usx2y/usbusx2yaudio.c if (NULL == (us->urb[i] = usb_alloc_urb(0, GFP_KERNEL))) {
GFP_KERNEL 751 sound/usb/usx2y/usbusx2yaudio.c err = usb_submit_urb(usX2Y->In04urb, GFP_KERNEL);
GFP_KERNEL 960 sound/usb/usx2y/usbusx2yaudio.c usX2Y_substream[i] = kzalloc(sizeof(struct snd_usX2Y_substream), GFP_KERNEL);
GFP_KERNEL 993 sound/usb/usx2y/usbusx2yaudio.c snd_dma_continuous_data(GFP_KERNEL),
GFP_KERNEL 997 sound/usb/usx2y/usbusx2yaudio.c snd_dma_continuous_data(GFP_KERNEL),
GFP_KERNEL 336 sound/usb/usx2y/usx2yhwdeppcm.c *purb = usb_alloc_urb(nr_of_packs(), GFP_KERNEL);
GFP_KERNEL 451 sound/usb/usx2y/usx2yhwdeppcm.c if ((err = usb_submit_urb(urb, GFP_KERNEL)) < 0) {
GFP_KERNEL 496 sound/usb/usx2y/usx2yhwdeppcm.c if (NULL == (usX2Y->hwdep_pcm_shm = snd_malloc_pages(sizeof(struct snd_usX2Y_hwdep_pcm_shm), GFP_KERNEL)))
GFP_KERNEL 773 sound/usb/usx2y/usx2yhwdeppcm.c snd_dma_continuous_data(GFP_KERNEL),
GFP_KERNEL 777 sound/usb/usx2y/usx2yhwdeppcm.c snd_dma_continuous_data(GFP_KERNEL),
GFP_KERNEL 90 virt/kvm/coalesced_mmio.c dev = kzalloc(sizeof(struct kvm_coalesced_mmio_dev), GFP_KERNEL);
GFP_KERNEL 408 virt/kvm/ioapic.c ioapic = kzalloc(sizeof(struct kvm_ioapic), GFP_KERNEL);
GFP_KERNEL 169 virt/kvm/kvm_main.c page = alloc_page(GFP_KERNEL | __GFP_ZERO);
GFP_KERNEL 323 virt/kvm/kvm_main.c page = alloc_page(GFP_KERNEL | __GFP_ZERO);
GFP_KERNEL 1135 virt/kvm/kvm_main.c kvm_regs = kzalloc(sizeof(struct kvm_regs), GFP_KERNEL);
GFP_KERNEL 1153 virt/kvm/kvm_main.c kvm_regs = kzalloc(sizeof(struct kvm_regs), GFP_KERNEL);
GFP_KERNEL 1715 virt/kvm/kvm_main.c bad_page = alloc_page(GFP_KERNEL | __GFP_ZERO);
GFP_KERNEL 162 virt/kvm/kvm_trace.c kt = kzalloc(sizeof(*kt), GFP_KERNEL);