mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-05 22:36:40 +07:00
45cd5290bf
Add a new seqfile for reporting coherent DMA allocations. This contains the address range, size and the function which was used to allocate each region, allowing these allocations to be viewed in much the same way as /proc/vmallocinfo. The DMA coherent region has limited space, so this allows allocation failures to be viewed, as well as finding out how much space is being used. Make sure this file is only readable by root - same as vmallocinfo - to prevent information leakage. Acked-by: Nicolas Pitre <nico@linaro.org> Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
206 lines
4.8 KiB
C
206 lines
4.8 KiB
C
#include <linux/fs.h>
|
|
#include <linux/spinlock.h>
|
|
#include <linux/list.h>
|
|
#include <linux/proc_fs.h>
|
|
#include <linux/seq_file.h>
|
|
#include <linux/slab.h>
|
|
|
|
#include "vmregion.h"
|
|
|
|
/*
|
|
* VM region handling support.
|
|
*
|
|
* This should become something generic, handling VM region allocations for
|
|
* vmalloc and similar (ioremap, module space, etc).
|
|
*
|
|
* I envisage vmalloc()'s supporting vm_struct becoming:
|
|
*
|
|
* struct vm_struct {
|
|
* struct vmregion region;
|
|
* unsigned long flags;
|
|
* struct page **pages;
|
|
* unsigned int nr_pages;
|
|
* unsigned long phys_addr;
|
|
* };
|
|
*
|
|
* get_vm_area() would then call vmregion_alloc with an appropriate
|
|
* struct vmregion head (eg):
|
|
*
|
|
* struct vmregion vmalloc_head = {
|
|
* .vm_list = LIST_HEAD_INIT(vmalloc_head.vm_list),
|
|
* .vm_start = VMALLOC_START,
|
|
* .vm_end = VMALLOC_END,
|
|
* };
|
|
*
|
|
* However, vmalloc_head.vm_start is variable (typically, it is dependent on
|
|
* the amount of RAM found at boot time.) I would imagine that get_vm_area()
|
|
* would have to initialise this each time prior to calling vmregion_alloc().
|
|
*/
|
|
|
|
struct arm_vmregion *
|
|
arm_vmregion_alloc(struct arm_vmregion_head *head, size_t align,
|
|
size_t size, gfp_t gfp, const void *caller)
|
|
{
|
|
unsigned long start = head->vm_start, addr = head->vm_end;
|
|
unsigned long flags;
|
|
struct arm_vmregion *c, *new;
|
|
|
|
if (head->vm_end - head->vm_start < size) {
|
|
printk(KERN_WARNING "%s: allocation too big (requested %#x)\n",
|
|
__func__, size);
|
|
goto out;
|
|
}
|
|
|
|
new = kmalloc(sizeof(struct arm_vmregion), gfp);
|
|
if (!new)
|
|
goto out;
|
|
|
|
new->caller = caller;
|
|
|
|
spin_lock_irqsave(&head->vm_lock, flags);
|
|
|
|
addr = rounddown(addr - size, align);
|
|
list_for_each_entry_reverse(c, &head->vm_list, vm_list) {
|
|
if (addr >= c->vm_end)
|
|
goto found;
|
|
addr = rounddown(c->vm_start - size, align);
|
|
if (addr < start)
|
|
goto nospc;
|
|
}
|
|
|
|
found:
|
|
/*
|
|
* Insert this entry after the one we found.
|
|
*/
|
|
list_add(&new->vm_list, &c->vm_list);
|
|
new->vm_start = addr;
|
|
new->vm_end = addr + size;
|
|
new->vm_active = 1;
|
|
|
|
spin_unlock_irqrestore(&head->vm_lock, flags);
|
|
return new;
|
|
|
|
nospc:
|
|
spin_unlock_irqrestore(&head->vm_lock, flags);
|
|
kfree(new);
|
|
out:
|
|
return NULL;
|
|
}
|
|
|
|
static struct arm_vmregion *__arm_vmregion_find(struct arm_vmregion_head *head, unsigned long addr)
|
|
{
|
|
struct arm_vmregion *c;
|
|
|
|
list_for_each_entry(c, &head->vm_list, vm_list) {
|
|
if (c->vm_active && c->vm_start == addr)
|
|
goto out;
|
|
}
|
|
c = NULL;
|
|
out:
|
|
return c;
|
|
}
|
|
|
|
struct arm_vmregion *arm_vmregion_find(struct arm_vmregion_head *head, unsigned long addr)
|
|
{
|
|
struct arm_vmregion *c;
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&head->vm_lock, flags);
|
|
c = __arm_vmregion_find(head, addr);
|
|
spin_unlock_irqrestore(&head->vm_lock, flags);
|
|
return c;
|
|
}
|
|
|
|
struct arm_vmregion *arm_vmregion_find_remove(struct arm_vmregion_head *head, unsigned long addr)
|
|
{
|
|
struct arm_vmregion *c;
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&head->vm_lock, flags);
|
|
c = __arm_vmregion_find(head, addr);
|
|
if (c)
|
|
c->vm_active = 0;
|
|
spin_unlock_irqrestore(&head->vm_lock, flags);
|
|
return c;
|
|
}
|
|
|
|
void arm_vmregion_free(struct arm_vmregion_head *head, struct arm_vmregion *c)
|
|
{
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&head->vm_lock, flags);
|
|
list_del(&c->vm_list);
|
|
spin_unlock_irqrestore(&head->vm_lock, flags);
|
|
|
|
kfree(c);
|
|
}
|
|
|
|
#ifdef CONFIG_PROC_FS
|
|
static int arm_vmregion_show(struct seq_file *m, void *p)
|
|
{
|
|
struct arm_vmregion *c = list_entry(p, struct arm_vmregion, vm_list);
|
|
|
|
seq_printf(m, "0x%08lx-0x%08lx %7lu", c->vm_start, c->vm_end,
|
|
c->vm_end - c->vm_start);
|
|
if (c->caller)
|
|
seq_printf(m, " %pS", (void *)c->caller);
|
|
seq_putc(m, '\n');
|
|
return 0;
|
|
}
|
|
|
|
static void *arm_vmregion_start(struct seq_file *m, loff_t *pos)
|
|
{
|
|
struct arm_vmregion_head *h = m->private;
|
|
spin_lock_irq(&h->vm_lock);
|
|
return seq_list_start(&h->vm_list, *pos);
|
|
}
|
|
|
|
static void *arm_vmregion_next(struct seq_file *m, void *p, loff_t *pos)
|
|
{
|
|
struct arm_vmregion_head *h = m->private;
|
|
return seq_list_next(p, &h->vm_list, pos);
|
|
}
|
|
|
|
static void arm_vmregion_stop(struct seq_file *m, void *p)
|
|
{
|
|
struct arm_vmregion_head *h = m->private;
|
|
spin_unlock_irq(&h->vm_lock);
|
|
}
|
|
|
|
static const struct seq_operations arm_vmregion_ops = {
|
|
.start = arm_vmregion_start,
|
|
.stop = arm_vmregion_stop,
|
|
.next = arm_vmregion_next,
|
|
.show = arm_vmregion_show,
|
|
};
|
|
|
|
static int arm_vmregion_open(struct inode *inode, struct file *file)
|
|
{
|
|
struct arm_vmregion_head *h = PDE(inode)->data;
|
|
int ret = seq_open(file, &arm_vmregion_ops);
|
|
if (!ret) {
|
|
struct seq_file *m = file->private_data;
|
|
m->private = h;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static const struct file_operations arm_vmregion_fops = {
|
|
.open = arm_vmregion_open,
|
|
.read = seq_read,
|
|
.llseek = seq_lseek,
|
|
.release = seq_release,
|
|
};
|
|
|
|
int arm_vmregion_create_proc(const char *path, struct arm_vmregion_head *h)
|
|
{
|
|
proc_create_data(path, S_IRUSR, NULL, &arm_vmregion_fops, h);
|
|
return 0;
|
|
}
|
|
#else
|
|
int arm_vmregion_create_proc(const char *path, struct arm_vmregion_head *h)
|
|
{
|
|
return 0;
|
|
}
|
|
#endif
|