Rename KMALLOC_* -> MEM_* [2/2]
authorBarret Rhoden <brho@cs.berkeley.edu>
Fri, 25 Mar 2016 16:28:55 +0000 (12:28 -0400)
committerBarret Rhoden <brho@cs.berkeley.edu>
Thu, 31 Mar 2016 20:53:42 +0000 (16:53 -0400)
The rename were done with this:

@@
@@
-KMALLOC_WAIT
+MEM_WAIT

@@
@@
-KMALLOC_ERROR
+MEM_ERROR

except for uses of the names in comments.

Signed-off-by: Barret Rhoden <brho@cs.berkeley.edu>
80 files changed:
kern/arch/x86/devarch.c
kern/arch/x86/msi.c
kern/arch/x86/perfmon.c
kern/arch/x86/pmap64.c
kern/arch/x86/vmm/intel/vmx.c
kern/arch/x86/vmm/vmm.c
kern/drivers/dev/acpi.c
kern/drivers/dev/alarm.c
kern/drivers/dev/eventfd.c
kern/drivers/dev/kprof.c
kern/drivers/dev/mnt.c
kern/drivers/dev/proc.c
kern/drivers/dev/root.c
kern/drivers/dev/srv.c
kern/drivers/dev/vars.c
kern/drivers/dev/version.c
kern/drivers/net/bnx2x/bnx2x.h
kern/drivers/net/bnx2x/bnx2x_cmn.c
kern/drivers/net/bnx2x/bnx2x_cmn.h
kern/drivers/net/bnx2x/bnx2x_dev.c
kern/drivers/net/bnx2x/bnx2x_ethtool.c
kern/drivers/net/bnx2x/bnx2x_main.c
kern/drivers/net/bnx2x/bnx2x_sriov.c
kern/drivers/net/bnx2x/bnx2x_vfpf.c
kern/drivers/net/ether8139.c
kern/drivers/net/ether8169.c
kern/drivers/net/ether82563.c
kern/drivers/net/etherigbe.c
kern/drivers/net/mlx4/alloc.c
kern/drivers/net/mlx4/cmd.c
kern/drivers/net/mlx4/cq.c
kern/drivers/net/mlx4/en_cq.c
kern/drivers/net/mlx4/en_ethtool.c
kern/drivers/net/mlx4/en_main.c
kern/drivers/net/mlx4/en_netdev.c
kern/drivers/net/mlx4/en_resources.c
kern/drivers/net/mlx4/en_rx.c
kern/drivers/net/mlx4/en_tx.c
kern/drivers/net/mlx4/eq.c
kern/drivers/net/mlx4/icm.c
kern/drivers/net/mlx4/intf.c
kern/drivers/net/mlx4/main.c
kern/drivers/net/mlx4/mcg.c
kern/drivers/net/mlx4/mr.c
kern/drivers/net/mlx4/pd.c
kern/drivers/net/mlx4/profile.c
kern/drivers/net/mlx4/qp.c
kern/drivers/net/mlx4/reset.c
kern/drivers/net/mlx4/resource_tracker.c
kern/drivers/net/mlx4/srq.c
kern/drivers/net/udrvr/compat.h
kern/include/kmalloc.h
kern/include/linux/compat_todo.h
kern/include/linux_compat.h
kern/lib/circular_buffer.c
kern/lib/slice.c
kern/lib/zlib_inflate/infutil.c
kern/src/dmapool.c
kern/src/fdtap.c
kern/src/ktest/pb_ktests.c
kern/src/net/arp.c
kern/src/net/devip.c
kern/src/net/dial.c
kern/src/net/ethermedium.c
kern/src/net/tcp.c
kern/src/ns/allocb.c
kern/src/ns/dev.c
kern/src/ns/devtab.c
kern/src/ns/pgrp.c
kern/src/ns/qio.c
kern/src/ns/sysfile.c
kern/src/page_alloc.c
kern/src/process.c
kern/src/profiler.c
kern/src/slab.c
kern/src/smallidpool.c
kern/src/syscall.c
kern/src/vfs.c
scripts/plan9
scripts/spatch/linux/memory.cocci

index a018210..2a45f6e 100644 (file)
@@ -322,7 +322,7 @@ static struct perf_context *arch_create_perf_context(void)
 {
        ERRSTACK(1);
        struct perf_context *pc = kzmalloc(sizeof(struct perf_context),
-                                          KMALLOC_WAIT);
+                                          MEM_WAIT);
 
        if (waserror()) {
                kfree(pc);
@@ -400,7 +400,7 @@ static long arch_perf_write(struct perf_context *pc, const void *udata,
                        ped = perfmon_open_event(&cset, pc->ps, &pev);
 
                        pc->resp_size = sizeof(uint32_t);
-                       pc->resp = kmalloc(pc->resp_size, KMALLOC_WAIT);
+                       pc->resp = kmalloc(pc->resp_size, MEM_WAIT);
                        put_le_u32(pc->resp, (uint32_t) ped);
                        break;
                }
@@ -416,13 +416,14 @@ static long arch_perf_write(struct perf_context *pc, const void *udata,
 
                        pef = perfmon_get_event_status(pc->ps, (int) ped);
 
-                       mvalues = kzmalloc(num_cores * sizeof(mvalues), KMALLOC_WAIT);
+                       mvalues = kzmalloc(num_cores * sizeof(mvalues),
+                                          MEM_WAIT);
                        for (i = 0; i < num_cores; i++)
                                mvalues[i] = pef->cores_values[i];
 
                        pc->resp_size = 3 * sizeof(uint64_t) + sizeof(uint32_t) +
                                num_cores * sizeof(uint64_t);
-                       pc->resp = kmalloc(pc->resp_size, KMALLOC_WAIT);
+                       pc->resp = kmalloc(pc->resp_size, MEM_WAIT);
 
                        rptr = put_le_u64(pc->resp, pef->ev.event);
                        rptr = put_le_u64(rptr, pef->ev.flags);
@@ -451,7 +452,7 @@ static long arch_perf_write(struct perf_context *pc, const void *udata,
                        perfmon_get_cpu_caps(&pcc);
 
                        pc->resp_size = 6 * sizeof(uint32_t);
-                       pc->resp = kmalloc(pc->resp_size, KMALLOC_WAIT);
+                       pc->resp = kmalloc(pc->resp_size, MEM_WAIT);
 
                        rptr = put_le_u32(pc->resp, pcc.perfmon_version);
                        rptr = put_le_u32(rptr, pcc.proc_arch_events);
@@ -548,7 +549,8 @@ static long archread(struct chan *c, void *a, long n, int64_t offset)
                        core_set_init(&cset);
                        core_set_fill_available(&cset);
                        msr_set_address(&msra, (uint32_t) offset);
-                       values = kzmalloc(num_cores * sizeof(uint64_t), KMALLOC_WAIT);
+                       values = kzmalloc(num_cores * sizeof(uint64_t),
+                                         MEM_WAIT);
                        if (!values)
                                error(ENOMEM, ERROR_FIXME);
                        msr_set_values(&msrv, values, num_cores);
index 292677c..e792f2e 100644 (file)
@@ -362,7 +362,7 @@ struct msix_irq_vector *pci_msix_enable(struct pci_device *p, uint64_t vec)
                spin_unlock_irqsave(&p->lock);
                return 0;
        }
-       linkage = kmalloc(sizeof(struct msix_irq_vector), KMALLOC_WAIT);
+       linkage = kmalloc(sizeof(struct msix_irq_vector), MEM_WAIT);
        linkage->pcidev = p;
        linkage->entry = entry;
        linkage->addr_lo = msi_make_addr_lo(vec);
index 6b07eef..08ed5ad 100644 (file)
@@ -266,7 +266,7 @@ static struct perfmon_alloc *perfmon_create_alloc(const struct perfmon_event *pe
        int i;
        struct perfmon_alloc *pa = kzmalloc(sizeof(struct perfmon_alloc) +
                                                num_cores * sizeof(counter_t),
-                                           KMALLOC_WAIT);
+                                           MEM_WAIT);
 
        kref_init(&pa->ref, perfmon_release_alloc, 1);
        pa->ev = *pev;
@@ -280,7 +280,7 @@ static struct perfmon_status *perfmon_alloc_status(void)
 {
        struct perfmon_status *pef = kzmalloc(sizeof(struct perfmon_status) +
                                                  num_cores * sizeof(uint64_t),
-                                             KMALLOC_WAIT);
+                                             MEM_WAIT);
 
        return pef;
 }
@@ -506,7 +506,7 @@ static void perfmon_release_session(struct kref *kref)
 struct perfmon_session *perfmon_create_session(void)
 {
        struct perfmon_session *ps = kzmalloc(sizeof(struct perfmon_session),
-                                             KMALLOC_WAIT);
+                                             MEM_WAIT);
 
        kref_init(&ps->ref, perfmon_release_session, 1);
        spinlock_init(&ps->lock);
index 9fe20a6..1c2ac2d 100644 (file)
@@ -102,7 +102,7 @@ static kpte_t *__pml_walk(kpte_t *pml, uintptr_t va, int flags, int pml_shift)
        if (!kpte_is_present(kpte)) {
                if (!(flags & PG_WALK_CREATE))
                        return NULL;
-               new_pml_kva = get_cont_pages(1, KMALLOC_WAIT);
+               new_pml_kva = get_cont_pages(1, MEM_WAIT);
                memset(new_pml_kva, 0, PGSIZE * 2);
                /* Might want better error handling (we're probably out of memory) */
                if (!new_pml_kva)
@@ -623,7 +623,7 @@ uintptr_t gva2gpa(struct proc *p, uintptr_t cr3, uintptr_t gva)
  * data segment). */
 int arch_pgdir_setup(pgdir_t boot_copy, pgdir_t *new_pd)
 {
-       kpte_t *kpt = get_cont_pages(1, KMALLOC_WAIT);
+       kpte_t *kpt = get_cont_pages(1, MEM_WAIT);
        memcpy(kpt, boot_copy.kpte, PGSIZE);
        epte_t *ept = kpte_to_epte(kpt);
        memset(ept, 0, PGSIZE);
index 2363594..5a93c5a 100644 (file)
@@ -692,7 +692,7 @@ __vmx_alloc_vmcs(int node)
 {
        struct vmcs *vmcs;
 
-       vmcs = get_cont_pages_node(node, vmcs_config.order, KMALLOC_WAIT);
+       vmcs = get_cont_pages_node(node, vmcs_config.order, MEM_WAIT);
        if (!vmcs)
                return 0;
        memset(vmcs, 0, vmcs_config.size);
@@ -1112,7 +1112,8 @@ static void vmx_setup_vmcs(struct guest_pcore *gpc)
 struct guest_pcore *create_guest_pcore(struct proc *p,
                                        struct vmm_gpcore_init *gpci)
 {
-       struct guest_pcore *gpc = kmalloc(sizeof(struct guest_pcore), KMALLOC_WAIT);
+       struct guest_pcore *gpc = kmalloc(sizeof(struct guest_pcore),
+                                         MEM_WAIT);
        int ret;
 
        if (!gpc)
@@ -1303,7 +1304,7 @@ int intel_vmm_init(void) {
                return -ENOMEM;
        }
        io_bitmap = (unsigned long *)get_cont_pages(VMX_IO_BITMAP_ORDER,
-                                                   KMALLOC_WAIT);
+                                                   MEM_WAIT);
        if (!io_bitmap) {
                printk("Could not allocate msr_bitmap\n");
                kfree(msr_bitmap);
index bdbf530..0287ad4 100644 (file)
@@ -95,7 +95,8 @@ int vmm_struct_init(struct proc *p, unsigned int nr_guest_pcores,
        vmm->vmmcp = TRUE;
        nr_guest_pcores = MIN(nr_guest_pcores, num_cores);
        vmm->amd = 0;
-       vmm->guest_pcores = kzmalloc(sizeof(void*) * nr_guest_pcores, KMALLOC_WAIT);
+       vmm->guest_pcores = kzmalloc(sizeof(void*) * nr_guest_pcores,
+                                    MEM_WAIT);
        for (i = 0; i < nr_guest_pcores; i++) {
                if (copy_from_user(&gpci, &u_gpcis[i],
                                   sizeof(struct vmm_gpcore_init))) {
index 8ba9eb4..66ab1a0 100644 (file)
@@ -130,7 +130,7 @@ struct Atable *mkatable(struct Atable *parent,
        void *m;
        struct Atable *t;
 
-       m = kzmalloc(ATABLEBUFSZ + addsize, KMALLOC_WAIT);
+       m = kzmalloc(ATABLEBUFSZ + addsize, MEM_WAIT);
        if (m == NULL)
                panic("no memory for more aml tables");
        t = m;
@@ -160,7 +160,7 @@ struct Atable *finatable(struct Atable *t, struct slice *slice)
        t->nchildren = n;
        t->children = (struct Atable **)slice_finalize(slice);
        dirs = kreallocarray(NULL, n + NQtypes, sizeof(struct dirtab),
-                            KMALLOC_WAIT);
+                            MEM_WAIT);
        assert(dirs != NULL);
        dirs[0] = (struct dirtab){ ".",      t->qid,   0, 0555 };
        dirs[1] = (struct dirtab){ "pretty", t->pqid,  0, 0444 };
@@ -498,7 +498,7 @@ static void *sdtmap(uintptr_t pa, size_t *n, int cksum)
                printk("acpi: SDT: bad checksum. pa = %p, len = %lu\n", pa, *n);
                return NULL;
        }
-       p = kzmalloc(sizeof(struct Acpilist) + *n, KMALLOC_WAIT);
+       p = kzmalloc(sizeof(struct Acpilist) + *n, MEM_WAIT);
        if (p == NULL)
                panic("sdtmap: memory allocation failed for %lu bytes", *n);
        memmove(p->raw, (void *)sdt, *n);
@@ -1543,7 +1543,7 @@ static void parsersdptr(void)
        printd("acpi: XSDT %#p\n", xsdt);
        parsexsdt(root);
        atableindex = kreallocarray(NULL, lastpath, sizeof(struct Atable *),
-                                   KMALLOC_WAIT);
+                                   MEM_WAIT);
        assert(atableindex != NULL);
        makeindex(root);
 }
index 391635f..254ed77 100644 (file)
@@ -251,7 +251,7 @@ static struct chan *alarmopen(struct chan *c, int omode)
                                error(EISDIR, ERROR_FIXME);
                        break;
                case Qclone:
-                       a = kzmalloc(sizeof(struct proc_alarm), KMALLOC_WAIT);
+                       a = kzmalloc(sizeof(struct proc_alarm), MEM_WAIT);
                        kref_init(&a->kref, alarm_release, 1);
                        init_awaiter(&a->a_waiter, proc_alarm_handler);
                        spin_lock(&p->alarmset.lock);
index d66081a..2287b25 100644 (file)
@@ -70,7 +70,7 @@ static struct chan *efd_attach(char *spec)
        struct eventfd *efd;
 
        c = devattach(devname(), spec);
-       efd = kzmalloc(sizeof(struct eventfd), KMALLOC_WAIT);
+       efd = kzmalloc(sizeof(struct eventfd), MEM_WAIT);
        SLIST_INIT(&efd->fd_taps);
        spinlock_init(&efd->tap_lock);
        rendez_init(&efd->rv_readers);
index f07a0e9..cb777db 100644 (file)
@@ -166,7 +166,7 @@ static void kprof_start_profiler(void)
 static void kprof_fetch_profiler_data(void)
 {
        size_t psize = kprof.psize + profiler_size();
-       char *ndata = krealloc(kprof.pdata, psize, KMALLOC_WAIT);
+       char *ndata = krealloc(kprof.pdata, psize, MEM_WAIT);
 
        if (!ndata)
                error(ENOMEM, ERROR_FIXME);
@@ -231,7 +231,7 @@ static void kprof_init(void)
        kprof.psize = 0;
 
        kprof.alarms = kzmalloc(sizeof(struct alarm_waiter) * num_cores,
-                               KMALLOC_WAIT);
+                               MEM_WAIT);
        if (!kprof.alarms)
                error(ENOMEM, ERROR_FIXME);
        if (waserror()) {
@@ -325,7 +325,7 @@ static void kprof_close(struct chan *c)
 static long mpstat_read(void *va, long n, int64_t off)
 {
        size_t bufsz = mpstat_len();
-       char *buf = kmalloc(bufsz, KMALLOC_WAIT);
+       char *buf = kmalloc(bufsz, MEM_WAIT);
        int len = 0;
        struct per_cpu_info *pcpui;
        uint64_t cpu_total;
@@ -363,7 +363,7 @@ static long mpstat_read(void *va, long n, int64_t off)
 static long mpstatraw_read(void *va, long n, int64_t off)
 {
        size_t bufsz = mpstatraw_len();
-       char *buf = kmalloc(bufsz, KMALLOC_WAIT);
+       char *buf = kmalloc(bufsz, MEM_WAIT);
        int len = 0;
        struct per_cpu_info *pcpui;
 
index 7a2fbc3..c0628de 100644 (file)
@@ -440,7 +440,7 @@ static struct walkqid *mntwalk(struct chan *c, struct chan *nc, char **name,
                error(EFAIL, "devmnt: too many name elements");
        alloc = 0;
        wq = kzmalloc(sizeof(struct walkqid) + nname * sizeof(struct qid),
-                                 KMALLOC_WAIT);
+                                 MEM_WAIT);
        if (waserror()) {
                if (alloc && wq->clone != NULL)
                        cclose(wq->clone);
@@ -1121,7 +1121,7 @@ struct mntrpc *mntralloc(struct chan *c, uint32_t msize)
                 * The header is split from the data buffer as
                 * mountmux may swap the buffer with another header.
                 */
-               new->rpc = kzmalloc(msize, KMALLOC_WAIT);
+               new->rpc = kzmalloc(msize, MEM_WAIT);
                if (new->rpc == NULL) {
                        kfree(new);
                        spin_unlock(&mntalloc.l);
@@ -1139,7 +1139,7 @@ struct mntrpc *mntralloc(struct chan *c, uint32_t msize)
                mntalloc.nrpcfree--;
                if (new->rpclen < msize) {
                        kfree(new->rpc);
-                       new->rpc = kzmalloc(msize, KMALLOC_WAIT);
+                       new->rpc = kzmalloc(msize, MEM_WAIT);
                        if (new->rpc == NULL) {
                                kfree(new);
                                mntalloc.nrpcused--;
index ccbe92d..e11f2f7 100644 (file)
@@ -439,10 +439,10 @@ static struct chan *procopen(struct chan *c, int omode)
                topens++;
                if (tevents == NULL) {
                        tevents = (Traceevent *) kzmalloc(sizeof(Traceevent) * Nevents,
-                                                                                         KMALLOC_WAIT);
+                                                                                         MEM_WAIT);
                        if (tevents == NULL)
                                error(ENOMEM, ERROR_FIXME);
-                       tpids = kzmalloc(Ntracedpids * 20, KMALLOC_WAIT);
+                       tpids = kzmalloc(Ntracedpids * 20, MEM_WAIT);
                        if (tpids == NULL) {
                                kfree(tpids);
                                tpids = NULL;
@@ -535,7 +535,7 @@ static struct chan *procopen(struct chan *c, int omode)
                case Qns:
                        if (omode != O_READ)
                                error(EPERM, ERROR_FIXME);
-                       c->aux = kzmalloc(sizeof(struct mntwalk), KMALLOC_WAIT);
+                       c->aux = kzmalloc(sizeof(struct mntwalk), MEM_WAIT);
                        break;
                case Qstatus:
                case Qvmstatus:
@@ -619,7 +619,7 @@ static int procwstat(struct chan *c, uint8_t * db, int n)
        if (strcmp(current->user, p->user) != 0 && strcmp(current->user, eve) != 0)
                error(EPERM, ERROR_FIXME);
 
-       d = kzmalloc(sizeof(struct dir) + n, KMALLOC_WAIT);
+       d = kzmalloc(sizeof(struct dir) + n, MEM_WAIT);
        n = convM2D(db, n, &d[0], (char *)&d[1]);
        if (n == 0)
                error(ENOENT, ERROR_FIXME);
@@ -788,11 +788,11 @@ static char *argcpy(char *s, char *p)
        if (n > 128)
                n = 128;
        if (n <= 0) {
-               t = kzmalloc(1, KMALLOC_WAIT);
+               t = kzmalloc(1, MEM_WAIT);
                *t = 0;
                return t;
        }
-       t = kzmalloc(n, KMALLOC_WAIT);
+       t = kzmalloc(n, MEM_WAIT);
        tp = t;
        te = t + n;
 
@@ -872,7 +872,7 @@ static long procread(struct chan *c, void *va, long n, int64_t off)
                case Qstatus:{
                                /* the old code grew the stack and was hideous.
                                 * status is not a high frequency operation; just malloc. */
-                               char *buf = kmalloc(4096, KMALLOC_WAIT);
+                               char *buf = kmalloc(4096, MEM_WAIT);
                                char *s = buf, *e = buf + 4096;
                                int i;
 
@@ -893,7 +893,7 @@ static long procread(struct chan *c, void *va, long n, int64_t off)
                case Qvmstatus:
                        {
                                size_t buflen = 50 * 65 + 2;
-                               char *buf = kmalloc(buflen, KMALLOC_WAIT);
+                               char *buf = kmalloc(buflen, MEM_WAIT);
                                int i, offset;
                                offset = 0;
                                offset += snprintf(buf + offset, buflen - offset, "{\n");
@@ -1023,7 +1023,7 @@ static long procwrite(struct chan *c, void *va, long n, int64_t off)
                        if (n >= sizeof buf - strlen(p->text) - 1)
                                error(E2BIG, ERROR_FIXME);
                        l = snprintf(buf, sizeof buf, "%s [%s]", p->text, (char *)va);
-                       args = kzmalloc(l + 1, KMALLOC_WAIT);
+                       args = kzmalloc(l + 1, MEM_WAIT);
                        if (args == NULL)
                                error(ENOMEM, ERROR_FIXME);
                        memmove(args, buf, l);
@@ -1256,7 +1256,7 @@ static void procctlreq(struct proc *p, char *va, int n)
        case CMstraceme:
                /* common allocation.  if we inherited, we might have one already */
                if (!p->strace) {
-                       strace = kzmalloc(sizeof(*p->strace), KMALLOC_WAIT);
+                       strace = kzmalloc(sizeof(*p->strace), MEM_WAIT);
                        strace->q = qopen(65536, Qdropoverflow|Qcoalesce, NULL, NULL);
                        /* both of these refs are put when the proc is freed.  procs is for
                         * every process that has this p->strace.  users is procs + every
index 178213f..75c924d 100644 (file)
@@ -429,7 +429,7 @@ static long rootwrite(struct chan *c, void *a, long n, int64_t off)
 
        if (off + n > rd->size){
                void *p;
-               p = krealloc(rd->ptr, off + n, KMALLOC_WAIT);
+               p = krealloc(rd->ptr, off + n, MEM_WAIT);
                if (! p)
                        error(EFAIL, "rootwrite: could not grow the file to %d bytes",
                                  off + n);
@@ -454,7 +454,7 @@ static int rootwstat(struct chan *c, uint8_t *m_buf, int m_buf_sz)
        /* common trick in wstats.  we want the dir and any strings in the M.  the
         * strings are smaller than entire M (strings plus other M).  the strings
         * will be placed right after the dir (dir[1]) */
-       dir = kzmalloc(sizeof(struct dir) + m_buf_sz, KMALLOC_WAIT);
+       dir = kzmalloc(sizeof(struct dir) + m_buf_sz, MEM_WAIT);
        m_sz = convM2D(m_buf, m_buf_sz, &dir[0], (char*)&dir[1]);
        if (!m_sz) {
                kfree(dir);
index d20e782..ba4e144 100644 (file)
@@ -126,7 +126,7 @@ static int srvgen(struct chan *c, char *name, struct dirtab *tab,
 
 static void __srvinit(void)
 {
-       top_dir = kzmalloc(sizeof(struct srvfile), KMALLOC_WAIT);
+       top_dir = kzmalloc(sizeof(struct srvfile), MEM_WAIT);
        /* kstrdup, just in case we free this later */
        kstrdup(&top_dir->name, "srv");
        kstrdup(&top_dir->user, current ? current->user : "eve");
@@ -233,7 +233,7 @@ static struct chan *srvopen(struct chan *c, int omode)
 static void srvcreate(struct chan *c, char *name, int omode, uint32_t perm)
 {
        struct srvfile *srv;
-       srv = kzmalloc(sizeof(struct srvfile), KMALLOC_WAIT);
+       srv = kzmalloc(sizeof(struct srvfile), MEM_WAIT);
        kstrdup(&srv->name, name);
        kstrdup(&srv->user, current ? current->user : "eve");
        srv->perm = 0770;       /* TODO need some security thoughts */
@@ -311,7 +311,7 @@ static long srvwrite(struct chan *c, void *va, long count, int64_t offset)
                kfree(kbuf);
                nexterror();
        }
-       kbuf = kmalloc(count + 1, KMALLOC_WAIT);
+       kbuf = kmalloc(count + 1, MEM_WAIT);
        strlcpy(kbuf, va, count + 1);
        fd = strtoul(kbuf, 0, 10);
        /* the magic of srv: srv stores the chan corresponding to the fd.  -1 for
index a295629..50fc022 100644 (file)
@@ -81,7 +81,7 @@ static void vars_init(void)
        struct dirtab *dot, temp;
 
        nr_vars = &__stop_devvars - &__start_devvars;
-       vars_dir = kmalloc_array(nr_vars, sizeof(struct dirtab), KMALLOC_WAIT);
+       vars_dir = kmalloc_array(nr_vars, sizeof(struct dirtab), MEM_WAIT);
        if (!vars_dir)
                error(ENOMEM, "kmalloc_array failed, nr_vars was %p", nr_vars);
        memcpy(vars_dir, &__start_devvars, nr_vars * sizeof(struct dirtab));
@@ -225,7 +225,7 @@ static void vars_create(struct chan *c, char *name, int omode, uint32_t perm)
        new_slot = find_free_var();
        if (!new_slot) {
                vars_dir = kreallocarray(vars_dir, nr_vars * 2, sizeof(struct dirtab),
-                                        KMALLOC_WAIT);
+                                        MEM_WAIT);
                if (!vars_dir)
                        error(ENOMEM, "krealloc_array failed, nr_vars was %p", nr_vars);
                memset(vars_dir + nr_vars, 0, nr_vars * sizeof(struct dirtab));
index 01bc4a7..e65d9bd 100644 (file)
@@ -39,7 +39,7 @@ static long ver_emit_nlstr(char *dest, const char *src, long size,
                                                   long offset)
 {
        long n, slen = strlen(src);
-       char *buf = kmalloc(slen + 2, KMALLOC_WAIT);
+       char *buf = kmalloc(slen + 2, MEM_WAIT);
 
        snprintf(buf, slen + 2, "%s\n", src);
        n = readmem(offset, dest, size, buf, slen + 2);
index 1dc81de..1690b1a 100644 (file)
@@ -2201,7 +2201,7 @@ void bnx2x_igu_clear_sb_gen(struct bnx2x *bp, uint8_t func,
                            bool is_pf);
 
 #define BNX2X_ILT_ZALLOC(x, y, size)                                   \
-       x = dma_zalloc_coherent(&bp->pdev->dev, size, y, KMALLOC_WAIT)
+       x = dma_zalloc_coherent(&bp->pdev->dev, size, y, MEM_WAIT)
 
 #define BNX2X_ILT_FREE(x, y, size) \
        do { \
index 39a5ce6..8fbd2cd 100644 (file)
@@ -643,7 +643,7 @@ static void *bnx2x_frag_alloc(const struct bnx2x_fastpath *fp, gfp_t gfp_mask)
 {
        if (fp->rx_frag_size) {
                /* GFP_KERNEL allocations are used only during initialization */
-               if (unlikely(gfp_mask & KMALLOC_WAIT))
+               if (unlikely(gfp_mask & MEM_WAIT))
                        return (void *)kpage_alloc_addr();
 
 #if 0 // AKAROS_PORT
@@ -1400,7 +1400,7 @@ void bnx2x_init_rx_rings(struct bnx2x *bp)
                                        &tpa_info->first_buf;
 
                                first_buf->data =
-                                       bnx2x_frag_alloc(fp, KMALLOC_WAIT);
+                                       bnx2x_frag_alloc(fp, MEM_WAIT);
                                if (!first_buf->data) {
                                        BNX2X_ERR("Failed to allocate TPA skb pool for queue[%d] - disabling TPA on this queue!\n",
                                                  j);
@@ -1423,7 +1423,7 @@ void bnx2x_init_rx_rings(struct bnx2x *bp)
                             i < MAX_RX_SGE_CNT*NUM_RX_SGE_PAGES; i++) {
 
                                if (bnx2x_alloc_rx_sge(bp, fp, ring_prod,
-                                                      KMALLOC_WAIT) < 0) {
+                                                      MEM_WAIT) < 0) {
                                        BNX2X_ERR("was only able to allocate %d rx sges\n",
                                                  i);
                                        BNX2X_ERR("disabling TPA for queue[%d]\n",
@@ -4448,7 +4448,7 @@ static int bnx2x_alloc_rx_bds(struct bnx2x_fastpath *fp,
         * fp->eth_q_stats.rx_skb_alloc_failed = 0
         */
        for (i = 0; i < rx_ring_size; i++) {
-               if (bnx2x_alloc_rx_data(bp, fp, ring_prod, KMALLOC_WAIT) < 0) {
+               if (bnx2x_alloc_rx_data(bp, fp, ring_prod, MEM_WAIT) < 0) {
                        failure_cnt++;
                        continue;
                }
@@ -4561,7 +4561,7 @@ static int bnx2x_alloc_fp_mem_at(struct bnx2x *bp, int index)
                           index, cos);
 
                        txdata->tx_buf_ring = kzmalloc((NUM_TX_BD) * (sizeof(struct sw_tx_bd)),
-                                                      KMALLOC_WAIT);
+                                                      MEM_WAIT);
                        if (!txdata->tx_buf_ring)
                                goto alloc_mem_err;
                        txdata->tx_desc_ring = BNX2X_PCI_ALLOC(&txdata->tx_desc_mapping,
@@ -4576,7 +4576,7 @@ static int bnx2x_alloc_fp_mem_at(struct bnx2x *bp, int index)
                /* fastpath rx rings: rx_buf rx_desc rx_comp */
                bnx2x_fp(bp, index, rx_buf_ring) =
                        kzmalloc((NUM_RX_BD) * (sizeof(struct sw_rx_bd)),
-                                KMALLOC_WAIT);
+                                MEM_WAIT);
                if (!bnx2x_fp(bp, index, rx_buf_ring))
                        goto alloc_mem_err;
                bnx2x_fp(bp, index, rx_desc_ring) =
@@ -4595,7 +4595,7 @@ static int bnx2x_alloc_fp_mem_at(struct bnx2x *bp, int index)
                /* SGE ring */
                bnx2x_fp(bp, index, rx_page_ring) =
                        kzmalloc((NUM_RX_SGE) * (sizeof(struct sw_rx_page)),
-                                KMALLOC_WAIT);
+                                MEM_WAIT);
                if (!bnx2x_fp(bp, index, rx_page_ring))
                        goto alloc_mem_err;
                bnx2x_fp(bp, index, rx_sge_ring) =
@@ -4725,13 +4725,13 @@ int bnx2x_alloc_mem_bp(struct bnx2x *bp)
        bp->fp_array_size = fp_array_size;
        BNX2X_DEV_INFO("fp_array_size %d\n", bp->fp_array_size);
 
-       fp = kzmalloc((bp->fp_array_size) * (sizeof(*fp)), KMALLOC_WAIT);
+       fp = kzmalloc((bp->fp_array_size) * (sizeof(*fp)), MEM_WAIT);
        if (!fp)
                goto alloc_err;
        for (i = 0; i < bp->fp_array_size; i++) {
                fp[i].tpa_info =
                        kzmalloc((ETH_MAX_AGGREGATION_QUEUES_E1H_E2) * (sizeof(struct bnx2x_agg_info)),
-                                KMALLOC_WAIT);
+                                MEM_WAIT);
                if (!(fp[i].tpa_info))
                        goto alloc_err;
        }
@@ -4740,13 +4740,13 @@ int bnx2x_alloc_mem_bp(struct bnx2x *bp)
 
        /* allocate sp objs */
        bp->sp_objs = kzmalloc((bp->fp_array_size) * (sizeof(struct bnx2x_sp_objs)),
-                              KMALLOC_WAIT);
+                              MEM_WAIT);
        if (!bp->sp_objs)
                goto alloc_err;
 
        /* allocate fp_stats */
        bp->fp_stats = kzmalloc((bp->fp_array_size) * (sizeof(struct bnx2x_fp_stats)),
-                               KMALLOC_WAIT);
+                               MEM_WAIT);
        if (!bp->fp_stats)
                goto alloc_err;
 
@@ -4756,19 +4756,19 @@ int bnx2x_alloc_mem_bp(struct bnx2x *bp)
        BNX2X_DEV_INFO("txq_array_size %d", txq_array_size);
 
        bp->bnx2x_txq = kzmalloc((txq_array_size) * (sizeof(struct bnx2x_fp_txdata)),
-                                KMALLOC_WAIT);
+                                MEM_WAIT);
        if (!bp->bnx2x_txq)
                goto alloc_err;
 
        // AKAROS_PORT: we probably won't use this table */
        /* msix table */
-       tbl = kzmalloc((msix_table_size) * (sizeof(*tbl)), KMALLOC_WAIT);
+       tbl = kzmalloc((msix_table_size) * (sizeof(*tbl)), MEM_WAIT);
        if (!tbl)
                goto alloc_err;
        bp->msix_table = tbl;
 
        /* ilt */
-       ilt = kzmalloc(sizeof(*ilt), KMALLOC_WAIT);
+       ilt = kzmalloc(sizeof(*ilt), MEM_WAIT);
        if (!ilt)
                goto alloc_err;
        bp->ilt = ilt;
index c52563e..4d68fd9 100644 (file)
@@ -45,7 +45,7 @@ extern int bnx2x_num_queues;
 
 #define BNX2X_PCI_ALLOC(y, size)                                       \
 ({                                                                     \
-       void *x = dma_zalloc_coherent(&bp->pdev->dev, size, y, KMALLOC_WAIT); \
+       void *x = dma_zalloc_coherent(&bp->pdev->dev, size, y, MEM_WAIT); \
        if (x)                                                          \
                DP(NETIF_MSG_HW,                                        \
                   "BNX2X_PCI_ALLOC: Physical %p Virtual %p\n", \
@@ -54,7 +54,7 @@ extern int bnx2x_num_queues;
 })
 #define BNX2X_PCI_FALLOC(y, size)                                      \
 ({                                                                     \
-       void *x = dma_alloc_coherent(&bp->pdev->dev, size, y, KMALLOC_WAIT); \
+       void *x = dma_alloc_coherent(&bp->pdev->dev, size, y, MEM_WAIT); \
        if (x) {                                                        \
                memset(x, 0xff, size);                                  \
                DP(NETIF_MSG_HW,                                        \
index 91fe064..f7c0be4 100644 (file)
@@ -327,7 +327,7 @@ static void bnx2x_attach(struct ether *edev)
        /* Alloc all your ctrl crap. */
 
        /* the ktasks should free these names, if they ever exit */
-       name = kmalloc(KNAMELEN, KMALLOC_WAIT);
+       name = kmalloc(KNAMELEN, MEM_WAIT);
        snprintf(name, KNAMELEN, "#l%d-bnx2x_rproc", edev->ctlrno);
        ktask(name, bnx2x_rproc, edev);
 
index 108a887..176b6e9 100644 (file)
@@ -2842,7 +2842,7 @@ static int bnx2x_test_nvram(struct bnx2x *bp)
        if (BP_NOMCP(bp))
                return 0;
 
-       buf = kmalloc(CRC_BUFF_SIZE, KMALLOC_WAIT);
+       buf = kmalloc(CRC_BUFF_SIZE, MEM_WAIT);
        if (!buf) {
                DP(BNX2X_MSG_ETHTOOL | BNX2X_MSG_NVM, "kmalloc failed\n");
                rc = -ENOMEM;
index 7ec3bad..899e6fe 100644 (file)
@@ -6533,11 +6533,11 @@ void bnx2x_post_irq_nic_init(struct bnx2x *bp, uint32_t load_code)
 static int bnx2x_gunzip_init(struct bnx2x *bp)
 {
        bp->gunzip_buf = dma_alloc_coherent(&bp->pdev->dev, FW_BUF_SIZE,
-                                           &bp->gunzip_mapping, KMALLOC_WAIT);
+                                           &bp->gunzip_mapping, MEM_WAIT);
        if (bp->gunzip_buf  == NULL)
                goto gunzip_nomem1;
 
-       bp->strm = kmalloc(sizeof(*bp->strm), KMALLOC_WAIT);
+       bp->strm = kmalloc(sizeof(*bp->strm), MEM_WAIT);
        if (bp->strm  == NULL)
                goto gunzip_nomem2;
 
@@ -8341,7 +8341,7 @@ int bnx2x_alloc_mem(struct bnx2x *bp)
                allocated += bp->context[i].size;
        }
        bp->ilt->lines = kzmalloc((ILT_MAX_LINES) * (sizeof(struct ilt_line)),
-                                 KMALLOC_WAIT);
+                                 MEM_WAIT);
        if (!bp->ilt->lines)
                goto alloc_mem_err;
 
@@ -10485,7 +10485,7 @@ static int bnx2x_prev_mark_path(struct bnx2x *bp, bool after_undi)
        up(&bnx2x_prev_sem);
 
        /* Create an entry for this path and add it */
-       tmp_list = kmalloc(sizeof(struct bnx2x_prev_path_list), KMALLOC_WAIT);
+       tmp_list = kmalloc(sizeof(struct bnx2x_prev_path_list), MEM_WAIT);
        if (!tmp_list) {
                BNX2X_ERR("Failed to allocate 'bnx2x_prev_path_list'\n");
                return -ENOMEM;
@@ -12040,7 +12040,7 @@ static void bnx2x_read_fwinfo(struct bnx2x *bp)
        i += PCI_VPD_LRDT_TAG_SIZE;
 
        if (block_end > BNX2X_VPD_LEN) {
-               vpd_extended_data = kmalloc(block_end, KMALLOC_WAIT);
+               vpd_extended_data = kmalloc(block_end, MEM_WAIT);
                if (vpd_extended_data  == NULL)
                        goto out_not_found;
 
@@ -13105,7 +13105,7 @@ static void be16_to_cpu_n(const uint8_t *_source, uint8_t *_target,
 #define BNX2X_ALLOC_AND_SET(arr, lbl, func)                            \
 do {                                                                   \
        uint32_t len = be32_to_cpu(fw_hdr->arr.len);                            \
-       bp->arr = kmalloc(len, KMALLOC_WAIT);                           \
+       bp->arr = kmalloc(len, MEM_WAIT);                               \
        if (!bp->arr)                                                   \
                goto lbl;                                               \
        func(bp->firmware->data + be32_to_cpu(fw_hdr->arr.offset),      \
@@ -14462,7 +14462,7 @@ static int bnx2x_register_cnic(struct ether *dev, struct cnic_ops *ops,
 
        bp->cnic_enabled = true;
 
-       bp->cnic_kwq = kzmalloc(PAGE_SIZE, KMALLOC_WAIT);
+       bp->cnic_kwq = kzmalloc(PAGE_SIZE, MEM_WAIT);
        if (!bp->cnic_kwq)
                return -ENOMEM;
 
index 5c7ac04..836c3c3 100644 (file)
@@ -591,7 +591,7 @@ int bnx2x_vf_mcast(struct bnx2x *bp, struct bnx2x_virtf *vf,
                set_bit(RAMROD_COMP_WAIT, &mcast.ramrod_flags);
        if (mc_num) {
                mc = kzmalloc(mc_num * sizeof(struct bnx2x_mcast_list_elem),
-                             KMALLOC_WAIT);
+                             MEM_WAIT);
                if (!mc) {
                        BNX2X_ERR("Cannot Configure mulicasts due to lack of memory\n");
                        return -ENOMEM;
@@ -1272,7 +1272,7 @@ int bnx2x_iov_init_one(struct bnx2x *bp, int int_mode_param,
        }
 
        /* allocate the vfs database */
-       bp->vfdb = kzmalloc(sizeof(*(bp->vfdb)), KMALLOC_WAIT);
+       bp->vfdb = kzmalloc(sizeof(*(bp->vfdb)), MEM_WAIT);
        if (!bp->vfdb) {
                BNX2X_ERR("failed to allocate vf database\n");
                err = -ENOMEM;
@@ -1300,7 +1300,7 @@ int bnx2x_iov_init_one(struct bnx2x *bp, int int_mode_param,
 
        /* allocate the vf array */
        bp->vfdb->vfs = kzmalloc(sizeof(struct bnx2x_virtf) * BNX2X_NR_VIRTFN(bp),
-                                KMALLOC_WAIT);
+                                MEM_WAIT);
        if (!bp->vfdb->vfs) {
                BNX2X_ERR("failed to allocate vf array\n");
                err = -ENOMEM;
@@ -1325,7 +1325,7 @@ int bnx2x_iov_init_one(struct bnx2x *bp, int int_mode_param,
 
        /* allocate the queue arrays for all VFs */
        bp->vfdb->vfqs = kzmalloc(BNX2X_MAX_NUM_VF_QUEUES * sizeof(struct bnx2x_vf_queue),
-                                 KMALLOC_WAIT);
+                                 MEM_WAIT);
 
        if (!bp->vfdb->vfqs) {
                BNX2X_ERR("failed to allocate vf queue array\n");
index 7721d41..f982518 100644 (file)
@@ -1573,7 +1573,7 @@ static int bnx2x_vf_mbx_macvlan_list(struct bnx2x *bp,
              sizeof(struct bnx2x_vf_mac_vlan_filter) +
              sizeof(struct bnx2x_vf_mac_vlan_filters);
 
-       fl = kzmalloc(fsz, KMALLOC_WAIT);
+       fl = kzmalloc(fsz, MEM_WAIT);
        if (!fl)
                return -ENOMEM;
 
index 4e2f391..1d75d95 100644 (file)
@@ -425,7 +425,7 @@ static void rtl8139attach(struct ether *edev)
        if (ctlr->alloc == NULL) {
                ctlr->rblen = 1 << ((Rblen >> RblenSHIFT) + 13);
                ctlr->alloc = kzmalloc(ctlr->rblen + 16 + Ntd * Tdbsz + ARCH_CL_SIZE,
-                                                          KMALLOC_WAIT);
+                                                          MEM_WAIT);
                rtl8139init(edev);
        }
        qunlock(&ctlr->alock);
@@ -715,7 +715,7 @@ static int rtl8139pnp(struct ether *edev)
                        if (pcidev->class != 0x02 || pcidev->subclass != 0)
                                continue;
 
-                       ctlr = kzmalloc(sizeof(struct ctlr), KMALLOC_WAIT);
+                       ctlr = kzmalloc(sizeof(struct ctlr), MEM_WAIT);
                        qlock_init(&ctlr->alock);
                        spinlock_init_irqsave(&ctlr->ilock);
                        spinlock_init_irqsave(&ctlr->tlock);
index 8998b49..828e0ef 100644 (file)
@@ -835,13 +835,13 @@ rtl8169attach(struct ether* edev)
                /*
                 * Handle allocation/init errors here.
                 */
-               ctlr->td = kzmalloc_align(sizeof(D) * Ntd, KMALLOC_WAIT, 256);
-               ctlr->tb = kzmalloc(Ntd * sizeof(struct block *), KMALLOC_WAIT);
+               ctlr->td = kzmalloc_align(sizeof(D) * Ntd, MEM_WAIT, 256);
+               ctlr->tb = kzmalloc(Ntd * sizeof(struct block *), MEM_WAIT);
                ctlr->ntd = Ntd;
-               ctlr->rd = kzmalloc_align(sizeof(D) * Nrd, KMALLOC_WAIT, 256);
-               ctlr->rb = kzmalloc(Nrd * sizeof(struct block *), KMALLOC_WAIT);
+               ctlr->rd = kzmalloc_align(sizeof(D) * Nrd, MEM_WAIT, 256);
+               ctlr->rb = kzmalloc(Nrd * sizeof(struct block *), MEM_WAIT);
                ctlr->nrd = Nrd;
-               ctlr->dtcc = kzmalloc_align(sizeof(Dtcc), KMALLOC_WAIT, 64);
+               ctlr->dtcc = kzmalloc_align(sizeof(Dtcc), MEM_WAIT, 64);
                rtl8169init(edev);
                ctlr->init = 1;
        }
@@ -1121,7 +1121,7 @@ rtl8169pci(void)
 
                port = pcidev->bar[0].pio_base;
 
-               ctlr = kzmalloc(sizeof(struct ctlr), KMALLOC_WAIT);
+               ctlr = kzmalloc(sizeof(struct ctlr), MEM_WAIT);
                spinlock_init_irqsave(&ctlr->ilock);
                spinlock_init_irqsave(&ctlr->tlock);
                spinlock_init_irqsave(&ctlr->rlock);
index 7f59049..822151a 100644 (file)
@@ -1631,7 +1631,7 @@ static void i82563attach(struct ether *edev)
 
        ctlr->alloc = kzmalloc(Nrd * sizeof(struct rd) +
                                   Ntd * sizeof(struct td) + 255,
-                              KMALLOC_WAIT);
+                              MEM_WAIT);
        if (ctlr->alloc == NULL) {
                qunlock(&ctlr->alock);
                error(ENOMEM, "i82563attach: error allocating rx/tx rings");
@@ -1648,15 +1648,15 @@ static void i82563attach(struct ether *edev)
        ctlr->edev = edev;      /* point back to Ether* */
        ctlr->attached = 1;
 
-       lname = kzmalloc(KNAMELEN, KMALLOC_WAIT);
+       lname = kzmalloc(KNAMELEN, MEM_WAIT);
        snprintf(lname, KNAMELEN, "#l%dl", edev->ctlrno);
        ktask(lname, i82563lproc, edev);
 
-       rname = kzmalloc(KNAMELEN, KMALLOC_WAIT);
+       rname = kzmalloc(KNAMELEN, MEM_WAIT);
        snprintf(rname, KNAMELEN, "#l%dr", edev->ctlrno);
        ktask(rname, i82563rproc, edev);
 
-       tname = kzmalloc(KNAMELEN, KMALLOC_WAIT);
+       tname = kzmalloc(KNAMELEN, MEM_WAIT);
        snprintf(tname, KNAMELEN, "#l%dt", edev->ctlrno);
        ktask(tname, i82563tproc, edev);
 
index 7c0a159..039f228 100644 (file)
@@ -1258,11 +1258,11 @@ igbeattach(struct ether* edev)
        }
 
        /* the ktasks should free these names, if they ever exit */
-       name = kmalloc(KNAMELEN, KMALLOC_WAIT);
+       name = kmalloc(KNAMELEN, MEM_WAIT);
        snprintf(name, KNAMELEN, "#l%dlproc", edev->ctlrno);
        ktask(name, igbelproc, edev);
 
-       name = kmalloc(KNAMELEN, KMALLOC_WAIT);
+       name = kmalloc(KNAMELEN, MEM_WAIT);
        snprintf(name, KNAMELEN, "#l%drproc", edev->ctlrno);
        ktask(name, igberproc, edev);
 
index fdb26ee..e5fdc74 100644 (file)
@@ -181,7 +181,7 @@ int mlx4_bitmap_init(struct mlx4_bitmap *bitmap, uint32_t num, uint32_t mask,
        bitmap->effective_len = bitmap->avail;
        spinlock_init(&bitmap->lock);
        bitmap->table = kzmalloc(BITS_TO_LONGS(bitmap->max) * sizeof(long),
-                                KMALLOC_WAIT);
+                                MEM_WAIT);
        if (!bitmap->table)
                return -ENOMEM;
 
@@ -220,7 +220,7 @@ struct mlx4_zone_entry {
 struct mlx4_zone_allocator *mlx4_zone_allocator_create(enum mlx4_zone_alloc_flags flags)
 {
        struct mlx4_zone_allocator *zones = kmalloc(sizeof(*zones),
-                                                   KMALLOC_WAIT);
+                                                   MEM_WAIT);
 
        if (NULL == zones)
                return NULL;
@@ -244,7 +244,7 @@ int mlx4_zone_add_one(struct mlx4_zone_allocator *zone_alloc,
 {
        uint32_t mask = mlx4_bitmap_masked_value(bitmap, (uint32_t)-1);
        struct mlx4_zone_entry *it;
-       struct mlx4_zone_entry *zone = kmalloc(sizeof(*zone), KMALLOC_WAIT);
+       struct mlx4_zone_entry *zone = kmalloc(sizeof(*zone), MEM_WAIT);
 
        if (NULL == zone)
                return -ENOMEM;
@@ -812,13 +812,13 @@ int mlx4_alloc_hwq_res(struct mlx4_dev *dev, struct mlx4_hwq_resources *wqres,
 {
        int err;
 
-       err = mlx4_db_alloc(dev, &wqres->db, 1, KMALLOC_WAIT);
+       err = mlx4_db_alloc(dev, &wqres->db, 1, MEM_WAIT);
        if (err)
                return err;
 
        *wqres->db.db = 0;
 
-       err = mlx4_buf_alloc(dev, size, max_direct, &wqres->buf, KMALLOC_WAIT);
+       err = mlx4_buf_alloc(dev, size, max_direct, &wqres->buf, MEM_WAIT);
        if (err)
                goto err_db;
 
@@ -827,7 +827,7 @@ int mlx4_alloc_hwq_res(struct mlx4_dev *dev, struct mlx4_hwq_resources *wqres,
        if (err)
                goto err_buf;
 
-       err = mlx4_buf_write_mtt(dev, &wqres->mtt, &wqres->buf, KMALLOC_WAIT);
+       err = mlx4_buf_write_mtt(dev, &wqres->mtt, &wqres->buf, MEM_WAIT);
        if (err)
                goto err_mtt;
 
index 5f86dbe..7f406e7 100644 (file)
@@ -948,7 +948,7 @@ static int mlx4_MAD_IFC_wrapper(struct mlx4_dev *dev, int slave,
                                if (port < 1 || port > dev->caps.num_ports)
                                        return -EINVAL;
                                table = kzmalloc(((dev->caps.pkey_table_len[port] / 32) + 1) * (sizeof(*table) * 32),
-                                                KMALLOC_WAIT);
+                                                MEM_WAIT);
 
                                if (!table)
                                        return -ENOMEM;
@@ -1696,7 +1696,7 @@ static int mlx4_master_process_vhcr(struct mlx4_dev *dev, int slave,
        int err = 0;
 
        /* Create sw representation of Virtual HCR */
-       vhcr = kzmalloc(sizeof(struct mlx4_vhcr), KMALLOC_WAIT);
+       vhcr = kzmalloc(sizeof(struct mlx4_vhcr), MEM_WAIT);
        if (!vhcr)
                return -ENOMEM;
 
@@ -1888,7 +1888,7 @@ static int mlx4_master_immediate_activate_vlan_qos(struct mlx4_priv *priv,
                 vp_admin->default_vlan, vp_admin->default_qos,
                 vp_admin->link_state);
 
-       work = kzmalloc(sizeof(*work), KMALLOC_WAIT);
+       work = kzmalloc(sizeof(*work), MEM_WAIT);
        if (!work)
                return -ENOMEM;
 
@@ -2360,19 +2360,19 @@ int mlx4_multi_func_init(struct mlx4_dev *dev)
 
                priv->mfunc.master.slave_state =
                        kzmalloc(dev->num_slaves * sizeof(struct mlx4_slave_state),
-                                KMALLOC_WAIT);
+                                MEM_WAIT);
                if (!priv->mfunc.master.slave_state)
                        goto err_comm;
 
                priv->mfunc.master.vf_admin =
                        kzmalloc(dev->num_slaves * sizeof(struct mlx4_vf_admin_state),
-                                KMALLOC_WAIT);
+                                MEM_WAIT);
                if (!priv->mfunc.master.vf_admin)
                        goto err_comm_admin;
 
                priv->mfunc.master.vf_oper =
                        kzmalloc(dev->num_slaves * sizeof(struct mlx4_vf_oper_state),
-                                KMALLOC_WAIT);
+                                MEM_WAIT);
                if (!priv->mfunc.master.vf_oper)
                        goto err_comm_oper;
 
@@ -2395,7 +2395,7 @@ int mlx4_multi_func_init(struct mlx4_dev *dev)
 
                                s_state->vlan_filter[port] =
                                        kzmalloc(sizeof(struct mlx4_vlan_fltr),
-                                                KMALLOC_WAIT);
+                                                MEM_WAIT);
                                if (!s_state->vlan_filter[port]) {
                                        if (--port)
                                                kfree(s_state->vlan_filter[port]);
@@ -2504,7 +2504,7 @@ int mlx4_cmd_init(struct mlx4_dev *dev)
                priv->mfunc.vhcr = dma_alloc_coherent(&dev->persist->pdev->dev,
                                                      PAGE_SIZE,
                                                      &priv->mfunc.vhcr_dma,
-                                                     KMALLOC_WAIT);
+                                                     MEM_WAIT);
                if (!priv->mfunc.vhcr)
                        goto err;
 
@@ -2607,7 +2607,7 @@ int mlx4_cmd_use_events(struct mlx4_dev *dev)
 
        priv->cmd.context = kmalloc(priv->cmd.max_cmds *
                                   sizeof (struct mlx4_cmd_context),
-                                  KMALLOC_WAIT);
+                                  MEM_WAIT);
        if (!priv->cmd.context)
                return -ENOMEM;
 
@@ -2661,11 +2661,11 @@ struct mlx4_cmd_mailbox *mlx4_alloc_cmd_mailbox(struct mlx4_dev *dev)
 {
        struct mlx4_cmd_mailbox *mailbox;
 
-       mailbox = kmalloc(sizeof *mailbox, KMALLOC_WAIT);
+       mailbox = kmalloc(sizeof *mailbox, MEM_WAIT);
        if (!mailbox)
                return ERR_PTR(-ENOMEM);
 
-       mailbox->buf = pci_pool_alloc(mlx4_priv(dev)->cmd.pool, KMALLOC_WAIT,
+       mailbox->buf = pci_pool_alloc(mlx4_priv(dev)->cmd.pool, MEM_WAIT,
                                      &mailbox->dma);
        if (!mailbox->buf) {
                kfree(mailbox);
index 900c0a7..acaec45 100644 (file)
@@ -226,11 +226,11 @@ int __mlx4_cq_alloc_icm(struct mlx4_dev *dev, int *cqn)
        if (*cqn == -1)
                return -ENOMEM;
 
-       err = mlx4_table_get(dev, &cq_table->table, *cqn, KMALLOC_WAIT);
+       err = mlx4_table_get(dev, &cq_table->table, *cqn, MEM_WAIT);
        if (err)
                goto err_out;
 
-       err = mlx4_table_get(dev, &cq_table->cmpt_table, *cqn, KMALLOC_WAIT);
+       err = mlx4_table_get(dev, &cq_table->cmpt_table, *cqn, MEM_WAIT);
        if (err)
                goto err_put;
        return 0;
index 460b2b7..b63375e 100644 (file)
@@ -52,9 +52,9 @@ int mlx4_en_create_cq(struct mlx4_en_priv *priv,
        struct mlx4_en_cq *cq;
        int err;
 
-       cq = kzalloc_node(sizeof(*cq), KMALLOC_WAIT, node);
+       cq = kzalloc_node(sizeof(*cq), MEM_WAIT, node);
        if (!cq) {
-               cq = kzmalloc(sizeof(*cq), KMALLOC_WAIT);
+               cq = kzmalloc(sizeof(*cq), MEM_WAIT);
                if (!cq) {
                        en_err(priv, "Failed to allocate CQ structure\n");
                        return -ENOMEM;
index b07f7fd..dd0c052 100644 (file)
@@ -1340,8 +1340,8 @@ static int add_ip_rule(struct mlx4_en_priv *priv,
        struct mlx4_spec_list *spec_l3 = NULL;
        struct ethtool_usrip4_spec *l3_mask = &cmd->fs.m_u.usr_ip4_spec;
 
-       spec_l3 = kzmalloc(sizeof(*spec_l3), KMALLOC_WAIT);
-       spec_l2 = kzmalloc(sizeof(*spec_l2), KMALLOC_WAIT);
+       spec_l3 = kzmalloc(sizeof(*spec_l3), MEM_WAIT);
+       spec_l2 = kzmalloc(sizeof(*spec_l2), MEM_WAIT);
        if (!spec_l2 || !spec_l3) {
                err = -ENOMEM;
                goto free_spec;
@@ -1379,9 +1379,9 @@ static int add_tcp_udp_rule(struct mlx4_en_priv *priv,
        struct mlx4_spec_list *spec_l4 = NULL;
        struct ethtool_tcpip4_spec *l4_mask = &cmd->fs.m_u.tcp_ip4_spec;
 
-       spec_l2 = kzmalloc(sizeof(*spec_l2), KMALLOC_WAIT);
-       spec_l3 = kzmalloc(sizeof(*spec_l3), KMALLOC_WAIT);
-       spec_l4 = kzmalloc(sizeof(*spec_l4), KMALLOC_WAIT);
+       spec_l2 = kzmalloc(sizeof(*spec_l2), MEM_WAIT);
+       spec_l3 = kzmalloc(sizeof(*spec_l3), MEM_WAIT);
+       spec_l4 = kzmalloc(sizeof(*spec_l4), MEM_WAIT);
        if (!spec_l2 || !spec_l3 || !spec_l4) {
                err = -ENOMEM;
                goto free_spec;
@@ -1452,7 +1452,7 @@ static int mlx4_en_ethtool_to_net_trans_rule(struct ether *dev,
 
        switch (cmd->fs.flow_type & ~(FLOW_EXT | FLOW_MAC_EXT)) {
        case ETHER_FLOW:
-               spec_l2 = kzmalloc(sizeof(*spec_l2), KMALLOC_WAIT);
+               spec_l2 = kzmalloc(sizeof(*spec_l2), MEM_WAIT);
                if (!spec_l2)
                        return -ENOMEM;
 
index d98253e..f1c7911 100644 (file)
@@ -242,7 +242,7 @@ static void *mlx4_en_add(struct mlx4_dev *dev)
 
        printk_once(KERN_INFO "%s", mlx4_en_version);
 
-       mdev = kzmalloc(sizeof(*mdev), KMALLOC_WAIT);
+       mdev = kzmalloc(sizeof(*mdev), MEM_WAIT);
        if (!mdev)
                goto err_free_res;
 
index 94b3088..75dcc53 100644 (file)
@@ -617,7 +617,7 @@ static int mlx4_en_get_qp(struct mlx4_en_priv *priv)
                goto tunnel_err;
 #endif
 
-       entry = kmalloc(sizeof(*entry), KMALLOC_WAIT);
+       entry = kmalloc(sizeof(*entry), MEM_WAIT);
        if (!entry) {
                err = -ENOMEM;
                goto alloc_err;
@@ -861,7 +861,7 @@ static void update_mclist_flags(struct mlx4_en_priv *priv,
                if (!found) {
                        new_mc = kmemdup(src_tmp,
                                         sizeof(struct mlx4_en_mc_list),
-                                        KMALLOC_WAIT);
+                                        MEM_WAIT);
                        if (!new_mc)
                                return;
 
@@ -1195,7 +1195,7 @@ static void mlx4_en_do_uc_filter(struct mlx4_en_priv *priv,
                }
 
                if (!found) {
-                       entry = kmalloc(sizeof(*entry), KMALLOC_WAIT);
+                       entry = kmalloc(sizeof(*entry), MEM_WAIT);
                        if (!entry) {
                                en_err(priv, "Failed adding MAC %pM on port:%d (out of memory)\n",
                                       ha->addr, priv->port);
@@ -1535,7 +1535,7 @@ static int mlx4_en_init_affinity_hint(struct mlx4_en_priv *priv, int ring_idx)
        struct mlx4_en_rx_ring *ring = priv->rx_ring[ring_idx];
        int numa_node = priv->mdev->dev->numa_node;
 
-       if (!zalloc_cpumask_var(&ring->affinity_mask, KMALLOC_WAIT))
+       if (!zalloc_cpumask_var(&ring->affinity_mask, MEM_WAIT))
                return -ENOMEM;
 
        cpumask_set_cpu(cpumask_local_spread(ring_idx, numa_node),
@@ -2853,7 +2853,7 @@ int mlx4_en_init_netdev(struct mlx4_en_dev *mdev, int port,
 
        SET_NETDEV_DEV(dev, &mdev->dev->persist->pdev->dev);
 #else
-       dev->ctlr = kzmalloc(sizeof(struct mlx4_en_priv), KMALLOC_WAIT);
+       dev->ctlr = kzmalloc(sizeof(struct mlx4_en_priv), MEM_WAIT);
 #endif
 
        /*
@@ -2895,13 +2895,13 @@ int mlx4_en_init_netdev(struct mlx4_en_dev *mdev, int port,
        netdev_rss_key_fill(priv->rss_key, sizeof(priv->rss_key));
 
        priv->tx_ring = kzmalloc(sizeof(struct mlx4_en_tx_ring *) * MAX_TX_RINGS,
-                                KMALLOC_WAIT);
+                                MEM_WAIT);
        if (!priv->tx_ring) {
                err = -ENOMEM;
                goto out;
        }
        priv->tx_cq = kzmalloc(sizeof(struct mlx4_en_cq *) * MAX_TX_RINGS,
-                              KMALLOC_WAIT);
+                              MEM_WAIT);
        if (!priv->tx_cq) {
                err = -ENOMEM;
                goto out;
index c467611..b985734 100644 (file)
@@ -89,7 +89,7 @@ int mlx4_en_map_buffer(struct mlx4_buf *buf)
 
        panic("Disabled");
 #if 0 // AKAROS_PORT
-       pages = kmalloc(sizeof *pages * buf->nbufs, KMALLOC_WAIT);
+       pages = kmalloc(sizeof *pages * buf->nbufs, MEM_WAIT);
        if (!pages)
                return -ENOMEM;
 
index b90df9e..c37901c 100644 (file)
@@ -148,7 +148,7 @@ static int mlx4_en_init_allocator(struct mlx4_en_priv *priv,
                const struct mlx4_en_frag_info *frag_info = &priv->frag_info[i];
 
                if (mlx4_alloc_pages(priv, &ring->page_alloc[i],
-                                    frag_info, KMALLOC_WAIT | __GFP_COLD))
+                                    frag_info, MEM_WAIT | __GFP_COLD))
                        goto out;
 
                en_dbg(DRV, priv, "  frag %d allocator: - size:%d frags:%d\n",
@@ -273,7 +273,7 @@ static int mlx4_en_fill_rx_buffers(struct mlx4_en_priv *priv)
 
                        if (mlx4_en_prepare_rx_desc(priv, ring,
                                                    ring->actual_size,
-                                                   KMALLOC_WAIT | __GFP_COLD)) {
+                                                   MEM_WAIT | __GFP_COLD)) {
                                if (ring->actual_size < MLX4_EN_MIN_RX_SIZE) {
                                        en_err(priv, "Failed to allocate enough rx buffers\n");
                                        return -ENOMEM;
@@ -352,9 +352,9 @@ int mlx4_en_create_rx_ring(struct mlx4_en_priv *priv,
        int err = -ENOMEM;
        int tmp;
 
-       ring = kzalloc_node(sizeof(*ring), KMALLOC_WAIT, node);
+       ring = kzalloc_node(sizeof(*ring), MEM_WAIT, node);
        if (!ring) {
-               ring = kzmalloc(sizeof(*ring), KMALLOC_WAIT);
+               ring = kzmalloc(sizeof(*ring), MEM_WAIT);
                if (!ring) {
                        en_err(priv, "Failed to allocate RX ring structure\n");
                        return -ENOMEM;
@@ -1188,11 +1188,11 @@ static int mlx4_en_config_rss_qp(struct mlx4_en_priv *priv, int qpn,
        struct mlx4_qp_context *context;
        int err = 0;
 
-       context = kmalloc(sizeof(*context), KMALLOC_WAIT);
+       context = kmalloc(sizeof(*context), MEM_WAIT);
        if (!context)
                return -ENOMEM;
 
-       err = mlx4_qp_alloc(mdev->dev, qpn, qp, KMALLOC_WAIT);
+       err = mlx4_qp_alloc(mdev->dev, qpn, qp, MEM_WAIT);
        if (err) {
                en_err(priv, "Failed to allocate qp #%x\n", qpn);
                goto out;
@@ -1237,7 +1237,7 @@ int mlx4_en_create_drop_qp(struct mlx4_en_priv *priv)
                return err;
        }
        err = mlx4_qp_alloc(priv->mdev->dev, qpn, &priv->drop_qp,
-                           KMALLOC_WAIT);
+                           MEM_WAIT);
        if (err) {
                en_err(priv, "Failed allocating drop qp\n");
                mlx4_qp_release_range(priv->mdev->dev, qpn, 1);
@@ -1294,7 +1294,7 @@ int mlx4_en_config_rss_steer(struct mlx4_en_priv *priv)
 
        /* Configure RSS indirection qp */
        err = mlx4_qp_alloc(mdev->dev, priv->base_qpn, &rss_map->indir_qp,
-                           KMALLOC_WAIT);
+                           MEM_WAIT);
        if (err) {
                en_err(priv, "Failed to allocate RSS indirection QP\n");
                goto rss_err;
index 3f469e9..1204c28 100644 (file)
@@ -44,9 +44,9 @@ int mlx4_en_create_tx_ring(struct mlx4_en_priv *priv,
        int tmp;
        int err;
 
-       ring = kzalloc_node(sizeof(*ring), KMALLOC_WAIT, node);
+       ring = kzalloc_node(sizeof(*ring), MEM_WAIT, node);
        if (!ring) {
-               ring = kzmalloc(sizeof(*ring), KMALLOC_WAIT);
+               ring = kzmalloc(sizeof(*ring), MEM_WAIT);
                if (!ring) {
                        en_err(priv, "Failed allocating TX ring\n");
                        return -ENOMEM;
@@ -58,7 +58,7 @@ int mlx4_en_create_tx_ring(struct mlx4_en_priv *priv,
        ring->stride = stride;
 
        tmp = size * sizeof(struct mlx4_en_tx_info);
-       ring->tx_info = kmalloc_node(tmp, KMALLOC_WAIT | __GFP_NOWARN, node);
+       ring->tx_info = kmalloc_node(tmp, MEM_WAIT | __GFP_NOWARN, node);
        if (!ring->tx_info) {
                ring->tx_info = vmalloc(tmp);
                if (!ring->tx_info) {
@@ -70,9 +70,9 @@ int mlx4_en_create_tx_ring(struct mlx4_en_priv *priv,
        en_dbg(DRV, priv, "Allocated tx_info ring at addr:%p size:%d\n",
                 ring->tx_info, tmp);
 
-       ring->bounce_buf = kmalloc_node(MAX_DESC_SIZE, KMALLOC_WAIT, node);
+       ring->bounce_buf = kmalloc_node(MAX_DESC_SIZE, MEM_WAIT, node);
        if (!ring->bounce_buf) {
-               ring->bounce_buf = kmalloc(MAX_DESC_SIZE, KMALLOC_WAIT);
+               ring->bounce_buf = kmalloc(MAX_DESC_SIZE, MEM_WAIT);
                if (!ring->bounce_buf) {
                        err = -ENOMEM;
                        goto err_info;
@@ -109,7 +109,7 @@ int mlx4_en_create_tx_ring(struct mlx4_en_priv *priv,
                goto err_map;
        }
 
-       err = mlx4_qp_alloc(mdev->dev, ring->qpn, &ring->qp, KMALLOC_WAIT);
+       err = mlx4_qp_alloc(mdev->dev, ring->qpn, &ring->qp, MEM_WAIT);
        if (err) {
                en_err(priv, "Failed allocating qp %d\n", ring->qpn);
                goto err_reserve;
index 8c87a70..e478afd 100644 (file)
@@ -955,14 +955,14 @@ static int mlx4_create_eq(struct mlx4_dev *dev, int nent,
        npages = PAGE_ALIGN(eq->nent * dev->caps.eqe_size) / PAGE_SIZE;
 
        eq->page_list = kmalloc(npages * sizeof *eq->page_list,
-                               KMALLOC_WAIT);
+                               MEM_WAIT);
        if (!eq->page_list)
                goto err_out;
 
        for (i = 0; i < npages; ++i)
                eq->page_list[i].buf = NULL;
 
-       dma_list = kmalloc(npages * sizeof *dma_list, KMALLOC_WAIT);
+       dma_list = kmalloc(npages * sizeof *dma_list, MEM_WAIT);
        if (!dma_list)
                goto err_out_free;
 
@@ -975,7 +975,7 @@ static int mlx4_create_eq(struct mlx4_dev *dev, int nent,
                eq->page_list[i].buf = dma_alloc_coherent(&dev->persist->
                                                          pdev->dev,
                                                          PAGE_SIZE, &t,
-                                                         KMALLOC_WAIT);
+                                                         MEM_WAIT);
                if (!eq->page_list[i].buf)
                        goto err_out_free_pages;
 
@@ -1145,7 +1145,7 @@ int mlx4_alloc_eq_table(struct mlx4_dev *dev)
        struct mlx4_priv *priv = mlx4_priv(dev);
 
        priv->eq_table.eq = kzmalloc((dev->caps.num_eqs - dev->caps.reserved_eqs) * (sizeof *priv->eq_table.eq),
-                                    KMALLOC_WAIT);
+                                    MEM_WAIT);
        if (!priv->eq_table.eq)
                return -ENOMEM;
 
@@ -1164,7 +1164,7 @@ int mlx4_init_eq_table(struct mlx4_dev *dev)
        int i;
 
        priv->eq_table.uar_map = kzmalloc((mlx4_num_eq_uar(dev)) * (sizeof *priv->eq_table.uar_map),
-                                         KMALLOC_WAIT);
+                                         MEM_WAIT);
        if (!priv->eq_table.uar_map) {
                err = -ENOMEM;
                goto err_out_free;
@@ -1196,7 +1196,7 @@ int mlx4_init_eq_table(struct mlx4_dev *dev)
        priv->eq_table.irq_names =
                kmalloc(MLX4_IRQNAME_SIZE * (dev->caps.num_comp_vectors + 1 +
                                             dev->caps.comp_pool),
-                       KMALLOC_WAIT);
+                       MEM_WAIT);
        if (!priv->eq_table.irq_names) {
                err = -ENOMEM;
                goto err_out_bitmap;
index cada6dd..25dcbcd 100644 (file)
@@ -362,7 +362,7 @@ int mlx4_table_get_range(struct mlx4_dev *dev, struct mlx4_icm_table *table,
        uint32_t i;
 
        for (i = start; i <= end; i += inc) {
-               err = mlx4_table_get(dev, table, i, KMALLOC_WAIT);
+               err = mlx4_table_get(dev, table, i, MEM_WAIT);
                if (err)
                        goto fail;
        }
@@ -402,7 +402,7 @@ int mlx4_init_icm_table(struct mlx4_dev *dev, struct mlx4_icm_table *table,
        num_icm = (nobj + obj_per_chunk - 1) / obj_per_chunk;
 
        table->icm      = kzmalloc((num_icm) * (sizeof *table->icm),
-                                  KMALLOC_WAIT);
+                                  MEM_WAIT);
        if (!table->icm)
                return -ENOMEM;
        table->virt     = virt;
@@ -421,7 +421,7 @@ int mlx4_init_icm_table(struct mlx4_dev *dev, struct mlx4_icm_table *table,
                                        i * MLX4_TABLE_CHUNK_SIZE);
 
                table->icm[i] = mlx4_alloc_icm(dev, chunk_size >> PAGE_SHIFT,
-                                              (use_lowmem ? KMALLOC_WAIT : GFP_HIGHUSER) |
+                                              (use_lowmem ? MEM_WAIT : GFP_HIGHUSER) |
                                               __GFP_NOWARN, use_coherent);
                if (!table->icm[i])
                        goto err;
index 2806444..2cdbad7 100644 (file)
@@ -50,7 +50,7 @@ static void mlx4_add_device(struct mlx4_interface *intf, struct mlx4_priv *priv)
 {
        struct mlx4_device_context *dev_ctx;
 
-       dev_ctx = kmalloc(sizeof *dev_ctx, KMALLOC_WAIT);
+       dev_ctx = kmalloc(sizeof *dev_ctx, MEM_WAIT);
        if (!dev_ctx)
                return;
 
index a664d68..c984ca1 100644 (file)
@@ -833,15 +833,15 @@ static int mlx4_slave_cap(struct mlx4_dev *dev)
        }
 
        dev->caps.qp0_qkey = kzmalloc((dev->caps.num_ports) * (sizeof(uint32_t)),
-                                     KMALLOC_WAIT);
+                                     MEM_WAIT);
        dev->caps.qp0_tunnel = kzmalloc((dev->caps.num_ports) * (sizeof(uint32_t)),
-                                       KMALLOC_WAIT);
+                                       MEM_WAIT);
        dev->caps.qp0_proxy = kzmalloc((dev->caps.num_ports) * (sizeof(uint32_t)),
-                                      KMALLOC_WAIT);
+                                      MEM_WAIT);
        dev->caps.qp1_tunnel = kzmalloc((dev->caps.num_ports) * (sizeof(uint32_t)),
-                                       KMALLOC_WAIT);
+                                       MEM_WAIT);
        dev->caps.qp1_proxy = kzmalloc((dev->caps.num_ports) * (sizeof(uint32_t)),
-                                      KMALLOC_WAIT);
+                                      MEM_WAIT);
 
        if (!dev->caps.qp0_tunnel || !dev->caps.qp0_proxy ||
            !dev->caps.qp1_tunnel || !dev->caps.qp1_proxy ||
@@ -2509,7 +2509,7 @@ static void mlx4_enable_msi_x(struct mlx4_dev *dev)
                nreq = MIN_T(int, dev->caps.num_eqs - dev->caps.reserved_eqs,
                             nreq);
 
-               entries = kzmalloc((nreq) * (sizeof *entries), KMALLOC_WAIT);
+               entries = kzmalloc((nreq) * (sizeof *entries), MEM_WAIT);
                if (!entries)
                        goto no_msi;
 
@@ -2638,7 +2638,7 @@ static int mlx4_init_steering(struct mlx4_dev *dev)
        int i, j;
 
        priv->steer = kzmalloc(sizeof(struct mlx4_steer) * num_entries,
-                              KMALLOC_WAIT);
+                              MEM_WAIT);
        if (!priv->steer)
                return -ENOMEM;
 
@@ -2748,7 +2748,7 @@ static uint64_t mlx4_enable_sriov(struct mlx4_dev *dev,
 
        if (reset_flow) {
                dev->dev_vfs = kzmalloc((total_vfs) * (sizeof(*dev->dev_vfs)),
-                                       KMALLOC_WAIT);
+                                       MEM_WAIT);
                if (!dev->dev_vfs)
                        goto free_mem;
                return dev_flags;
@@ -2764,7 +2764,7 @@ static uint64_t mlx4_enable_sriov(struct mlx4_dev *dev,
        }
 
        dev->dev_vfs = kzmalloc(total_vfs * sizeof(*dev->dev_vfs),
-                               KMALLOC_WAIT);
+                               MEM_WAIT);
        if (NULL == dev->dev_vfs) {
                mlx4_err(dev, "Failed to allocate memory for VFs\n");
                goto disable_sriov;
@@ -2926,7 +2926,7 @@ slave_start:
        if (mlx4_is_master(dev)) {
                /* when we hit the goto slave_start below, dev_cap already initialized */
                if (!dev_cap) {
-                       dev_cap = kzmalloc(sizeof(*dev_cap), KMALLOC_WAIT);
+                       dev_cap = kzmalloc(sizeof(*dev_cap), MEM_WAIT);
 
                        if (!dev_cap) {
                                err = -ENOMEM;
@@ -3410,12 +3410,12 @@ static int mlx4_init_one(struct pci_device *pdev,
 
        printk_once(KERN_INFO "%s", mlx4_version);
 
-       priv = kzmalloc(sizeof(*priv), KMALLOC_WAIT);
+       priv = kzmalloc(sizeof(*priv), MEM_WAIT);
        if (!priv)
                return -ENOMEM;
 
        dev       = &priv->dev;
-       dev->persist = kzmalloc(sizeof(*dev->persist), KMALLOC_WAIT);
+       dev->persist = kzmalloc(sizeof(*dev->persist), MEM_WAIT);
        if (!dev->persist) {
                kfree(priv);
                return -ENOMEM;
index 47a3741..fc6e312 100644 (file)
@@ -161,7 +161,7 @@ static int new_steering_entry(struct mlx4_dev *dev, uint8_t port,
                return -EINVAL;
 
        s_steer = &mlx4_priv(dev)->steer[port - 1];
-       new_entry = kzmalloc(sizeof *new_entry, KMALLOC_WAIT);
+       new_entry = kzmalloc(sizeof *new_entry, MEM_WAIT);
        if (!new_entry)
                return -ENOMEM;
 
@@ -174,7 +174,7 @@ static int new_steering_entry(struct mlx4_dev *dev, uint8_t port,
         */
        pqp = get_promisc_qp(dev, port, steer, qpn);
        if (pqp) {
-               dqp = kmalloc(sizeof *dqp, KMALLOC_WAIT);
+               dqp = kmalloc(sizeof *dqp, MEM_WAIT);
                if (!dqp) {
                        err = -ENOMEM;
                        goto out_alloc;
@@ -273,7 +273,7 @@ static int existing_steering_entry(struct mlx4_dev *dev, uint8_t port,
        }
 
        /* add the qp as a duplicate on this index */
-       dqp = kmalloc(sizeof *dqp, KMALLOC_WAIT);
+       dqp = kmalloc(sizeof *dqp, MEM_WAIT);
        if (!dqp)
                return -ENOMEM;
        dqp->qpn = qpn;
@@ -442,7 +442,7 @@ static int add_promisc_qp(struct mlx4_dev *dev, uint8_t port,
                goto out_mutex;
        }
 
-       pqp = kmalloc(sizeof *pqp, KMALLOC_WAIT);
+       pqp = kmalloc(sizeof *pqp, MEM_WAIT);
        if (!pqp) {
                err = -ENOMEM;
                goto out_mutex;
@@ -479,7 +479,7 @@ static int add_promisc_qp(struct mlx4_dev *dev, uint8_t port,
                                         * Add to duplicates.
                                         */
                                        dqp = kmalloc(sizeof(*dqp),
-                                                     KMALLOC_WAIT);
+                                                     MEM_WAIT);
                                        if (!dqp) {
                                                err = -ENOMEM;
                                                goto out_mailbox;
index 1eddbb8..f197114 100644 (file)
@@ -102,16 +102,16 @@ static int mlx4_buddy_init(struct mlx4_buddy *buddy, int max_order)
        spinlock_init(&buddy->lock);
 
        buddy->bits = kzmalloc((buddy->max_order + 1) * (sizeof(long *)),
-                              KMALLOC_WAIT);
+                              MEM_WAIT);
        buddy->num_free = kzmalloc(((buddy->max_order + 1)) * (sizeof *buddy->num_free),
-                                  KMALLOC_WAIT);
+                                  MEM_WAIT);
        if (!buddy->bits || !buddy->num_free)
                goto err_out;
 
        for (i = 0; i <= buddy->max_order; ++i) {
                s = BITS_TO_LONGS(1 << (buddy->max_order - i));
                buddy->bits[i] = kzmalloc((s) * (sizeof(long)),
-                                         KMALLOC_WAIT | __GFP_NOWARN);
+                                         MEM_WAIT | __GFP_NOWARN);
 #if 0 // AKAROS_PORT
                if (!buddy->bits[i]) {
                        buddy->bits[i] = vzalloc(s * sizeof(long));
@@ -644,7 +644,7 @@ int mlx4_mr_enable(struct mlx4_dev *dev, struct mlx4_mr *mr)
        struct mlx4_mpt_entry *mpt_entry;
        int err;
 
-       err = mlx4_mpt_alloc_icm(dev, key_to_hw_index(mr->key), KMALLOC_WAIT);
+       err = mlx4_mpt_alloc_icm(dev, key_to_hw_index(mr->key), MEM_WAIT);
        if (err)
                return err;
 
@@ -858,7 +858,7 @@ int mlx4_mw_enable(struct mlx4_dev *dev, struct mlx4_mw *mw)
        struct mlx4_mpt_entry *mpt_entry;
        int err;
 
-       err = mlx4_mpt_alloc_icm(dev, key_to_hw_index(mw->key), KMALLOC_WAIT);
+       err = mlx4_mpt_alloc_icm(dev, key_to_hw_index(mw->key), MEM_WAIT);
        if (err)
                return err;
 
index c2580b6..6dba1a1 100644 (file)
@@ -188,9 +188,9 @@ int mlx4_bf_alloc(struct mlx4_dev *dev, struct mlx4_bf *bf, int node)
                        err = -ENOMEM;
                        goto out;
                }
-               uar = kmalloc_node(sizeof(*uar), KMALLOC_WAIT, node);
+               uar = kmalloc_node(sizeof(*uar), MEM_WAIT, node);
                if (!uar) {
-                       uar = kmalloc(sizeof(*uar), KMALLOC_WAIT);
+                       uar = kmalloc(sizeof(*uar), MEM_WAIT);
                        if (!uar) {
                                err = -ENOMEM;
                                goto out;
index 2e76ab4..8633be6 100644 (file)
@@ -86,7 +86,7 @@ uint64_t mlx4_make_profile(struct mlx4_dev *dev,
 #endif
        int i, j;
 
-       profile = kzmalloc((MLX4_RES_NUM) * (sizeof(*profile)), KMALLOC_WAIT);
+       profile = kzmalloc((MLX4_RES_NUM) * (sizeof(*profile)), MEM_WAIT);
        if (!profile)
                return -ENOMEM;
 
index 652e032..31805d5 100644 (file)
@@ -515,7 +515,7 @@ static int mlx4_create_zones(struct mlx4_dev *dev,
        if (NULL == qp_table->zones)
                return -ENOMEM;
 
-       bitmap = kmalloc(sizeof(*bitmap), KMALLOC_WAIT);
+       bitmap = kmalloc(sizeof(*bitmap), MEM_WAIT);
 
        if (NULL == bitmap) {
                err = -ENOMEM;
@@ -808,13 +808,13 @@ int mlx4_init_qp_table(struct mlx4_dev *dev)
                /* In mfunc, calculate proxy and tunnel qp offsets for the PF here,
                 * since the PF does not call mlx4_slave_caps */
                dev->caps.qp0_tunnel = kzmalloc((dev->caps.num_ports) * (sizeof(uint32_t)),
-                                               KMALLOC_WAIT);
+                                               MEM_WAIT);
                dev->caps.qp0_proxy = kzmalloc((dev->caps.num_ports) * (sizeof(uint32_t)),
-                                              KMALLOC_WAIT);
+                                              MEM_WAIT);
                dev->caps.qp1_tunnel = kzmalloc((dev->caps.num_ports) * (sizeof(uint32_t)),
-                                               KMALLOC_WAIT);
+                                               MEM_WAIT);
                dev->caps.qp1_proxy = kzmalloc((dev->caps.num_ports) * (sizeof(uint32_t)),
-                                              KMALLOC_WAIT);
+                                              MEM_WAIT);
 
                if (!dev->caps.qp0_tunnel || !dev->caps.qp0_proxy ||
                    !dev->caps.qp1_tunnel || !dev->caps.qp1_proxy) {
index ebb5d23..e34405a 100644 (file)
@@ -64,7 +64,7 @@ int mlx4_reset(struct mlx4_dev *dev)
         */
 
        /* Do we need to save off the full 4K PCI Express header?? */
-       hca_header = kmalloc(256, KMALLOC_WAIT);
+       hca_header = kmalloc(256, MEM_WAIT);
        if (!hca_header) {
                err = -ENOMEM;
                mlx4_err(dev, "Couldn't allocate memory to save HCA PCI header, aborting\n");
index 20c9384..d9c68be 100644 (file)
@@ -463,7 +463,7 @@ int mlx4_init_resource_tracker(struct mlx4_dev *dev)
 
        priv->mfunc.master.res_tracker.slave_list =
                kzmalloc(dev->num_slaves * sizeof(struct slave_list),
-                        KMALLOC_WAIT);
+                        MEM_WAIT);
        if (!priv->mfunc.master.res_tracker.slave_list)
                return -ENOMEM;
 
@@ -483,15 +483,15 @@ int mlx4_init_resource_tracker(struct mlx4_dev *dev)
                struct resource_allocator *res_alloc =
                        &priv->mfunc.master.res_tracker.res_alloc[i];
                res_alloc->quota = kmalloc((dev->persist->num_vfs + 1) *
-                                          sizeof(int), KMALLOC_WAIT);
+                                          sizeof(int), MEM_WAIT);
                res_alloc->guaranteed = kmalloc((dev->persist->num_vfs + 1) *
-                                               sizeof(int), KMALLOC_WAIT);
+                                               sizeof(int), MEM_WAIT);
                if (i == RES_MAC || i == RES_VLAN)
                        res_alloc->allocated = kzmalloc(MLX4_MAX_PORTS * (dev->persist->num_vfs + 1) * sizeof(int),
-                                                       KMALLOC_WAIT);
+                                                       MEM_WAIT);
                else
                        res_alloc->allocated = kzmalloc((dev->persist->num_vfs + 1) * sizeof(int),
-                                                       KMALLOC_WAIT);
+                                                       MEM_WAIT);
 
                if (!res_alloc->quota || !res_alloc->guaranteed ||
                    !res_alloc->allocated)
@@ -859,7 +859,7 @@ static struct res_common *alloc_qp_tr(int id)
 {
        struct res_qp *ret;
 
-       ret = kzmalloc(sizeof *ret, KMALLOC_WAIT);
+       ret = kzmalloc(sizeof *ret, MEM_WAIT);
        if (!ret)
                return NULL;
 
@@ -877,7 +877,7 @@ static struct res_common *alloc_mtt_tr(int id, int order)
 {
        struct res_mtt *ret;
 
-       ret = kzmalloc(sizeof *ret, KMALLOC_WAIT);
+       ret = kzmalloc(sizeof *ret, MEM_WAIT);
        if (!ret)
                return NULL;
 
@@ -893,7 +893,7 @@ static struct res_common *alloc_mpt_tr(int id, int key)
 {
        struct res_mpt *ret;
 
-       ret = kzmalloc(sizeof *ret, KMALLOC_WAIT);
+       ret = kzmalloc(sizeof *ret, MEM_WAIT);
        if (!ret)
                return NULL;
 
@@ -908,7 +908,7 @@ static struct res_common *alloc_eq_tr(int id)
 {
        struct res_eq *ret;
 
-       ret = kzmalloc(sizeof *ret, KMALLOC_WAIT);
+       ret = kzmalloc(sizeof *ret, MEM_WAIT);
        if (!ret)
                return NULL;
 
@@ -922,7 +922,7 @@ static struct res_common *alloc_cq_tr(int id)
 {
        struct res_cq *ret;
 
-       ret = kzmalloc(sizeof *ret, KMALLOC_WAIT);
+       ret = kzmalloc(sizeof *ret, MEM_WAIT);
        if (!ret)
                return NULL;
 
@@ -937,7 +937,7 @@ static struct res_common *alloc_srq_tr(int id)
 {
        struct res_srq *ret;
 
-       ret = kzmalloc(sizeof *ret, KMALLOC_WAIT);
+       ret = kzmalloc(sizeof *ret, MEM_WAIT);
        if (!ret)
                return NULL;
 
@@ -952,7 +952,7 @@ static struct res_common *alloc_counter_tr(int id)
 {
        struct res_counter *ret;
 
-       ret = kzmalloc(sizeof *ret, KMALLOC_WAIT);
+       ret = kzmalloc(sizeof *ret, MEM_WAIT);
        if (!ret)
                return NULL;
 
@@ -966,7 +966,7 @@ static struct res_common *alloc_xrcdn_tr(int id)
 {
        struct res_xrcdn *ret;
 
-       ret = kzmalloc(sizeof *ret, KMALLOC_WAIT);
+       ret = kzmalloc(sizeof *ret, MEM_WAIT);
        if (!ret)
                return NULL;
 
@@ -980,7 +980,7 @@ static struct res_common *alloc_fs_rule_tr(uint64_t id, int qpn)
 {
        struct res_fs_rule *ret;
 
-       ret = kzmalloc(sizeof *ret, KMALLOC_WAIT);
+       ret = kzmalloc(sizeof *ret, MEM_WAIT);
        if (!ret)
                return NULL;
 
@@ -1049,7 +1049,7 @@ static int add_res_range(struct mlx4_dev *dev, int slave, uint64_t base,
        struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;
        struct rb_root *root = &tracker->res_tree[type];
 
-       res_arr = kzmalloc(count * sizeof *res_arr, KMALLOC_WAIT);
+       res_arr = kzmalloc(count * sizeof *res_arr, MEM_WAIT);
        if (!res_arr)
                return -ENOMEM;
 
@@ -1599,7 +1599,7 @@ static int qp_alloc_res(struct mlx4_dev *dev, int slave, int op, int cmd,
                        return err;
 
                if (!fw_reserved(dev, qpn)) {
-                       err = __mlx4_qp_alloc_icm(dev, qpn, KMALLOC_WAIT);
+                       err = __mlx4_qp_alloc_icm(dev, qpn, MEM_WAIT);
                        if (err) {
                                res_abort_move(dev, slave, RES_QP, qpn);
                                return err;
@@ -1686,7 +1686,7 @@ static int mpt_alloc_res(struct mlx4_dev *dev, int slave, int op, int cmd,
                if (err)
                        return err;
 
-               err = __mlx4_mpt_alloc_icm(dev, mpt->key, KMALLOC_WAIT);
+               err = __mlx4_mpt_alloc_icm(dev, mpt->key, MEM_WAIT);
                if (err) {
                        res_abort_move(dev, slave, RES_MPT, id);
                        return err;
@@ -1806,7 +1806,7 @@ static int mac_add_to_slave(struct mlx4_dev *dev, int slave, uint64_t mac,
 
        if (mlx4_grant_resource(dev, slave, RES_MAC, 1, port))
                return -EINVAL;
-       res = kzmalloc(sizeof *res, KMALLOC_WAIT);
+       res = kzmalloc(sizeof *res, MEM_WAIT);
        if (!res) {
                mlx4_release_resource(dev, slave, RES_MAC, 1, port);
                return -ENOMEM;
@@ -1913,7 +1913,7 @@ static int vlan_add_to_slave(struct mlx4_dev *dev, int slave, uint16_t vlan,
 
        if (mlx4_grant_resource(dev, slave, RES_VLAN, 1, port))
                return -EINVAL;
-       res = kzmalloc(sizeof(*res), KMALLOC_WAIT);
+       res = kzmalloc(sizeof(*res), MEM_WAIT);
        if (!res) {
                mlx4_release_resource(dev, slave, RES_VLAN, 1, port);
                return -ENOMEM;
@@ -3787,7 +3787,7 @@ static int add_mcg_res(struct mlx4_dev *dev, int slave, struct res_qp *rqp,
        struct res_gid *res;
        int err;
 
-       res = kzmalloc(sizeof *res, KMALLOC_WAIT);
+       res = kzmalloc(sizeof *res, MEM_WAIT);
        if (!res)
                return -ENOMEM;
 
index 784a342..75ca5b8 100644 (file)
@@ -100,11 +100,11 @@ int __mlx4_srq_alloc_icm(struct mlx4_dev *dev, int *srqn)
        if (*srqn == -1)
                return -ENOMEM;
 
-       err = mlx4_table_get(dev, &srq_table->table, *srqn, KMALLOC_WAIT);
+       err = mlx4_table_get(dev, &srq_table->table, *srqn, MEM_WAIT);
        if (err)
                goto err_out;
 
-       err = mlx4_table_get(dev, &srq_table->cmpt_table, *srqn, KMALLOC_WAIT);
+       err = mlx4_table_get(dev, &srq_table->cmpt_table, *srqn, MEM_WAIT);
        if (err)
                goto err_put;
        return 0;
index 796e310..b61dfc1 100644 (file)
@@ -85,9 +85,9 @@ extern void set_page_dirty_lock(struct page *pagep);
 #define        read_lock(p)
 #define        read_unlock(p)
 
-#define        GFP_KERNEL                      KMALLOC_WAIT
+#define        GFP_KERNEL                      MEM_WAIT
 #define        GFP_ATOMIC                      0
-#define        GFP_NOIO                        KMALLOC_WAIT
+#define        GFP_NOIO                        MEM_WAIT
 #define        GFP_NOWAIT                      0
 
 #define        __get_free_page(f)              kpage_alloc_addr()
index 32862ca..0ea26d0 100644 (file)
@@ -33,9 +33,6 @@ void *debug_canary;
 #define MEM_WAIT                               (1 << 2)
 #define MEM_ERROR                              (1 << 3)
 
-#define KMALLOC_WAIT                   MEM_WAIT
-#define KMALLOC_ERROR                  MEM_ERROR
-
 /* Kmalloc tag flags looks like this:
  *
  * +--------------28---------------+-----4------+
index bcd0809..77634e2 100644 (file)
@@ -190,7 +190,7 @@ static inline int radix_tree_insert(struct radix_tree_root *root,
                lp = lp->next;
        }
 
-       p = kmalloc(sizeof(*p), KMALLOC_WAIT);
+       p = kmalloc(sizeof(*p), MEM_WAIT);
        if (!p)
                return -ENOMEM;
        p->index = index;
index 74daf88..f80beda 100644 (file)
@@ -168,7 +168,7 @@ static inline int __dma_mapping_error(dma_addr_t dma_addr)
 
 static void *vmalloc(size_t size)
 {
-       void *vaddr = get_cont_pages(LOG2_UP(nr_pages(size)), KMALLOC_WAIT);
+       void *vaddr = get_cont_pages(LOG2_UP(nr_pages(size)), MEM_WAIT);
        /* zalloc, to be safe */
        if (vaddr)
                memset(vaddr, 0, size);
@@ -727,7 +727,7 @@ static inline int request_firmware(const struct firmware **fwp,
                kref_put(&fw_file->f_kref);
                return -1;
        }
-       ret_fw = kmalloc(sizeof(struct firmware), KMALLOC_WAIT);
+       ret_fw = kmalloc(sizeof(struct firmware), MEM_WAIT);
        ret_fw->data = fw_data;
        ret_fw->size = fw_file->f_dentry->d_inode->i_size;
        *fwp = ret_fw;
index 93dd174..b720d0a 100644 (file)
@@ -16,7 +16,7 @@ bool circular_buffer_init(struct circular_buffer *cb, size_t size, char *mem)
        if (mem)
                cb->base = mem;
        else
-               cb->base = kmalloc(size, KMALLOC_WAIT);
+               cb->base = kmalloc(size, MEM_WAIT);
        if (cb->base) {
                cb->rdptr = cb->wrptr = cb->base;
                cb->size = 0;
index a92b588..fef606a 100644 (file)
@@ -54,7 +54,8 @@ void slice_append(struct slice *s, void *p)
                if (s->capacity == 0)
                        s->capacity = 4;
                s->capacity *= 2;
-               ps = kreallocarray(s->ptrs, s->capacity, sizeof(void *), KMALLOC_WAIT);
+               ps = kreallocarray(s->ptrs, s->capacity, sizeof(void *),
+                                  MEM_WAIT);
                assert(ps != NULL);             /* XXX: if size*sizeof(void*) overflows. */
                s->ptrs = ps;
        }
@@ -71,7 +72,7 @@ void **slice_finalize(struct slice *slice)
 {
        void **ps;
 
-       ps = kreallocarray(slice->ptrs, slice->len, sizeof(void *), KMALLOC_WAIT);
+       ps = kreallocarray(slice->ptrs, slice->len, sizeof(void *), MEM_WAIT);
        assert(ps != NULL);
        slice->len = 0;
        slice->capacity = 0;
index c1b268a..909ad7b 100644 (file)
@@ -15,10 +15,10 @@ int zlib_inflate_blob(void *gunzip_buf, unsigned int sz,
        int rc;
 
        rc = -ENOMEM;
-       strm = kmalloc(sizeof(*strm), KMALLOC_WAIT);
+       strm = kmalloc(sizeof(*strm), MEM_WAIT);
        if (strm == NULL)
                goto gunzip_nomem1;
-       strm->workspace = kmalloc(zlib_inflate_workspacesize(), KMALLOC_WAIT);
+       strm->workspace = kmalloc(zlib_inflate_workspacesize(), MEM_WAIT);
        if (strm->workspace == NULL)
                goto gunzip_nomem2;
 
index b91ffa8..f714cdd 100644 (file)
@@ -72,7 +72,7 @@ struct dma_pool *dma_pool_create(const char *name, void *dev,
        else if ((boundary < size) || (boundary & (boundary - 1)))
                return NULL;
 
-       retval = kmalloc(sizeof(*retval), KMALLOC_WAIT);
+       retval = kmalloc(sizeof(*retval), MEM_WAIT);
        if (!retval)
                return retval;
 
index 643fdd8..d3a80da 100644 (file)
@@ -44,7 +44,7 @@ int add_fd_tap(struct proc *p, struct fd_tap_req *tap_req)
                set_errno(EBADF);
                return -1;
        }
-       tap = kzmalloc(sizeof(struct fd_tap), KMALLOC_WAIT);
+       tap = kzmalloc(sizeof(struct fd_tap), MEM_WAIT);
        tap->proc = p;
        tap->fd = fd;
        tap->filter = tap_req->filter;
index 8ad25fc..99c1626 100644 (file)
@@ -936,7 +936,7 @@ bool test_circular_buffer(void)
                off += csize;
        }
 
-       bigbuf = kzmalloc(cbsize, KMALLOC_WAIT);
+       bigbuf = kzmalloc(cbsize, MEM_WAIT);
        KT_ASSERT(bigbuf != NULL);
 
        mxsize = circular_buffer_max_write_size(&cb);
@@ -2091,7 +2091,7 @@ bool test_u16pool(void)
        int numalloc;
        KT_ASSERT(id);
 
-       t = kzmalloc(sizeof(int) * (AMT + 1), KMALLOC_WAIT);
+       t = kzmalloc(sizeof(int) * (AMT + 1), MEM_WAIT);
        for (x = 0; x < 1024; x++) {
                KT_ASSERT_M("Should be empty", id->tos == 0);
                for (i = 0; i < id->size; i++) {
index 5bd4432..c821abd 100644 (file)
@@ -79,7 +79,7 @@ static void rxmitproc(void *v);
 
 void arpinit(struct Fs *f)
 {
-       f->arp = kzmalloc(sizeof(struct arp), KMALLOC_WAIT);
+       f->arp = kzmalloc(sizeof(struct arp), MEM_WAIT);
        qlock_init(&f->arp->qlock);
        rendez_init(&f->arp->rxmtq);
        f->arp->f = f;
index 0865941..fe99cad 100644 (file)
@@ -311,7 +311,7 @@ static struct Fs *ipgetfs(int dev)
 
        qlock(&fslock);
        if (ipfs[dev] == NULL) {
-               f = kzmalloc(sizeof(struct Fs), KMALLOC_WAIT);
+               f = kzmalloc(sizeof(struct Fs), MEM_WAIT);
                rwinit(&f->rwlock);
                qlock_init(&f->iprouter.qlock);
                ip_init(f);
index 667f071..43e7477 100644 (file)
@@ -76,8 +76,8 @@ int kdial(char *dest, char *local, char *dir, int *cfdp)
        int rv;
        char *err, *alterr;
 
-       err = kmalloc(ERRMAX, KMALLOC_WAIT);
-       alterr = kmalloc(ERRMAX, KMALLOC_WAIT);
+       err = kmalloc(ERRMAX, MEM_WAIT);
+       alterr = kmalloc(ERRMAX, MEM_WAIT);
 
        ds.local = local;
        ds.dir = dir;
@@ -123,10 +123,10 @@ static int csdial(DS * ds)
        int n, fd, rv = -1;
        char *p, *buf, *clone, *err, *besterr;
 
-       buf = kmalloc(Maxstring, KMALLOC_WAIT);
-       clone = kmalloc(Maxpath, KMALLOC_WAIT);
-       err = kmalloc(ERRMAX, KMALLOC_WAIT);
-       besterr = kmalloc(ERRMAX, KMALLOC_WAIT);
+       buf = kmalloc(Maxstring, MEM_WAIT);
+       clone = kmalloc(Maxpath, MEM_WAIT);
+       err = kmalloc(ERRMAX, MEM_WAIT);
+       besterr = kmalloc(ERRMAX, MEM_WAIT);
        /*
         *  open connection server
         */
@@ -190,9 +190,9 @@ static int call(char *clone, char *dest, DS * ds)
        int fd, cfd, n, retval;
        char *name, *data, *err, *p;
 
-       name = kmalloc(Maxpath, KMALLOC_WAIT);
-       data = kmalloc(Maxpath, KMALLOC_WAIT);
-       err = kmalloc(ERRMAX, KMALLOC_WAIT);
+       name = kmalloc(Maxpath, MEM_WAIT);
+       data = kmalloc(Maxpath, MEM_WAIT);
+       err = kmalloc(ERRMAX, MEM_WAIT);
 
        cfd = sysopen(clone, O_RDWR);
        if (cfd < 0) {
index 942d88d..f8749be 100644 (file)
@@ -182,8 +182,8 @@ static void etherbind(struct Ipifc *ifc, int argc, char **argv)
        if (argc < 2)
                error(EINVAL, ERROR_FIXME);
 
-       addr = kmalloc(Maxpath, KMALLOC_WAIT);  //char addr[2*KNAMELEN];
-       dir = kmalloc(Maxpath, KMALLOC_WAIT);   //char addr[2*KNAMELEN];
+       addr = kmalloc(Maxpath, MEM_WAIT);      //char addr[2*KNAMELEN];
+       dir = kmalloc(Maxpath, MEM_WAIT);       //char addr[2*KNAMELEN];
        mchan4 = cchan4 = achan = mchan6 = cchan6 = NULL;
        buf = NULL;
        if (waserror()) {
index ca219d5..fd15bce 100644 (file)
@@ -899,7 +899,7 @@ void tcpstart(struct conv *s, int mode)
        Tcpctl *tcb;
        struct tcppriv *tpriv;
        /* tcpackproc needs to free this if it ever exits */
-       char *kpname = kmalloc(KNAMELEN, KMALLOC_WAIT);
+       char *kpname = kmalloc(KNAMELEN, MEM_WAIT);
 
        tpriv = s->p->priv;
 
index ab68534..9a568f3 100644 (file)
@@ -99,7 +99,7 @@ static struct block *_allocb(int size, int mem_flags)
 
 struct block *allocb(int size)
 {
-       return _allocb(size, KMALLOC_WAIT);
+       return _allocb(size, MEM_WAIT);
 }
 
 /* Makes sure b has nr_bufs extra_data.  Will grow, but not shrink, an existing
index d6d4754..7b7717c 100644 (file)
@@ -141,7 +141,7 @@ struct chan *devattach(const char *name, char *spec)
                spec = "";
        /* 1 for #, 1 for ., 1 for \0 */
        buflen = strlen(name) + strlen(spec) + 3;
-       buf = kzmalloc(buflen, KMALLOC_WAIT);
+       buf = kzmalloc(buflen, MEM_WAIT);
        snprintf(buf, sizeof(buf), "#%s.%s", name, spec);
        c->name = newcname(buf);
        kfree(buf);
@@ -198,7 +198,7 @@ struct walkqid *devwalk(struct chan *c,
 
        alloc = 0;
        wq = kzmalloc(sizeof(struct walkqid) + nname * sizeof(struct qid),
-                                 KMALLOC_WAIT);
+                                 MEM_WAIT);
        if (waserror()) {
                if (alloc && wq->clone != NULL)
                        cclose(wq->clone);
index c1fd810..aaa33ce 100644 (file)
@@ -71,7 +71,7 @@ long devtabread(struct chan *c, void *buf, long n, int64_t off)
        struct dev *dev;
        char *alloc, *e, *p;
 
-       alloc = kzmalloc(READSTR, KMALLOC_WAIT);
+       alloc = kzmalloc(READSTR, MEM_WAIT);
        if (alloc == NULL)
                error(ENOMEM, ERROR_FIXME);
 
index 9837ac9..894512f 100644 (file)
@@ -80,7 +80,7 @@ struct pgrp *newpgrp(void)
 {
        struct pgrp *p;
 
-       p = kzmalloc(sizeof(struct pgrp), KMALLOC_WAIT);
+       p = kzmalloc(sizeof(struct pgrp), MEM_WAIT);
        kref_init(&p->ref, freepgrp, 1);
        p->pgrpid = NEXT_ID(pgrpid);
        p->progmode = 0644;
index 98bce76..0c0db2e 100644 (file)
@@ -589,7 +589,7 @@ struct block *adjustblock(struct block *bp, int len)
                        return bp;
                }
                /* Grow with extra data buffers. */
-               block_append_extra(bp, len - BLEN(bp), KMALLOC_WAIT);
+               block_append_extra(bp, len - BLEN(bp), MEM_WAIT);
                QDEBUG checkb(bp, "adjustblock 3");
                return bp;
        }
@@ -1142,7 +1142,7 @@ struct block *blist_clone(struct block *blist, int header_len, int len,
        do {
                ret = __blist_clone_to(blist, newb, len, offset);
                if (ret)
-                       block_add_extd(newb, ret, KMALLOC_WAIT);
+                       block_add_extd(newb, ret, MEM_WAIT);
        } while (ret);
        return newb;
 }
@@ -1162,7 +1162,7 @@ struct block *qclone(struct queue *q, int header_len, int len, uint32_t offset)
                ret = __blist_clone_to(q->bfirst, newb, len, offset);
                spin_unlock_irqsave(&q->lock);
                if (ret)
-                       block_add_extd(newb, ret, KMALLOC_WAIT);
+                       block_add_extd(newb, ret, MEM_WAIT);
        } while (ret);
        return newb;
 }
@@ -1822,7 +1822,7 @@ int qwrite(struct queue *q, void *vp, int len)
                b = allocb(64);
                ext_buf = kmalloc(n, 0);
                memcpy(ext_buf, p + sofar, n);
-               block_add_extd(b, 1, KMALLOC_WAIT); /* returns 0 on success */
+               block_add_extd(b, 1, MEM_WAIT); /* returns 0 on success */
                b->extra_data[0].base = (uintptr_t)ext_buf;
                b->extra_data[0].off = 0;
                b->extra_data[0].len = n;
index 451d5c7..08dccca 100644 (file)
@@ -687,7 +687,7 @@ static long rread(int fd, void *va, long n, int64_t * offp)
                /* expecting only one dirent at a time, o/w we're busted */
                assert(n >= sizeof(struct kdirent));
                if (!c->buf) {
-                       c->buf=kmalloc(DIRREADSIZE, KMALLOC_WAIT);
+                       c->buf = kmalloc(DIRREADSIZE, MEM_WAIT);
                        c->bufused = 0;
                }
                /* Attempt to extract an M, in case there was some already */
@@ -955,7 +955,7 @@ int sysfstatakaros(int fd, struct kstat *ks)
        
        int n = 4096;
        uint8_t *buf;
-       buf = kmalloc(n, KMALLOC_WAIT);
+       buf = kmalloc(n, MEM_WAIT);
        n = sysfstat(fd, buf, n);
        if (n > 0) {
                convM2kstat(buf, n, ks);
@@ -994,7 +994,7 @@ int sysstatakaros(char *path, struct kstat *ks)
        
        int n = 4096;
        uint8_t *buf;
-       buf = kmalloc(n, KMALLOC_WAIT);
+       buf = kmalloc(n, MEM_WAIT);
        n = sysstat(path, buf, n);
        if (n > 0) {
                convM2kstat(buf, n, ks);
index 9c727f7..535d16e 100644 (file)
@@ -208,7 +208,7 @@ void *get_cont_pages(size_t order, int flags)
        //If we couldn't find them, return NULL
        if( first == -1 ) {
                spin_unlock_irqsave(&colored_page_free_list_lock);
-               if (flags & KMALLOC_ERROR)
+               if (flags & MEM_ERROR)
                        error(ENOMEM, ERROR_FIXME);
                return NULL;
        }
@@ -266,7 +266,7 @@ void *get_cont_phys_pages_at(size_t order, physaddr_t at, int flags)
        for (unsigned long i = first_pg_nr; i < first_pg_nr + nr_pgs; i++) {
                if (!page_is_free(i)) {
                        spin_unlock_irqsave(&colored_page_free_list_lock);
-                       if (flags & KMALLOC_ERROR)
+                       if (flags & MEM_ERROR)
                                error(ENOMEM, ERROR_FIXME);
                        return NULL;
                }
index b0889f1..ad4910d 100644 (file)
@@ -2292,7 +2292,7 @@ void proc_get_set(struct process_set *pset)
                pset->size = atomic_read(&num_envs) + num_extra_alloc;
                pset->num_processes = 0;
                pset->procs = (struct proc **)
-                       kzmalloc(pset->size * sizeof(struct proc *), KMALLOC_WAIT);
+                       kzmalloc(pset->size * sizeof(struct proc *), MEM_WAIT);
                if (!pset->procs)
                        error(-ENOMEM, ERROR_FIXME);
 
index 644200d..d1abcc4 100644 (file)
@@ -278,7 +278,7 @@ static void alloc_cpu_buffers(void)
        qnonblock(profiler_queue, TRUE);
 
        profiler_percpu_ctx =
-           kzmalloc(sizeof(*profiler_percpu_ctx) * num_cores, KMALLOC_WAIT);
+           kzmalloc(sizeof(*profiler_percpu_ctx) * num_cores, MEM_WAIT);
 
        for (int i = 0; i < num_cores; i++) {
                struct profiler_cpu_context *b = &profiler_percpu_ctx[i];
index c6a1a95..397bb28 100644 (file)
@@ -166,7 +166,7 @@ void *kmem_cache_alloc(struct kmem_cache *cp, int flags)
                if (TAILQ_EMPTY(&cp->empty_slab_list) &&
                        !kmem_cache_grow(cp)) {
                        spin_unlock_irqsave(&cp->cache_lock);
-                       if (flags & KMALLOC_ERROR)
+                       if (flags & MEM_ERROR)
                                error(ENOMEM, ERROR_FIXME);
                        else
                                panic("[German Accent]: OOM for a small slab growth!!!");
index 42f7931..6e6e8b9 100644 (file)
@@ -20,7 +20,7 @@ struct u16_pool *create_u16_pool(unsigned int size)
        if (size > MAX_U16_POOL_SZ)
                return NULL;
        /* ids and check are alloced and aligned right after the id struct */
-       id = kmalloc(sizeof(*id) + sizeof(uint16_t) * size + size, KMALLOC_WAIT);
+       id = kmalloc(sizeof(*id) + sizeof(uint16_t) * size + size, MEM_WAIT);
        spinlock_init_irqsave(&id->lock);
        id->size = size;
        id->ids = (void *)&id[1];
index 03a9e3e..211f821 100644 (file)
@@ -245,7 +245,7 @@ static void systrace_finish_trace(struct kthread *kthread, long retval)
 
 static void alloc_sysc_str(struct kthread *kth)
 {
-       kth->name = kmalloc(SYSCALL_STRLEN, KMALLOC_WAIT);
+       kth->name = kmalloc(SYSCALL_STRLEN, MEM_WAIT);
        kth->name[0] = 0;
 }
 
@@ -1891,7 +1891,7 @@ intreg_t sys_readlink(struct proc *p, char *path, size_t path_l,
        path_d = lookup_dentry(t_path, 0);
        if (!path_d){
                int n = 2048;
-               buf = kmalloc(n*2, KMALLOC_WAIT);
+               buf = kmalloc(n*2, MEM_WAIT);
                struct dir *d = (void *)&buf[n];
                /* try 9ns. */
                if (sysstat(t_path, buf, n) > 0) {
@@ -2244,7 +2244,7 @@ static int vfs_wstat(struct file *file, uint8_t *stat_m, size_t stat_sz,
        int m_sz;
        int retval = 0;
 
-       dir = kzmalloc(sizeof(struct dir) + stat_sz, KMALLOC_WAIT);
+       dir = kzmalloc(sizeof(struct dir) + stat_sz, MEM_WAIT);
        m_sz = convM2D(stat_m, stat_sz, &dir[0], (char*)&dir[1]);
        if (m_sz != stat_sz) {
                set_error(EINVAL, ERROR_FIXME);
index 7ed5651..dac0468 100644 (file)
@@ -2005,7 +2005,7 @@ int do_pipe(struct file **pipe_files, int flags)
        /* Actually build the pipe.  We're using one page, hanging off the
         * pipe_inode_info struct.  When we release the inode, we free the pipe
         * memory too */
-       pipe_i->i_pipe = kmalloc(sizeof(struct pipe_inode_info), KMALLOC_WAIT);
+       pipe_i->i_pipe = kmalloc(sizeof(struct pipe_inode_info), MEM_WAIT);
        pii = pipe_i->i_pipe;
        if (!pii) {
                set_errno(ENOMEM);
@@ -2337,7 +2337,7 @@ void *kread_whole_file(struct file *file)
        ssize_t cpy_amt;
 
        size = file->f_dentry->d_inode->i_size;
-       contents = kmalloc(size, KMALLOC_WAIT);
+       contents = kmalloc(size, MEM_WAIT);
        cpy_amt = kread_file(file, contents, size);
        if (cpy_amt < 0) {
                printk("Error %d reading file %s\n", get_errno(), file_name(file));
@@ -2599,7 +2599,7 @@ void close_fdt(struct fd_table *fdt, bool cloexec)
        int idx = 0;
 
        to_close = kzmalloc(sizeof(struct file_desc) * fdt->max_files,
-                           KMALLOC_WAIT);
+                           MEM_WAIT);
        spin_lock(&fdt->lock);
        if (fdt->closed) {
                spin_unlock(&fdt->lock);
index 2e45f76..0b5199c 100644 (file)
@@ -1,6 +1,6 @@
 #!/bin/sh
 sed -i 's/nil/NULL/g' $1
-sed -i 's/KERN_WAIT/KMALLOC_WAIT/g' $1
+sed -i 's/KERN_WAIT/MEM_WAIT/g' $1
 sed -i 's/nelem/ARRAY_SIZE/g' $1
 
 # stuff I'm not smart enough to do with spatch
index ece5fb0..6536d09 100644 (file)
@@ -6,17 +6,17 @@
 @@
 @@
 -GFP_KERNEL
-+KMALLOC_WAIT
++MEM_WAIT
 
 @@
 @@
 -GFP_WAIT
-+KMALLOC_WAIT
++MEM_WAIT
 
 @@
 @@
 -__GFP_WAIT
-+KMALLOC_WAIT
++MEM_WAIT
 
 @@
 expression SZ;