libsel4utils/src/vspace/client_server_vspace.c - 3p/sel4/sel4_libs - Git at Google

 /*
  * Copyright 2014, NICTA
  *
  * This software may be distributed and modified according to the terms of
  * the BSD 2-Clause license. Note that NO WARRANTY is provided.
  * See "LICENSE_BSD2.txt" for details.
  *
  * @TAG(NICTA_BSD)
  */

 #include <autoconf.h>

 #if defined CONFIG_LIB_SEL4_VKA && defined CONFIG_LIB_SEL4_VSPACE

 #include <sel4utils/client_server_vspace.h>
 #include <vka/capops.h>
 #include <sel4utils/mapping.h>
 #include <sel4utils/util.h>
 #include <stdlib.h>
 #include <sel4utils/vspace.h>
 #include <sel4utils/vspace_internal.h>

 #define OFFSET(x)  ((uintptr_t)(x) & MASK(BOTTOM_LEVEL_BITS_OFFSET) )
 #define ADDR(start, page) ( ((uintptr_t) start) + (page) * PAGE_SIZE_4K )

 typedef struct client_server_vspace {
     /* vspace of the server. we also use this to request memory for metadata */
     vspace_t *server;
     /* vspace of the client we are proxying calls for */
     vspace_t *client;
     vka_t *vka;
     /* a fake sel4utils vspace that acts as a translation layer */
     sel4utils_alloc_data_t translation_data;
     vspace_t translation;
 } client_server_vspace_t;

 static void unmap(client_server_vspace_t *cs_vspace, void *caddr, size_t size_bits)
 {
     /* determine the virtual address of the start */
     void *saddr = (void*)get_cap(cs_vspace->translation_data.top_level, (uintptr_t) caddr);
     assert(saddr);
     /* get the cap from the server vspace */
     seL4_CPtr cap = vspace_get_cap(cs_vspace->server, saddr);
     assert(cap);
     /* unmap */
     vspace_unmap_pages(cs_vspace->server, saddr, 1, size_bits, VSPACE_PRESERVE);
     /* delete and free the cap */
     cspacepath_t cap_path;
     vka_cspace_make_path(cs_vspace->vka, cap, &cap_path);
     vka_cnode_delete(&cap_path);
     vka_cspace_free(cs_vspace->vka, cap);
     /* remove our translation */
     clear_entries(&cs_vspace->translation, (uintptr_t) caddr, size_bits);
 }

 static void unmap_many(client_server_vspace_t *cs_vspace, void *caddr, size_t num_pages, size_t size_bits)
 {
     int i;
     for (i = 0; i < num_pages; i++) {
         unmap(cs_vspace, caddr + BIT(size_bits) * i, size_bits);
     }
 }

 static int dup_and_map(client_server_vspace_t *cs_vspace, seL4_CPtr cap, void *caddr, size_t size_bits)
 {
     /* duplicate the cap */
     seL4_CPtr server_cap;
     cspacepath_t cap_path, server_cap_path;
     int error = vka_cspace_alloc(cs_vspace->vka, &server_cap);
     if (error) {
         LOG_ERROR("Failed to allocate cslot");
         return error;
     }
     vka_cspace_make_path(cs_vspace->vka, cap, &cap_path);
     vka_cspace_make_path(cs_vspace->vka, server_cap, &server_cap_path);
     error = vka_cnode_copy(&server_cap_path, &cap_path, seL4_AllRights);
     if (error != seL4_NoError) {
         LOG_ERROR("Error copying frame cap");
         vka_cspace_free(cs_vspace->vka, server_cap);
         return -1;
     }
     /* map it into the server */
     void *saddr = vspace_map_pages(cs_vspace->server, &server_cap_path.capPtr, NULL, seL4_AllRights, 1, size_bits, 1);
     if (!saddr) {
         LOG_ERROR("Error mapping frame into server vspace");
         vka_cnode_delete(&server_cap_path);
         vka_cspace_free(cs_vspace->vka, server_cap);
         return -1;
     }
     /* update our translation */
     int i;
     uint32_t pages = BYTES_TO_4K_PAGES(BIT(size_bits));
     for (i = 0; i < pages; i++) {
         if (update_entry(&cs_vspace->translation, ADDR(caddr, i), (seL4_CPtr)ADDR(saddr, i), 0)) {
             /* remove the entries we already put in. we can't call
              * clear_entries because the portion to remove is not
              * a power of two size */
             for (i--; i >= 0; i--) {
                 clear(&cs_vspace->translation, ADDR(caddr, i));
             }
             vka_cnode_delete(&server_cap_path);
             vka_cspace_free(cs_vspace->vka, server_cap);
             return -1;
         }
     }
     return 0;
 }

 static int dup_and_map_many(client_server_vspace_t *cs_vspace, seL4_CPtr *caps, void *caddr, size_t num_pages, size_t size_bits)
 {
     int i;
     for (i = 0; i < num_pages; i++) {
         int error = dup_and_map(cs_vspace, caps[i], caddr + BIT(size_bits) * i, size_bits);
         if (error) {
             unmap_many(cs_vspace, caddr, i - 1, size_bits);
             return error;
         }
     }
     return 0;
 }

 static int find_dup_and_map_many(client_server_vspace_t *cs_vspace, void *caddr, size_t num_pages, size_t size_bits)
 {
     int i;
     seL4_CPtr caps[num_pages];
     for (i = 0; i < num_pages; i++) {
         caps[i] = vspace_get_cap(cs_vspace->client, caddr + BIT(size_bits) * i);
         assert(caps[i]);
     }
     return dup_and_map_many(cs_vspace, caps, caddr, num_pages, size_bits);
 }

 static reservation_t cs_reserve_range_aligned(vspace_t *vspace, size_t size, size_t size_bits, seL4_CapRights rights,
                                               int cacheable, void **result)
 {
     client_server_vspace_t *cs_vspace = (client_server_vspace_t*)vspace->data;
     assert(cacheable);
     get_alloc_data(cs_vspace->client)->page_directory = cs_vspace->translation_data.page_directory;
     /* we are not interested in client reservations, just proxy */
     return vspace_reserve_range_aligned(cs_vspace->client, size, size_bits, rights, cacheable, result);
 }

 static reservation_t cs_reserve_range_at(vspace_t *vspace, void *vaddr, size_t size, seL4_CapRights
                                          rights, int cacheable)
 {
     client_server_vspace_t *cs_vspace = (client_server_vspace_t*)vspace->data;
     assert(cacheable);
     get_alloc_data(cs_vspace->client)->page_directory = cs_vspace->translation_data.page_directory;
     /* we are not interested in client reservations, just proxy */
     return vspace_reserve_range_at(cs_vspace->client, vaddr, size, rights, cacheable);
 }

 static void cs_free_reservation(vspace_t *vspace, reservation_t reservation)
 {
     client_server_vspace_t *cs_vspace = (client_server_vspace_t*)vspace->data;
     get_alloc_data(cs_vspace->client)->page_directory = cs_vspace->translation_data.page_directory;
     vspace_free_reservation(cs_vspace->client, reservation);
 }

 static int cs_map_pages_at_vaddr(vspace_t *vspace, seL4_CPtr caps[], uint32_t cookies[], void *vaddr,
                                  size_t num_pages, size_t size_bits, reservation_t reservation)
 {
     client_server_vspace_t *cs_vspace = (client_server_vspace_t*)vspace->data;
     get_alloc_data(cs_vspace->client)->page_directory = cs_vspace->translation_data.page_directory;
     assert(size_bits >= 12);
     /* first map all the pages into the client */
     int result = vspace_map_pages_at_vaddr(cs_vspace->client, caps, cookies, vaddr, num_pages, size_bits, reservation);
     if (result) {
         LOG_ERROR("Error mapping pages into client vspace");
         /* some error, propagate up */
         return result;
     }
     /* now map them all into the server */
     result = dup_and_map_many(cs_vspace, caps, vaddr, num_pages, size_bits);
     if (result) {
         /* unmap */
         LOG_ERROR("Error mapping pages into server vspace");
         vspace_unmap_pages(cs_vspace->client, vaddr, num_pages, size_bits, VSPACE_PRESERVE);
         return result;
     }
     return 0;
 }

 static seL4_CPtr cs_get_cap(vspace_t *vspace, void *vaddr)
 {
     client_server_vspace_t *cs_vspace = (client_server_vspace_t*)vspace->data;
     get_alloc_data(cs_vspace->client)->page_directory = cs_vspace->translation_data.page_directory;
     /* return the client cap */
     return vspace_get_cap(cs_vspace->client, vaddr);
 }

 static seL4_CPtr cs_get_root(vspace_t *vspace)
 {
     client_server_vspace_t *cs_vspace = (client_server_vspace_t*)vspace->data;
     return cs_vspace->translation_data.page_directory;
 }

 static void cs_unmap_pages(vspace_t *vspace, void *vaddr, size_t num_pages, size_t size_bits, vka_t *vka)
 {
     client_server_vspace_t *cs_vspace = (client_server_vspace_t*)vspace->data;
     get_alloc_data(cs_vspace->client)->page_directory = cs_vspace->translation_data.page_directory;
     /* remove our mappings */
     unmap_many(cs_vspace, vaddr, num_pages, size_bits);
     /* unmap from the client */
     vspace_unmap_pages(cs_vspace->client, vaddr, num_pages, size_bits, vka);
 }

 static int cs_new_pages_at_vaddr(vspace_t *vspace, void *vaddr, size_t num_pages,
                                  size_t size_bits, reservation_t reservation)
 {
     client_server_vspace_t *cs_vspace = (client_server_vspace_t*)vspace->data;
     get_alloc_data(cs_vspace->client)->page_directory = cs_vspace->translation_data.page_directory;
     assert(size_bits >= 12);
     /* create new pages in the client first */
     int result = vspace_new_pages_at_vaddr(cs_vspace->client, vaddr, num_pages, size_bits, reservation);
     if (result) {
         LOG_ERROR("Error creating pages in client vspace");
         return result;
     }
     result = find_dup_and_map_many(cs_vspace, vaddr, num_pages, size_bits);
     if (result) {
         LOG_ERROR("Error mapping new page in server vspace");
         assert(!"Cannot delete pages we created in client vspace");
         return -1;
     }
     return 0;
 }

 int sel4utils_get_cs_vspace(vspace_t *vspace, vka_t *vka, vspace_t *server, vspace_t *client)
 {
     int error;
     client_server_vspace_t *cs_vspace = malloc(sizeof(*cs_vspace));
     if (cs_vspace == NULL) {
         LOG_ERROR("Failed to create translation vspace");
         return -1;
     }
     cs_vspace->server = server;
     cs_vspace->client = client;
     cs_vspace->vka = vka;

     error = sel4utils_get_vspace(server, &cs_vspace->translation, &cs_vspace->translation_data,
                                  vka, 0, NULL, NULL);
     if (error) {
         LOG_ERROR("Failed to create translation vspace");
         free(cs_vspace);
         return error;
     }

     vspace->data = cs_vspace;

     vspace->new_pages_at_vaddr = cs_new_pages_at_vaddr;

     vspace->map_pages_at_vaddr = cs_map_pages_at_vaddr;
     vspace->unmap_pages = cs_unmap_pages;

     vspace->reserve_range_aligned = cs_reserve_range_aligned;
     vspace->reserve_range_at = cs_reserve_range_at;
     vspace->free_reservation = cs_free_reservation;

     vspace->get_cap = cs_get_cap;
     vspace->get_root = cs_get_root;

     vspace->allocated_object = NULL;
     vspace->allocated_object_cookie = NULL;

     return 0;
 }

 void *sel4utils_cs_vspace_translate(vspace_t *vspace, void *addr)
 {
     client_server_vspace_t *cs_vspace = (client_server_vspace_t*)vspace->data;

     seL4_CPtr translation_result = get_cap(cs_vspace->translation_data.top_level, (uintptr_t) addr);

     /* the translation will throw away any non aligned bits, if we got a successful
      * translation then add the offset back onto the result */
     return translation_result == 0 ? NULL : (void *)(translation_result + OFFSET((uintptr_t) addr));
 }

 int sel4utils_cs_vspace_for_each(vspace_t *vspace, void *addr, uint32_t len,
                                  int (*proc)(void* addr, uint32_t len, void *cookie),
                                  void *cookie)
 {
     uintptr_t current_addr;
     uintptr_t next_addr;
     uintptr_t end_addr = (uintptr_t) addr + len;
     for (current_addr = (uintptr_t) addr; current_addr < end_addr; current_addr = next_addr) {
         uintptr_t current_aligned = PAGE_ALIGN_4K(current_addr);
         uintptr_t next_page_start = current_aligned + PAGE_SIZE_4K;
         next_addr = MIN(end_addr, next_page_start);
         uintptr_t saddr = (uintptr_t) sel4utils_cs_vspace_translate(vspace, (void *) current_aligned);
         if (!saddr) {
             return -1;
         }
         int result = proc((void*)(saddr + (current_addr - current_aligned)), next_addr - current_addr, cookie);
         if (result) {
             return result;
         }
     }
     return 0;
 }

 int sel4utils_cs_vspace_set_root(vspace_t *vspace, seL4_CPtr page_directory)
 {
     assert(vspace);

     client_server_vspace_t *cs_vspace = (client_server_vspace_t*)vspace->data;
     cs_vspace->translation_data.page_directory = page_directory;

     return 0;
 }

 #endif
	/*
	* Copyright 2014, NICTA
	*
	* This software may be distributed and modified according to the terms of
	* the BSD 2-Clause license. Note that NO WARRANTY is provided.
	* See "LICENSE_BSD2.txt" for details.
	*
	* @TAG(NICTA_BSD)
	*/

	#include <autoconf.h>

	#if defined CONFIG_LIB_SEL4_VKA && defined CONFIG_LIB_SEL4_VSPACE

	#include <sel4utils/client_server_vspace.h>
	#include <vka/capops.h>
	#include <sel4utils/mapping.h>
	#include <sel4utils/util.h>
	#include <stdlib.h>
	#include <sel4utils/vspace.h>
	#include <sel4utils/vspace_internal.h>

	#define OFFSET(x) ((uintptr_t)(x) & MASK(BOTTOM_LEVEL_BITS_OFFSET) )
	#define ADDR(start, page) ( ((uintptr_t) start) + (page) * PAGE_SIZE_4K )

	typedef struct client_server_vspace {
	/* vspace of the server. we also use this to request memory for metadata */
	vspace_t *server;
	/* vspace of the client we are proxying calls for */
	vspace_t *client;
	vka_t *vka;
	/* a fake sel4utils vspace that acts as a translation layer */
	sel4utils_alloc_data_t translation_data;
	vspace_t translation;
	} client_server_vspace_t;

	static void unmap(client_server_vspace_t cs_vspace, void caddr, size_t size_bits)
	{
	/* determine the virtual address of the start */
	void saddr = (void)get_cap(cs_vspace->translation_data.top_level, (uintptr_t) caddr);
	assert(saddr);
	/* get the cap from the server vspace */
	seL4_CPtr cap = vspace_get_cap(cs_vspace->server, saddr);
	assert(cap);
	/* unmap */
	vspace_unmap_pages(cs_vspace->server, saddr, 1, size_bits, VSPACE_PRESERVE);
	/* delete and free the cap */
	cspacepath_t cap_path;
	vka_cspace_make_path(cs_vspace->vka, cap, &cap_path);
	vka_cnode_delete(&cap_path);
	vka_cspace_free(cs_vspace->vka, cap);
	/* remove our translation */
	clear_entries(&cs_vspace->translation, (uintptr_t) caddr, size_bits);
	}

	static void unmap_many(client_server_vspace_t cs_vspace, void caddr, size_t num_pages, size_t size_bits)
	{
	int i;
	for (i = 0; i < num_pages; i++) {
	unmap(cs_vspace, caddr + BIT(size_bits) * i, size_bits);
	}
	}

	static int dup_and_map(client_server_vspace_t cs_vspace, seL4_CPtr cap, void caddr, size_t size_bits)
	{
	/* duplicate the cap */
	seL4_CPtr server_cap;
	cspacepath_t cap_path, server_cap_path;
	int error = vka_cspace_alloc(cs_vspace->vka, &server_cap);
	if (error) {
	LOG_ERROR("Failed to allocate cslot");
	return error;
	}
	vka_cspace_make_path(cs_vspace->vka, cap, &cap_path);
	vka_cspace_make_path(cs_vspace->vka, server_cap, &server_cap_path);
	error = vka_cnode_copy(&server_cap_path, &cap_path, seL4_AllRights);
	if (error != seL4_NoError) {
	LOG_ERROR("Error copying frame cap");
	vka_cspace_free(cs_vspace->vka, server_cap);
	return -1;
	}
	/* map it into the server */
	void *saddr = vspace_map_pages(cs_vspace->server, &server_cap_path.capPtr, NULL, seL4_AllRights, 1, size_bits, 1);
	if (!saddr) {
	LOG_ERROR("Error mapping frame into server vspace");
	vka_cnode_delete(&server_cap_path);
	vka_cspace_free(cs_vspace->vka, server_cap);
	return -1;
	}
	/* update our translation */
	int i;
	uint32_t pages = BYTES_TO_4K_PAGES(BIT(size_bits));
	for (i = 0; i < pages; i++) {
	if (update_entry(&cs_vspace->translation, ADDR(caddr, i), (seL4_CPtr)ADDR(saddr, i), 0)) {
	/* remove the entries we already put in. we can't call
	* clear_entries because the portion to remove is not
	* a power of two size */
	for (i--; i >= 0; i--) {
	clear(&cs_vspace->translation, ADDR(caddr, i));
	}
	vka_cnode_delete(&server_cap_path);
	vka_cspace_free(cs_vspace->vka, server_cap);
	return -1;
	}
	}
	return 0;
	}

	static int dup_and_map_many(client_server_vspace_t cs_vspace, seL4_CPtr caps, void *caddr, size_t num_pages, size_t size_bits)
	{
	int i;
	for (i = 0; i < num_pages; i++) {
	int error = dup_and_map(cs_vspace, caps[i], caddr + BIT(size_bits) * i, size_bits);
	if (error) {
	unmap_many(cs_vspace, caddr, i - 1, size_bits);
	return error;
	}
	}
	return 0;
	}

	static int find_dup_and_map_many(client_server_vspace_t cs_vspace, void caddr, size_t num_pages, size_t size_bits)
	{
	int i;
	seL4_CPtr caps[num_pages];
	for (i = 0; i < num_pages; i++) {
	caps[i] = vspace_get_cap(cs_vspace->client, caddr + BIT(size_bits) * i);
	assert(caps[i]);
	}
	return dup_and_map_many(cs_vspace, caps, caddr, num_pages, size_bits);
	}

	static reservation_t cs_reserve_range_aligned(vspace_t *vspace, size_t size, size_t size_bits, seL4_CapRights rights,
	int cacheable, void **result)
	{
	client_server_vspace_t cs_vspace = (client_server_vspace_t)vspace->data;
	assert(cacheable);
	get_alloc_data(cs_vspace->client)->page_directory = cs_vspace->translation_data.page_directory;
	/* we are not interested in client reservations, just proxy */
	return vspace_reserve_range_aligned(cs_vspace->client, size, size_bits, rights, cacheable, result);
	}

	static reservation_t cs_reserve_range_at(vspace_t vspace, void vaddr, size_t size, seL4_CapRights
	rights, int cacheable)
	{
	client_server_vspace_t cs_vspace = (client_server_vspace_t)vspace->data;
	assert(cacheable);
	get_alloc_data(cs_vspace->client)->page_directory = cs_vspace->translation_data.page_directory;
	/* we are not interested in client reservations, just proxy */
	return vspace_reserve_range_at(cs_vspace->client, vaddr, size, rights, cacheable);
	}

	static void cs_free_reservation(vspace_t *vspace, reservation_t reservation)
	{
	client_server_vspace_t cs_vspace = (client_server_vspace_t)vspace->data;
	get_alloc_data(cs_vspace->client)->page_directory = cs_vspace->translation_data.page_directory;
	vspace_free_reservation(cs_vspace->client, reservation);
	}

	static int cs_map_pages_at_vaddr(vspace_t vspace, seL4_CPtr caps[], uint32_t cookies[], void vaddr,
	size_t num_pages, size_t size_bits, reservation_t reservation)
	{
	client_server_vspace_t cs_vspace = (client_server_vspace_t)vspace->data;
	get_alloc_data(cs_vspace->client)->page_directory = cs_vspace->translation_data.page_directory;
	assert(size_bits >= 12);
	/* first map all the pages into the client */
	int result = vspace_map_pages_at_vaddr(cs_vspace->client, caps, cookies, vaddr, num_pages, size_bits, reservation);
	if (result) {
	LOG_ERROR("Error mapping pages into client vspace");
	/* some error, propagate up */
	return result;
	}
	/* now map them all into the server */
	result = dup_and_map_many(cs_vspace, caps, vaddr, num_pages, size_bits);
	if (result) {
	/* unmap */
	LOG_ERROR("Error mapping pages into server vspace");
	vspace_unmap_pages(cs_vspace->client, vaddr, num_pages, size_bits, VSPACE_PRESERVE);
	return result;
	}
	return 0;
	}

	static seL4_CPtr cs_get_cap(vspace_t vspace, void vaddr)
	{
	client_server_vspace_t cs_vspace = (client_server_vspace_t)vspace->data;
	get_alloc_data(cs_vspace->client)->page_directory = cs_vspace->translation_data.page_directory;
	/* return the client cap */
	return vspace_get_cap(cs_vspace->client, vaddr);
	}

	static seL4_CPtr cs_get_root(vspace_t *vspace)
	{
	client_server_vspace_t cs_vspace = (client_server_vspace_t)vspace->data;
	return cs_vspace->translation_data.page_directory;
	}

	static void cs_unmap_pages(vspace_t vspace, void vaddr, size_t num_pages, size_t size_bits, vka_t *vka)
	{
	client_server_vspace_t cs_vspace = (client_server_vspace_t)vspace->data;
	get_alloc_data(cs_vspace->client)->page_directory = cs_vspace->translation_data.page_directory;
	/* remove our mappings */
	unmap_many(cs_vspace, vaddr, num_pages, size_bits);
	/* unmap from the client */
	vspace_unmap_pages(cs_vspace->client, vaddr, num_pages, size_bits, vka);
	}

	static int cs_new_pages_at_vaddr(vspace_t vspace, void vaddr, size_t num_pages,
	size_t size_bits, reservation_t reservation)
	{
	client_server_vspace_t cs_vspace = (client_server_vspace_t)vspace->data;
	get_alloc_data(cs_vspace->client)->page_directory = cs_vspace->translation_data.page_directory;
	assert(size_bits >= 12);
	/* create new pages in the client first */
	int result = vspace_new_pages_at_vaddr(cs_vspace->client, vaddr, num_pages, size_bits, reservation);
	if (result) {
	LOG_ERROR("Error creating pages in client vspace");
	return result;
	}
	result = find_dup_and_map_many(cs_vspace, vaddr, num_pages, size_bits);
	if (result) {
	LOG_ERROR("Error mapping new page in server vspace");
	assert(!"Cannot delete pages we created in client vspace");
	return -1;
	}
	return 0;
	}

	int sel4utils_get_cs_vspace(vspace_t vspace, vka_t vka, vspace_t server, vspace_t client)
	{
	int error;
	client_server_vspace_t cs_vspace = malloc(sizeof(cs_vspace));
	if (cs_vspace == NULL) {
	LOG_ERROR("Failed to create translation vspace");
	return -1;
	}
	cs_vspace->server = server;
	cs_vspace->client = client;
	cs_vspace->vka = vka;

	error = sel4utils_get_vspace(server, &cs_vspace->translation, &cs_vspace->translation_data,
	vka, 0, NULL, NULL);
	if (error) {
	LOG_ERROR("Failed to create translation vspace");
	free(cs_vspace);
	return error;
	}

	vspace->data = cs_vspace;

	vspace->new_pages_at_vaddr = cs_new_pages_at_vaddr;

	vspace->map_pages_at_vaddr = cs_map_pages_at_vaddr;
	vspace->unmap_pages = cs_unmap_pages;

	vspace->reserve_range_aligned = cs_reserve_range_aligned;
	vspace->reserve_range_at = cs_reserve_range_at;
	vspace->free_reservation = cs_free_reservation;

	vspace->get_cap = cs_get_cap;
	vspace->get_root = cs_get_root;

	vspace->allocated_object = NULL;
	vspace->allocated_object_cookie = NULL;

	return 0;
	}

	void sel4utils_cs_vspace_translate(vspace_t vspace, void *addr)
	{
	client_server_vspace_t cs_vspace = (client_server_vspace_t)vspace->data;

	seL4_CPtr translation_result = get_cap(cs_vspace->translation_data.top_level, (uintptr_t) addr);

	/* the translation will throw away any non aligned bits, if we got a successful
	* translation then add the offset back onto the result */
	return translation_result == 0 ? NULL : (void *)(translation_result + OFFSET((uintptr_t) addr));
	}

	int sel4utils_cs_vspace_for_each(vspace_t vspace, void addr, uint32_t len,
	int (proc)(void addr, uint32_t len, void *cookie),
	void *cookie)
	{
	uintptr_t current_addr;
	uintptr_t next_addr;
	uintptr_t end_addr = (uintptr_t) addr + len;
	for (current_addr = (uintptr_t) addr; current_addr < end_addr; current_addr = next_addr) {
	uintptr_t current_aligned = PAGE_ALIGN_4K(current_addr);
	uintptr_t next_page_start = current_aligned + PAGE_SIZE_4K;
	next_addr = MIN(end_addr, next_page_start);
	uintptr_t saddr = (uintptr_t) sel4utils_cs_vspace_translate(vspace, (void *) current_aligned);
	if (!saddr) {
	return -1;
	}
	int result = proc((void*)(saddr + (current_addr - current_aligned)), next_addr - current_addr, cookie);
	if (result) {
	return result;
	}
	}
	return 0;
	}

	int sel4utils_cs_vspace_set_root(vspace_t *vspace, seL4_CPtr page_directory)
	{
	assert(vspace);

	client_server_vspace_t cs_vspace = (client_server_vspace_t)vspace->data;
	cs_vspace->translation_data.page_directory = page_directory;

	return 0;
	}

	#endif