M_DRM
free(sfb, M_DRM, sizeof(*sfb));
fb = malloc(sizeof(*fb), M_DRM, M_ZERO | M_WAITOK);
free(fb, M_DRM, sizeof(*fb));
M_DRM, M_WAITOK | M_ZERO);
head = mallocarray(1, sizeof(*head), M_DRM, M_NOWAIT | M_ZERO);
arg.busid = malloc(arg.busid_len + 1, M_DRM, M_NOWAIT);
dev = malloc(sizeof(struct drm_device), M_DRM,
M_DRM, M_WAITOK | M_ZERO);
free(dev->agp, M_DRM, 0);
free(dev->pdev->bus->self, M_DRM, sizeof(struct pci_dev));
free(dev, M_DRM, sizeof(struct drm_device));
mem = malloc(strsize, M_DRM, M_NOWAIT | M_ZERO);
free(mem, M_DRM, 0);
free(mem, M_DRM, 0);
free(obj, M_DRM, sizeof(*obj));
free(obj, M_DRM, sizeof(*obj));
obj = malloc(sizeof(*obj), M_DRM, M_WAITOK | M_ZERO);
free(fb, M_DRM, 0);
fb = malloc(sizeof(*fb), M_DRM, M_ZERO | M_WAITOK);
free(fb, M_DRM, sizeof(*fb));
adata = malloc(asize, M_DRM, M_WAITOK | M_ZERO);
free(adata, M_DRM, asize);
M_DRM, gfp_mask | M_ZERO);
free(table->sgl, M_DRM,
result->pointer = malloc(result->length, M_DRM, M_WAITOK);
bd = malloc(sizeof(*bd), M_DRM, M_WAITOK);
free(bd, M_DRM, sizeof(*bd));
drvdata = malloc(sizeof(*drvdata), M_DRM, M_WAITOK);
free(fence, M_DRM, 0);
cb = mallocarray(count, sizeof(*cb), M_DRM, M_WAITOK|M_CANFAIL|M_ZERO);
free(cb, M_DRM, count * sizeof(*cb));
struct dma_fence *f = malloc(sizeof(*f), M_DRM,
free(dfa->fences, M_DRM, 0);
M_DRM, M_WAITOK|M_CANFAIL|M_ZERO);
free(dmabuf, M_DRM, sizeof(struct dma_buf));
dmabuf = malloc(sizeof(struct dma_buf), M_DRM, M_WAITOK | M_ZERO);
thread = malloc(sizeof(*thread), M_DRM, M_WAITOK);
free(thread, M_DRM, sizeof(*thread));
struct kthread_worker *w = malloc(sizeof(*w), M_DRM, M_WAITOK);
free(sf, M_DRM, sizeof(struct sync_file));
free(worker, M_DRM, sizeof(*worker));
sf = malloc(sizeof(struct sync_file), M_DRM, M_WAITOK | M_ZERO);
free(thread, M_DRM, sizeof(*thread));
free(p, M_DRM, n * size);
free(m->p, M_DRM, m->size);
free(m, M_DRM, sizeof(*m));
struct drmm_node *node = malloc(sizeof(*node), M_DRM, M_WAITOK | M_ZERO);
struct drmm_node *node = malloc(sizeof(*node), M_DRM, M_WAITOK | M_ZERO);
free(n->p, M_DRM, n->size);
free(n, M_DRM, sizeof(*n));
struct drmm_node *node = malloc(sizeof(*node), M_DRM, flags | M_ZERO);
free(node, M_DRM, sizeof(*node));
struct drmm_node *node = malloc(sizeof(*node), M_DRM, flags | M_ZERO);
free(node, M_DRM, sizeof(*node));
struct drmm_node *node = malloc(sizeof(*node), M_DRM, flags | M_ZERO);
free(node, M_DRM, sizeof(*node));
return malloc(sizeof(struct dma_fence_chain), M_DRM,
free(dfc, M_DRM, sizeof(struct dma_fence_chain));
free(fence, M_DRM, 0);
struct firmware *f = malloc(sizeof(struct firmware), M_DRM,
free(f, M_DRM, sizeof(struct firmware));
free(__DECONST(struct firmware *, fw), M_DRM, sizeof(*fw));
buf = malloc(len + 1, M_DRM, flags);
return malloc(size, M_DRM, flags);
return malloc(n * size, M_DRM, flags);
return malloc(size, M_DRM, flags | M_ZERO);
free((void *)objp, M_DRM, 0);
#define kfree_rcu(objp, name) do { free((void *)objp, M_DRM, 0); } while(0)
return malloc(size, M_DRM, flags);
return malloc(n * size, M_DRM, flags);
return malloc(n * size, M_DRM, flags | M_ZERO);
return malloc(size, M_DRM, flags | M_ZERO);
free((void *)objp, M_DRM, 0);
char *p = malloc(size + 1, M_DRM, M_WAITOK | M_CANFAIL);
free(p, M_DRM, size + 1);
p = malloc(len, M_DRM, flags);
void *p = malloc(len, M_DRM, flags);
void *p = mallocarray(nemb, size, M_DRM, flags);
void *p = mallocarray(nemb, size, M_DRM, M_WAITOK | M_CANFAIL);
free(p, M_DRM, nemb * size);
char *p = malloc(size, M_DRM, M_WAITOK | M_CANFAIL);
free(p, M_DRM, size);
return malloc(size, M_DRM, M_WAITOK | M_CANFAIL);
return malloc(n * size, M_DRM, M_WAITOK | M_CANFAIL);
return malloc(n * size, M_DRM, M_WAITOK | M_CANFAIL | M_ZERO);
return malloc(size, M_DRM, M_WAITOK | M_CANFAIL | M_ZERO);
free(objp, M_DRM, 0);
#define M_RADIX M_DRM
entry = malloc(sizeof(struct ttm_pool_type_lru), M_DRM, M_WAITOK);
free(entry, M_DRM, sizeof(struct ttm_pool_type_lru));
free(entry, M_DRM, sizeof(struct ttm_pool_type_lru));