--- /dev/null
+/* Copyright (c) 2007,2008 Sandia National Laboratories */
+
+#include <lwk/kernel.h>
+#include <lwk/task.h>
+#include <lwk/spinlock.h>
+#include <lwk/string.h>
+#include <lwk/aspace.h>
+#include <lwk/idspace.h>
+#include <lwk/htable.h>
+#include <lwk/log2.h>
+#include <lwk/cpuinfo.h>
+#include <lwk/pmem.h>
+#include <arch/uaccess.h>
+
+/**
+ * ID space used to allocate address space IDs.
+ */
+static idspace_t idspace;
+
+/**
+ * Hash table used to lookup address space structures by ID.
+ */
+static htable_t htable;
+
+/**
+ * Lock for serializing access to the htable.
+ */
+static DEFINE_SPINLOCK(htable_lock);
+
+/**
+ * Memory region structure. A memory region represents a contiguous region
+ * [start, end) of valid memory addresses in an address space.
+ */
+struct region {
+ struct aspace * aspace; /* Address space this region belongs to */
+ struct list_head link; /* Linkage in the aspace->region_list */
+
+ vaddr_t start; /* Starting address of the region */
+ vaddr_t end; /* 1st byte after end of the region */
+ vmflags_t flags; /* Permissions, caching, etc. */
+ vmpagesize_t pagesz; /* Allowed page sizes... 2^bit */
+ id_t smartmap; /* If (flags & VM_SMARTMAP), ID of the
+ aspace this region is mapped to */
+ char name[16]; /* Human-readable name of the region */
+};
+
+/**
+ * This calculates a region's end address. Normally end is the address of the
+ * first byte after the region. However if the region extends to the end of
+ * memory, that is not possible so set end to the last valid address,
+ * ULONG_MAX.
+ */
+static vaddr_t
+calc_end(vaddr_t start, size_t extent)
+{
+ vaddr_t end = start + extent;
+ if (end == 0)
+ end = ULONG_MAX;
+ return end;
+}
+
+/**
+ * Locates the region covering the specified address.
+ */
+static struct region *
+find_region(struct aspace *aspace, vaddr_t addr)
+{
+ struct region *rgn;
+
+ list_for_each_entry(rgn, &aspace->region_list, link) {
+ if ((rgn->start <= addr) && (rgn->end > addr))
+ return rgn;
+ }
+ return NULL;
+}
+
+/**
+ * Finds a region that overlaps the specified interval.
+ */
+static struct region *
+find_overlapping_region(struct aspace *aspace, vaddr_t start, vaddr_t end)
+{
+ struct region *rgn;
+
+ list_for_each_entry(rgn, &aspace->region_list, link) {
+ if ((start < rgn->end) && (end > rgn->start))
+ return rgn;
+ }
+ return NULL;
+}
+
+/**
+ * Locates the region that is SMARTMAP'ed to the specified aspace ID.
+ */
+static struct region *
+find_smartmap_region(struct aspace *aspace, id_t src_aspace)
+{
+ struct region *rgn;
+
+ list_for_each_entry(rgn, &aspace->region_list, link) {
+ if ((rgn->flags & VM_SMARTMAP) && (rgn->smartmap == src_aspace))
+ return rgn;
+ }
+ return NULL;
+}
+
+/**
+ * Looks up an aspace object by ID and returns it with its spinlock locked.
+ */
+static struct aspace *
+lookup_and_lock(id_t id)
+{
+ struct aspace *aspace;
+
+ /* Lock the hash table, lookup aspace object by ID */
+ spin_lock(&htable_lock);
+ if ((aspace = htable_lookup(htable, id)) == NULL) {
+ spin_unlock(&htable_lock);
+ return NULL;
+ }
+
+ /* Lock the identified aspace */
+ spin_lock(&aspace->lock);
+
+ /* Unlock the hash table, others may now use it */
+ spin_unlock(&htable_lock);
+
+ return aspace;
+}
+
+/**
+ * Like lookup_and_lock(), but looks up two address spaces instead of one.
+ */
+static int
+lookup_and_lock_two(id_t a, id_t b,
+ struct aspace **aspace_a, struct aspace **aspace_b)
+{
+ /* Lock the hash table, lookup aspace objects by ID */
+ spin_lock(&htable_lock);
+ if ((*aspace_a = htable_lookup(htable, a)) == NULL) {
+ spin_unlock(&htable_lock);
+ return -ENOENT;
+ }
+
+ if ((*aspace_b = htable_lookup(htable, b)) == NULL) {
+ spin_unlock(&htable_lock);
+ return -ENOENT;
+ }
+
+ /* Lock the identified aspaces */
+ spin_lock(&(*aspace_a)->lock);
+ spin_lock(&(*aspace_b)->lock);
+
+ /* Unlock the hash table, others may now use it */
+ spin_unlock(&htable_lock);
+
+ return 0;
+}
+
+static bool
+id_ok(id_t id)
+{
+ return ((id >= ASPACE_MIN_ID) && (id <= ASPACE_MAX_ID));
+}
+
+int __init
+aspace_subsys_init(void)
+{
+ int status;
+
+ /* Create an ID space for allocating address space IDs */
+ if ((status = idspace_create(__ASPACE_MIN_ID, __ASPACE_MAX_ID, &idspace)))
+ panic("Failed to create aspace ID space (status=%d).", status);
+
+ /* Create a hash table that will be used for quick ID->aspace lookups */
+ if ((status = htable_create(7 /* 2^7 bins */,
+ offsetof(struct aspace, id),
+ offsetof(struct aspace, ht_link),
+ &htable)))
+ panic("Failed to create aspace hash table (status=%d).", status);
+
+ /* Create an aspace for use by kernel threads */
+ if ((status = aspace_create(KERNEL_ASPACE_ID, "kernel", NULL)))
+ panic("Failed to create kernel aspace (status=%d).", status);
+
+ /* Switch to the newly created kernel address space */
+ if ((current->aspace = aspace_acquire(KERNEL_ASPACE_ID)) == NULL)
+ panic("Failed to acquire kernel aspace.");
+ arch_aspace_activate(current->aspace);
+
+ return 0;
+}
+
+int
+aspace_get_myid(id_t *id)
+{
+ *id = current->aspace->id;
+ return 0;
+}
+
+int
+sys_aspace_get_myid(id_t __user *id)
+{
+ int status;
+ id_t _id;
+
+ if ((status = aspace_get_myid(&_id)) != 0)
+ return status;
+
+ if (id && copy_to_user(id, &_id, sizeof(*id)))
+ return -EINVAL;
+
+ return 0;
+}
+
+int
+aspace_create(id_t id_request, const char *name, id_t *id)
+{
+ int status;
+ id_t new_id;
+ struct aspace *aspace;
+ unsigned long flags;
+
+ if ((status = idspace_alloc_id(idspace, id_request, &new_id)) != 0)
+ return status;
+
+ if ((aspace = kmem_alloc(sizeof(*aspace))) == NULL) {
+ idspace_free_id(idspace, new_id);
+ return -ENOMEM;
+ }
+
+ /*
+ * Initialize the address space. kmem_alloc() allocates zeroed memory
+ * so fields with an initial state of zero do not need to be explicitly
+ * initialized.
+ */
+ aspace->id = new_id;
+ spin_lock_init(&aspace->lock);
+ list_head_init(&aspace->region_list);
+ hlist_node_init(&aspace->ht_link);
+ if (name)
+ strlcpy(aspace->name, name, sizeof(aspace->name));
+
+ /* Create a region for the kernel portion of the address space */
+ status =
+ __aspace_add_region(
+ aspace,
+ PAGE_OFFSET,
+ ULONG_MAX-PAGE_OFFSET+1, /* # bytes to end of memory */
+ VM_KERNEL,
+ PAGE_SIZE,
+ "kernel"
+ );
+ if (status)
+ goto error1;
+
+ /* Do architecture-specific initialization */
+ if ((status = arch_aspace_create(aspace)) != 0)
+ goto error2;
+
+ /* Add new address space to a hash table, for quick lookups by ID */
+ spin_lock_irqsave(&htable_lock, flags);
+ BUG_ON(htable_add(htable, aspace));
+ spin_unlock_irqrestore(&htable_lock, flags);
+
+ if (id)
+ *id = new_id;
+ return 0;
+
+error2:
+ BUG_ON(__aspace_del_region(aspace,PAGE_OFFSET,ULONG_MAX-PAGE_OFFSET+1));
+error1:
+ idspace_free_id(idspace, aspace->id);
+ kmem_free(aspace);
+ return status;
+}
+
+int
+sys_aspace_create(id_t id_request, const char __user *name, id_t __user *id)
+{
+ int status;
+ char _name[16];
+ id_t _id;
+
+ if (current->uid != 0)
+ return -EPERM;
+
+ if ((id_request != ANY_ID) && !id_ok(id_request))
+ return -EINVAL;
+
+ if (strncpy_from_user(_name, name, sizeof(_name)) < 0)
+ return -EFAULT;
+ _name[sizeof(_name) - 1] = '\0';
+
+ if ((status = aspace_create(id_request, _name, &_id)) != 0)
+ return status;
+
+ BUG_ON(!id_ok(_id));
+
+ if (id && copy_to_user(id, &_id, sizeof(*id)))
+ return -EFAULT;
+
+ return 0;
+}
+
+int
+aspace_destroy(id_t id)
+{
+ struct aspace *aspace;
+ struct list_head *pos, *tmp;
+ struct region *rgn;
+ unsigned long irqstate;
+
+ /* Lock the hash table, lookup aspace object by ID */
+ spin_lock_irqsave(&htable_lock, irqstate);
+ if ((aspace = htable_lookup(htable, id)) == NULL) {
+ spin_unlock_irqrestore(&htable_lock, irqstate);
+ return -EINVAL;
+ }
+
+ /* Lock the identified aspace */
+ spin_lock(&aspace->lock);
+
+ if (aspace->refcnt) {
+ spin_unlock(&aspace->lock);
+ spin_unlock_irqrestore(&htable_lock, irqstate);
+ return -EBUSY;
+ }
+
+ /* Remove aspace from hash table, preventing others from finding it */
+ BUG_ON(htable_del(htable, aspace));
+
+ /* Unlock the hash table, others may now use it */
+ spin_unlock_irqrestore(&htable_lock, irqstate);
+ spin_unlock(&aspace->lock);
+
+ /* Finish up destroying the aspace, we have the only reference */
+ list_for_each_safe(pos, tmp, &aspace->region_list) {
+ rgn = list_entry(pos, struct region, link);
+ /* Must drop our reference on all SMARTMAP'ed aspaces */
+ if (rgn->flags & VM_SMARTMAP) {
+ struct aspace *src;
+ spin_lock_irqsave(&htable_lock, irqstate);
+ src = htable_lookup(htable, rgn->smartmap);
+ BUG_ON(src == NULL);
+ spin_lock(&src->lock);
+ --src->refcnt;
+ spin_unlock(&src->lock);
+ spin_unlock_irqrestore(&htable_lock, irqstate);
+ }
+ list_del(&rgn->link);
+ kmem_free(rgn);
+ }
+ arch_aspace_destroy(aspace);
+ BUG_ON(idspace_free_id(idspace, aspace->id));
+ kmem_free(aspace);
+ return 0;
+}
+
+int
+sys_aspace_destroy(id_t id)
+{
+ if (current->uid != 0)
+ return -EPERM;
+ if (!id_ok(id))
+ return -EINVAL;
+ return aspace_destroy(id);
+}
+
+/**
+ * Acquires an address space object. The object is guaranteed not to be
+ * deleted until it is released via aspace_release().
+ */
+struct aspace *
+aspace_acquire(id_t id)
+{
+ struct aspace *aspace;
+ unsigned long irqstate;
+
+ local_irq_save(irqstate);
+ if ((aspace = lookup_and_lock(id)) != NULL) {
+ ++aspace->refcnt;
+ spin_unlock(&aspace->lock);
+ }
+ local_irq_restore(irqstate);
+ return aspace;
+}
+
+/**
+ * Releases an aspace object that was previously acquired via aspace_acquire().
+ * The aspace object passed in must be unlocked.
+ */
+void
+aspace_release(struct aspace *aspace)
+{
+ unsigned long irqstate;
+ spin_lock_irqsave(&aspace->lock, irqstate);
+ --aspace->refcnt;
+ spin_unlock_irqrestore(&aspace->lock, irqstate);
+}
+
+int
+__aspace_find_hole(struct aspace *aspace,
+ vaddr_t start_hint, size_t extent, size_t alignment,
+ vaddr_t *start)
+{
+ struct region *rgn;
+ vaddr_t hole;
+
+ if (!aspace || !extent || !is_power_of_2(alignment))
+ return -EINVAL;
+
+ if (start_hint == 0)
+ start_hint = 1;
+
+ hole = round_up(start_hint, alignment);
+ while ((rgn = find_overlapping_region(aspace, hole, hole + extent))) {
+ if (rgn->end == ULONG_MAX)
+ return -ENOENT;
+ hole = round_up(rgn->end, alignment);
+ }
+
+ if (start)
+ *start = hole;
+ return 0;
+}
+
+int
+aspace_find_hole(id_t id,
+ vaddr_t start_hint, size_t extent, size_t alignment,
+ vaddr_t *start)
+{
+ int status;
+ struct aspace *aspace;
+ unsigned long irqstate;
+
+ local_irq_save(irqstate);
+ aspace = lookup_and_lock(id);
+ status = __aspace_find_hole(aspace, start_hint, extent, alignment,
+ start);
+ if (aspace) spin_unlock(&aspace->lock);
+ local_irq_restore(irqstate);
+ return status;
+}
+
+int
+sys_aspace_find_hole(id_t id,
+ vaddr_t start_hint, size_t extent, size_t alignment,
+ vaddr_t __user *start)
+{
+ vaddr_t _start;
+ int status;
+
+ if (current->uid != 0)
+ return -EPERM;
+
+ if (!id_ok(id))
+ return -EINVAL;
+
+ status = aspace_find_hole(id, start_hint, extent, alignment, &_start);
+ if (status)
+ return status;
+
+ if (start && copy_to_user(start, &_start, sizeof(_start)))
+ return -EFAULT;
+
+ return 0;
+}
+
+int
+__aspace_add_region(struct aspace *aspace,
+ vaddr_t start, size_t extent,
+ vmflags_t flags, vmpagesize_t pagesz,
+ const char *name)
+{
+ struct region *rgn;
+ struct region *cur;
+ struct list_head *pos;
+ vaddr_t end = calc_end(start, extent);
+
+ if (!aspace || !start)
+ return -EINVAL;
+
+ /* Region must have non-zero size */
+ if (extent == 0) {
+ printk(KERN_WARNING "Extent must be non-zero.\n");
+ return -EINVAL;
+ }
+
+ /* Region must have a positive size */
+ if (start >= end) {
+ printk(KERN_WARNING
+ "Invalid region size (start=0x%lx, extent=0x%lx).\n",
+ start, extent);
+ return -EINVAL;
+ }
+
+ /* Architecture must support the page size specified */
+ if ((pagesz & cpu_info[0].pagesz_mask) == 0) {
+ printk(KERN_WARNING
+ "Invalid page size specified (pagesz=0x%lx).\n",
+ pagesz);
+ return -EINVAL;
+ }
+ pagesz &= cpu_info[0].pagesz_mask;
+
+ /* Only one page size may be specified */
+ if (!is_power_of_2(pagesz)) {
+ printk(KERN_WARNING
+ "More than one page size specified (pagesz=0x%lx).\n",
+ pagesz);
+ return -EINVAL;
+ }
+
+ /* Region must be aligned to at least the specified page size */
+ if ((start & (pagesz-1)) || ((end!=ULONG_MAX) && (end & (pagesz-1)))) {
+ printk(KERN_WARNING
+ "Region is misaligned (start=0x%lx, end=0x%lx).\n",
+ start, end);
+ return -EINVAL;
+ }
+
+ /* Region must not overlap with any existing regions */
+ list_for_each_entry(cur, &aspace->region_list, link) {
+ if ((start < cur->end) && (end > cur->start)) {
+ printk(KERN_WARNING
+ "Region overlaps with existing region.\n");
+ return -ENOTUNIQ;
+ }
+ }
+
+ /* Allocate and initialize a new region object */
+ if ((rgn = kmem_alloc(sizeof(struct region))) == NULL)
+ return -ENOMEM;
+
+ rgn->aspace = aspace;
+ rgn->start = start;
+ rgn->end = end;
+ rgn->flags = flags;
+ rgn->pagesz = pagesz;
+ if (name)
+ strlcpy(rgn->name, name, sizeof(rgn->name));
+
+ /* The heap region is special, remember its bounds */
+ if (flags & VM_HEAP) {
+ aspace->heap_start = start;
+ aspace->heap_end = end;
+ aspace->brk = aspace->heap_start;
+ aspace->mmap_brk = aspace->heap_end;
+ }
+
+ /* Insert region into address space's sorted region list */
+ list_for_each(pos, &aspace->region_list) {
+ cur = list_entry(pos, struct region, link);
+ if (cur->start > rgn->start)
+ break;
+ }
+ list_add_tail(&rgn->link, pos);
+ return 0;
+}
+
+int
+aspace_add_region(id_t id,
+ vaddr_t start, size_t extent,
+ vmflags_t flags, vmpagesize_t pagesz,
+ const char *name)
+{
+ int status;
+ struct aspace *aspace;
+ unsigned long irqstate;
+
+ local_irq_save(irqstate);
+ aspace = lookup_and_lock(id);
+ status = __aspace_add_region(aspace, start, extent, flags, pagesz, name);
+ if (aspace) spin_unlock(&aspace->lock);
+ local_irq_restore(irqstate);
+ return status;
+}
+
+int
+sys_aspace_add_region(id_t id,
+ vaddr_t start, size_t extent,
+ vmflags_t flags, vmpagesize_t pagesz,
+ const char __user *name)
+{
+ char _name[16];
+
+ if (current->uid != 0)
+ return -EPERM;
+
+ if (!id_ok(id))
+ return -EINVAL;
+
+ if (strncpy_from_user(_name, name, sizeof(_name)) < 0)
+ return -EFAULT;
+ _name[sizeof(_name) - 1] = '\0';
+
+ return aspace_add_region(id, start, extent, flags, pagesz, _name);
+}
+
+
+int
+__aspace_del_region(struct aspace *aspace, vaddr_t start, size_t extent)
+{
+ int status;
+ struct region *rgn;
+ vaddr_t end = calc_end(start, extent);
+
+ if (!aspace)
+ return -EINVAL;
+
+ /* Locate the region to delete */
+ rgn = find_region(aspace, start);
+ if (!rgn || (rgn->start != start) || (rgn->end != end)
+ || (rgn->flags & VM_KERNEL))
+ return -EINVAL;
+
+ if (!(rgn->flags & VM_SMARTMAP)) {
+ /* Unmap all of the memory that was mapped to the region */
+ status = __aspace_unmap_pmem(aspace, start, extent);
+ if (status)
+ return status;
+ }
+
+ /* Remove the region from the address space */
+ list_del(&rgn->link);
+ kmem_free(rgn);
+ return 0;
+}
+
+int
+aspace_del_region(id_t id, vaddr_t start, size_t extent)
+{
+ int status;
+ struct aspace *aspace;
+ unsigned long irqstate;
+
+ local_irq_save(irqstate);
+ aspace = lookup_and_lock(id);
+ status = __aspace_del_region(aspace, start, extent);
+ if (aspace) spin_unlock(&aspace->lock);
+ local_irq_restore(irqstate);
+ return status;
+}
+
+int
+sys_aspace_del_region(id_t id, vaddr_t start, size_t extent)
+{
+ if (current->uid != 0)
+ return -EPERM;
+ if (!id_ok(id))
+ return -EINVAL;
+ return aspace_del_region(id, start, extent);
+}
+
+static int
+map_pmem(struct aspace *aspace,
+ paddr_t pmem, vaddr_t start, size_t extent,
+ bool umem_only)
+{
+ int status;
+ struct region *rgn;
+
+ if (!aspace)
+ return -EINVAL;
+
+ if (umem_only && !pmem_is_umem(pmem, extent)) {
+ printk(KERN_WARNING
+ "User-space tried to map non-UMEM "
+ "(pmem=0x%lx, extent=0x%lx).\n",
+ pmem, extent);
+ return -EPERM;
+ }
+
+ while (extent) {
+ /* Find region covering the address */
+ rgn = find_region(aspace, start);
+ if (!rgn) {
+ printk(KERN_WARNING
+ "Failed to find region covering addr=0x%lx.\n",
+ start);
+ return -EINVAL;
+ }
+
+ /* Can't map anything to kernel or SMARTMAP regions */
+ if ((rgn->flags & VM_KERNEL) || (rgn->flags & VM_SMARTMAP)) {
+ printk(KERN_WARNING
+ "Trying to map memory to protected region.\n");
+ return -EINVAL;
+ }
+
+ /* addresses must be aligned to region's page size */
+ if ((start & (rgn->pagesz-1)) || (pmem & (rgn->pagesz-1))) {
+ printk(KERN_WARNING
+ "Misalignment "
+ "(start=0x%lx, pmem=0x%lx, pagesz=0x%lx).\n",
+ start, pmem, rgn->pagesz);
+ return -EINVAL;
+ }
+
+ /* Map until full extent mapped or end of region is reached */
+ while (extent && (start < rgn->end)) {
+
+ status =
+ arch_aspace_map_page(
+ aspace,
+ start,
+ pmem,
+ rgn->flags,
+ rgn->pagesz
+ );
+ if (status)
+ return status;
+
+ extent -= rgn->pagesz;
+ start += rgn->pagesz;
+ pmem += rgn->pagesz;
+ }
+ }
+
+ return 0;
+}
+
+static int
+map_pmem_locked(id_t id,
+ paddr_t pmem, vaddr_t start, size_t extent,
+ bool umem_only)
+{
+ int status;
+ struct aspace *aspace;
+ unsigned long irqstate;
+
+ local_irq_save(irqstate);
+ aspace = lookup_and_lock(id);
+ status = map_pmem(aspace, pmem, start, extent, umem_only);
+ if (aspace) spin_unlock(&aspace->lock);
+ local_irq_restore(irqstate);
+ return status;
+}
+
+int
+__aspace_map_pmem(struct aspace *aspace,
+ paddr_t pmem, vaddr_t start, size_t extent)
+{
+ return map_pmem(aspace, pmem, start, extent, false);
+}
+
+int
+aspace_map_pmem(id_t id, paddr_t pmem, vaddr_t start, size_t extent)
+{
+ return map_pmem_locked(id, pmem, start, extent, false);
+}
+
+int
+sys_aspace_map_pmem(id_t id, paddr_t pmem, vaddr_t start, size_t extent)
+{
+ if (current->uid != 0)
+ return -EPERM;
+ if (!id_ok(id))
+ return -EINVAL;
+ return map_pmem_locked(id, pmem, start, extent, true);
+}
+
+int
+__aspace_unmap_pmem(struct aspace *aspace, vaddr_t start, size_t extent)
+{
+ struct region *rgn;
+
+ if (!aspace)
+ return -EINVAL;
+
+ while (extent) {
+ /* Find region covering the address */
+ rgn = find_region(aspace, start);
+ if (!rgn) {
+ printk(KERN_WARNING
+ "Failed to find region covering addr=0x%lx.\n",
+ start);
+ return -EINVAL;
+ }
+
+ /* Can't unmap anything from kernel or SMARTMAP regions */
+ if ((rgn->flags & VM_KERNEL) || (rgn->flags & VM_SMARTMAP)) {
+ printk(KERN_WARNING
+ "Trying to map memory to protected region.\n");
+ return -EINVAL;
+ }
+
+ /* address must be aligned to region's page size */
+ if (start & (rgn->pagesz-1)) {
+ printk(KERN_WARNING
+ "Misalignment (start=0x%lx, pagesz=0x%lx).\n",
+ start, rgn->pagesz);
+ return -EINVAL;
+ }
+
+ /* Unmap until full extent unmapped or end of region is reached */
+ while (extent && (start < rgn->end)) {
+
+ arch_aspace_unmap_page(
+ aspace,
+ start,
+ rgn->pagesz
+ );
+
+ extent -= rgn->pagesz;
+ start += rgn->pagesz;
+ }
+ }
+
+ return 0;
+}
+
+int
+aspace_unmap_pmem(id_t id, vaddr_t start, size_t extent)
+{
+ int status;
+ struct aspace *aspace;
+ unsigned long irqstate;
+
+ local_irq_save(irqstate);
+ aspace = lookup_and_lock(id);
+ status = __aspace_unmap_pmem(aspace, start, extent);
+ if (aspace) spin_unlock(&aspace->lock);
+ local_irq_restore(irqstate);
+ return status;
+}
+
+int
+sys_aspace_unmap_pmem(id_t id, vaddr_t start, size_t extent)
+{
+ if (current->uid != 0)
+ return -EPERM;
+ if (!id_ok(id))
+ return -EINVAL;
+ return aspace_unmap_pmem(id, start, extent);
+}
+
+int
+__aspace_smartmap(struct aspace *src, struct aspace *dst,
+ vaddr_t start, size_t extent)
+{
+ int status;
+ vaddr_t end = start + extent;
+ char name[16];
+ struct region *rgn;
+
+ /* Can only SMARTMAP a given aspace in once */
+ if (find_smartmap_region(dst, src->id))
+ return -EINVAL;
+
+ if (start >= end)
+ return -EINVAL;
+
+ if ((start & (SMARTMAP_ALIGN-1)) || (end & (SMARTMAP_ALIGN-1)))
+ return -EINVAL;
+
+ snprintf(name, sizeof(name), "SMARTMAP-%u", (unsigned int)src->id);
+ if ((status = __aspace_add_region(dst, start, extent,
+ VM_SMARTMAP, PAGE_SIZE, name)))
+ return status;
+
+ /* Do architecture-specific SMARTMAP initialization */
+ if ((status = arch_aspace_smartmap(src, dst, start, extent))) {
+ BUG_ON(__aspace_del_region(dst, start, extent));
+ return status;
+ }
+
+ /* Remember the source aspace that the SMARTMAP region is mapped to */
+ rgn = find_region(dst, start);
+ BUG_ON(!rgn);
+ rgn->smartmap = src->id;
+
+ /* Ensure source aspace doesn't go away while we have it SMARTMAP'ed */
+ ++src->refcnt;
+
+ return 0;
+}
+
+int
+aspace_smartmap(id_t src, id_t dst, vaddr_t start, size_t extent)
+{
+ int status;
+ struct aspace *src_spc, *dst_spc;
+ unsigned long irqstate;
+
+ /* Don't allow self SMARTMAP'ing */
+ if (src == dst)
+ return -EINVAL;
+
+ local_irq_save(irqstate);
+ if ((status = lookup_and_lock_two(src, dst, &src_spc, &dst_spc))) {
+ local_irq_restore(irqstate);
+ return status;
+ }
+ status = __aspace_smartmap(src_spc, dst_spc, start, extent);
+ spin_unlock(&src_spc->lock);
+ spin_unlock(&dst_spc->lock);
+ local_irq_restore(irqstate);
+ return status;
+}
+
+int
+sys_aspace_smartmap(id_t src, id_t dst, vaddr_t start, size_t extent)
+{
+ if (current->uid != 0)
+ return -EPERM;
+ if (!id_ok(src) || !id_ok(dst))
+ return -EINVAL;
+ return aspace_smartmap(src, dst, start, extent);
+}
+
+int
+__aspace_unsmartmap(struct aspace *src, struct aspace *dst)
+{
+ struct region *rgn;
+ size_t extent;
+
+ if ((rgn = find_smartmap_region(dst, src->id)) == NULL)
+ return -EINVAL;
+ extent = rgn->end - rgn->start;
+
+ /* Do architecture-specific SMARTMAP unmapping */
+ BUG_ON(arch_aspace_unsmartmap(src, dst, rgn->start, extent));
+
+ /* Delete the SMARTMAP region and release our reference on the source */
+ BUG_ON(__aspace_del_region(dst, rgn->start, extent));
+ --src->refcnt;
+
+ return 0;
+}
+
+int
+aspace_unsmartmap(id_t src, id_t dst)
+{
+ int status;
+ struct aspace *src_spc, *dst_spc;
+ unsigned long irqstate;
+
+ /* Don't allow self SMARTMAP'ing */
+ if (src == dst)
+ return -EINVAL;
+
+ local_irq_save(irqstate);
+ if ((status = lookup_and_lock_two(src, dst, &src_spc, &dst_spc))) {
+ local_irq_restore(irqstate);
+ return status;
+ }
+ status = __aspace_unsmartmap(src_spc, dst_spc);
+ spin_unlock(&src_spc->lock);
+ spin_unlock(&dst_spc->lock);
+ local_irq_restore(irqstate);
+ return status;
+}
+
+int
+sys_aspace_unsmartmap(id_t src, id_t dst)
+{
+ if (current->uid != 0)
+ return -EPERM;
+ if (!id_ok(src) || !id_ok(dst))
+ return -EINVAL;
+ return aspace_unsmartmap(src, dst);
+}
+
+int
+aspace_dump2console(id_t id)
+{
+ struct aspace *aspace;
+ struct region *rgn;
+ unsigned long irqstate;
+
+ local_irq_save(irqstate);
+
+ if ((aspace = lookup_and_lock(id)) == NULL) {
+ local_irq_restore(irqstate);
+ return -EINVAL;
+ }
+
+ printk(KERN_DEBUG "DUMP OF ADDRESS SPACE %u:\n", aspace->id);
+ printk(KERN_DEBUG " name: %s\n", aspace->name);
+ printk(KERN_DEBUG " refcnt: %d\n", aspace->refcnt);
+ printk(KERN_DEBUG " regions:\n");
+ list_for_each_entry(rgn, &aspace->region_list, link) {
+ printk(KERN_DEBUG
+ " [0x%016lx, 0x%016lx%c %s\n",
+ rgn->start,
+ rgn->end,
+ (rgn->end == ULONG_MAX) ? ']' : ')',
+ rgn->name
+ );
+ }
+
+ spin_unlock(&aspace->lock);
+ local_irq_restore(irqstate);
+ return 0;
+}
+
+int
+sys_aspace_dump2console(id_t id)
+{
+ return aspace_dump2console(id);
+}
