diff -r ec6442c07549 -r 7c011e163562 linux-2.6-xen-sparse/drivers/xen/xenidc/Makefile --- a/linux-2.6-xen-sparse/drivers/xen/xenidc/Makefile Wed Nov 23 17:37:53 2005 +++ b/linux-2.6-xen-sparse/drivers/xen/xenidc/Makefile Wed Nov 23 19:30:40 2005 @@ -8,3 +8,5 @@ xenidc-objs += xenidc_remote_buffer_reference.o xenidc-objs += xenidc_concatenate.o xenidc-objs += xenidc_wrapping.o +xenidc-objs += xenidc_grant_table.o +xenidc-objs += xenidc_vaddress.o diff -r ec6442c07549 -r 7c011e163562 linux-2.6-xen-sparse/include/asm-xen/xenidc_remote_buffer_reference.h --- a/linux-2.6-xen-sparse/include/asm-xen/xenidc_remote_buffer_reference.h Wed Nov 23 17:37:53 2005 +++ b/linux-2.6-xen-sparse/include/asm-xen/xenidc_remote_buffer_reference.h Wed Nov 23 19:30:40 2005 @@ -38,7 +38,8 @@ typedef u32 xenidc_rbr_type; -#define XENIDC_RBR_TYPE_NULL 0 +#define XENIDC_RBR_TYPE_NULL 0 +#define XENIDC_RBR_TYPE_GRANT_TABLE 1 #define XENIDC_RBR_ACCESS_FLAGS_READ 1 #define XENIDC_RBR_ACCESS_FLAGS_WRITE 2 diff -r ec6442c07549 -r 7c011e163562 linux-2.6-xen-sparse/drivers/xen/xenidc/xenidc_grant_table.c --- /dev/null Wed Nov 23 17:37:53 2005 +++ b/linux-2.6-xen-sparse/drivers/xen/xenidc/xenidc_grant_table.c Wed Nov 23 19:30:40 2005 @@ -0,0 +1,228 @@ +/*****************************************************************************/ +/* Xen inter-domain communication grant table remote buffer reference type. */ +/* */ +/* Copyright (c) 2005 Harry Butterworth IBM Corporation */ +/* */ +/* This program is free software; you can redistribute it and/or modify it */ +/* under the terms of the GNU General Public License as published by the */ +/* Free Software Foundation; either version 2 of the License, or (at your */ +/* option) any later version. */ +/* */ +/* This program is distributed in the hope that it will be useful, but */ +/* WITHOUT ANY WARRANTY; without even the implied warranty of */ +/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General */ +/* Public License for more details. */ +/* */ +/* You should have received a copy of the GNU General Public License along */ +/* with this program; if not, write to the Free Software Foundation, Inc., */ +/* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ +/* */ +/*****************************************************************************/ +/*****************************************************************************/ +/* Based on */ +/* */ +/* arch/xen/drivers/blkback/blkback.c */ +/* */ +/* original copyright notice follows... */ +/*****************************************************************************/ +/****************************************************************************** + * arch/xen/drivers/blkif/backend/main.c + * + * Back-end of the driver for virtual block devices. This portion of the + * driver exports a 'unified' block-device interface that can be accessed + * by any operating system that implements a compatible front end. A + * reference front-end implementation can be found in: + * arch/xen/drivers/blkif/frontend + * + * Copyright (c) 2003-2004, Keir Fraser & Steve Hand + * Copyright (c) 2005, Christopher Clark + */ + +#include +#include +#include "xenidc_trace.h" + +static int +xenidc_grant_table_calculate_map_resources( +struct xenidc_rbr_mappable_class *class, struct xenidc_rbr *rbr, +struct xenidc_address *address, struct xenidc_buffer_resource_list *list) +{ + int invalid_request = 0; + unsigned long first_page, final_page; + trace(); + if ((rbr->byte_offset + rbr->byte_count) < + (XENIDC_GRANT_TABLE_REFERENCE_COUNT * PAGE_SIZE)) { + *list = xenidc_buffer_resource_list_null(); + list->pages = 1; + list->empty_page_ranges = 1; + first_page = rbr->byte_offset / PAGE_SIZE; + final_page = (rbr->byte_offset + rbr->byte_count - 1) / + PAGE_SIZE; + list->empty_page_range_page_count = final_page - + first_page + 1; + } else { + invalid_request = 1; + } + return invalid_request; +} + +struct xenidc_grant_table_mapping_context { + struct xenidc_rbr_mappable_class *class; + struct xenidc_buffer_resource_provider *provider; + unsigned long page_count; + unsigned long mmap_vaddress; + int16_t handle[XENIDC_GRANT_TABLE_REFERENCE_COUNT]; +}; + +static void +xenidc_grant_table_unmap_rbr(struct xenidc_rbr_mappable_class **context_in); + +static struct xenidc_rbr_mappable_class ** +xenidc_grant_table_map_rbr(struct xenidc_rbr_mappable_class *class, +struct xenidc_rbr *rbr, struct xenidc_address *address, +struct xenidc_buffer_resource_provider *provider, void **mapping, +int access_flags) +{ + struct xenidc_grant_table_mapping_context *context; + struct gnttab_map_grant_ref map[XENIDC_GRANT_TABLE_REFERENCE_COUNT]; + unsigned long first_page, final_page; + int i, error; + struct xenidc_grant_table_base *base = + (struct xenidc_grant_table_base *)&rbr->base; + uint16_t map_flags = GNTMAP_host_map | (((access_flags & + XENIDC_RBR_ACCESS_FLAGS_WRITE) == 0) ? GNTMAP_readonly : 0); + trace(); + context = xenidc_buffer_resource_provider_allocate_page(provider); + first_page = rbr->byte_offset / PAGE_SIZE; + final_page = (rbr->byte_offset + rbr->byte_count - 1) / PAGE_SIZE; + context->class = class; + context->provider = provider; + context->page_count = final_page - first_page + 1; + context->mmap_vaddress = + xenidc_buffer_resource_provider_allocate_empty_page_range( + provider, context->page_count); + for (i = 0; i < context->page_count; i++) { + map[i].host_addr = context->mmap_vaddress + (i * PAGE_SIZE); + map[i].dom = xenidc_address_query_remote_domain_id(address); + map[i].ref = base->reference[first_page + i]; + map[i].flags = map_flags; + } + error = HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, map, + context->page_count); + BUG_ON(error); + error = 0; + for (i = 0; i < context->page_count; i++) { + context->handle[i] = map[i].handle; + if (unlikely(map[i].handle < 0)) { + error = 1; + } + } + if (!error) { + for (i = 0; i < context->page_count; i++) { + set_phys_to_machine(__pa(context->mmap_vaddress + + (i * PAGE_SIZE)) + >> PAGE_SHIFT, + FOREIGN_FRAME(map[i].dev_bus_addr + >> PAGE_SHIFT)); + } + } else { + xenidc_grant_table_unmap_rbr(&context->class); + context = NULL; + } + if (context != NULL) { + *mapping = (void *)(context->mmap_vaddress + + (rbr->byte_offset % PAGE_SIZE)); + return &context->class; + } else { + return NULL; + } +} + +static void +xenidc_grant_table_unmap_rbr(struct xenidc_rbr_mappable_class **context_in) +{ + struct xenidc_grant_table_mapping_context *context; + struct gnttab_unmap_grant_ref unmap + [XENIDC_GRANT_TABLE_REFERENCE_COUNT]; + int i,j,error; + trace(); + context = container_of(context_in, + struct xenidc_grant_table_mapping_context, class); + for (i = 0, j = 0; i < context->page_count; i++) { + if (context->handle[i] >= 0) { + unmap[j].host_addr = context->mmap_vaddress + (i * + PAGE_SIZE); + unmap[j].dev_bus_addr = 0; + unmap[j].handle = context->handle[i]; + j++; + } + } + if (j != 0) { + error = HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref, + unmap, j); + BUG_ON(error); + } + for (i = 0; i < context->page_count; i++) { + /* Tidy this up to avoid */ + /* BUG_ON(phys_to_machine_mapping[pfn] != INVALID_P2M_ENTRY);*/ + /* in balloon.c */ + set_phys_to_machine(__pa(context->mmap_vaddress + (i * + PAGE_SIZE)) >> PAGE_SHIFT, INVALID_P2M_ENTRY); + } + xenidc_buffer_resource_provider_free_empty_page_range( + context->provider, context->mmap_vaddress); + xenidc_buffer_resource_provider_free_page(context->provider, context); +} + +static void xenidc_grant_table_init(void) +{ + static int initialised = 0; + static struct xenidc_rbr_mappable_class + xenidc_grant_table_mappable_class; + static DEFINE_RWLOCK(xenidc_grant_table_lock); + unsigned long flags; + trace(); + read_lock_irqsave(&xenidc_grant_table_lock, flags); + if (initialised) { + read_unlock_irqrestore(&xenidc_grant_table_lock, flags); + return; + } + read_unlock_irqrestore(&xenidc_grant_table_lock, flags); + write_lock_irqsave(&xenidc_grant_table_lock, flags); + if (initialised) { + write_unlock_irqrestore(&xenidc_grant_table_lock, flags); + return; + } + xenidc_rbr_register_buffer_mappable_class( + &xenidc_grant_table_mappable_class, + XENIDC_RBR_TYPE_GRANT_TABLE, + xenidc_grant_table_calculate_map_resources, + xenidc_grant_table_map_rbr, + xenidc_grant_table_unmap_rbr); + initialised = 1; + write_unlock_irqrestore(&xenidc_grant_table_lock, flags); +} + +struct xenidc_buffer_resource_list +xenidc_grant_table_calculate_buffer_resource_list( +xenidc_buffer_byte_count byte_count, xenidc_buffer_byte_count byte_alignment) +{ + struct xenidc_buffer_resource_list list; + xenidc_buffer_byte_count requested_page_count; + trace(); + xenidc_grant_table_init(); + list = xenidc_buffer_resource_list_null(); + if (byte_count > 0) { + list.pages = 1; + list.empty_page_ranges = 1; + requested_page_count = ((((byte_alignment % PAGE_SIZE) + + byte_count - 1) / PAGE_SIZE) + 1); + list.empty_page_range_page_count = ((requested_page_count < + XENIDC_GRANT_TABLE_REFERENCE_COUNT) ? + requested_page_count : + XENIDC_GRANT_TABLE_REFERENCE_COUNT); + } + return list; +} + +EXPORT_SYMBOL(xenidc_grant_table_calculate_buffer_resource_list); diff -r ec6442c07549 -r 7c011e163562 linux-2.6-xen-sparse/drivers/xen/xenidc/xenidc_vaddress.c --- /dev/null Wed Nov 23 17:37:53 2005 +++ b/linux-2.6-xen-sparse/drivers/xen/xenidc/xenidc_vaddress.c Wed Nov 23 19:30:40 2005 @@ -0,0 +1,249 @@ +/*****************************************************************************/ +/* Xen inter-domain communication vaddress local buffer reference type. */ +/* */ +/* Copyright (c) 2005 Harry Butterworth IBM Corporation */ +/* */ +/* This program is free software; you can redistribute it and/or modify it */ +/* under the terms of the GNU General Public License as published by the */ +/* Free Software Foundation; either version 2 of the License, or (at your */ +/* option) any later version. */ +/* */ +/* This program is distributed in the hope that it will be useful, but */ +/* WITHOUT ANY WARRANTY; without even the implied warranty of */ +/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General */ +/* Public License for more details. */ +/* */ +/* You should have received a copy of the GNU General Public License along */ +/* with this program; if not, write to the Free Software Foundation, Inc., */ +/* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ +/* */ +/*****************************************************************************/ + +#include +#include +#include +#include +#include "xenidc_trace.h" + +static xenidc_lbr_type xenidc_vaddress_type; + +static void +xenidc_vaddress_copy_in_or_out(struct xenidc_lbr_concrete_class *class, +struct xenidc_lbr *lbr, void *buffer, xenidc_buffer_byte_count byte_count, +int out) +{ + trace(); + if (out) { + memcpy(buffer, ((char *)lbr->base) + lbr->byte_offset, + byte_count); + } else { + memcpy(((char *)lbr->base) + lbr->byte_offset, buffer, + byte_count); + } +} + +static void +xenidc_vaddress_zero(struct xenidc_lbr_concrete_class *class, +struct xenidc_lbr *lbr) +{ + trace(); + memset(((char *)lbr->base) + lbr->byte_offset, 0, lbr->byte_count); +} + +static int +xenidc_vaddress_calculate_rbr_resources( +struct xenidc_lbr_concrete_class *class, struct xenidc_lbr *lbr, +struct xenidc_address *address, struct xenidc_buffer_resource_list *list) +{ + unsigned long first_page, final_page; + trace(); + *list = xenidc_buffer_resource_list_null(); + first_page = (((unsigned long)(((char *)lbr->base) + lbr->byte_offset)) + / PAGE_SIZE); + final_page = (((unsigned long)(((char *)lbr->base) + lbr->byte_offset + + lbr->byte_count - 1)) / PAGE_SIZE); + list->pages = 1; + list->grant_references = final_page - first_page + 1; + return list->grant_references > XENIDC_GRANT_TABLE_REFERENCE_COUNT; +} + +struct xenidc_vaddress_rbr_context { + struct xenidc_lbr_concrete_class *class; + struct xenidc_buffer_resource_provider *provider; + struct timer_list timer; + struct xenidc_callback *callback; + int domain_id; + int count; + grant_ref_t reference[XENIDC_GRANT_TABLE_REFERENCE_COUNT]; +}; + +static struct xenidc_lbr_concrete_class ** +xenidc_vaddress_create_rbr(struct xenidc_lbr_concrete_class *class, +struct xenidc_lbr *lbr, struct xenidc_address *address, +struct xenidc_buffer_resource_provider *provider, struct xenidc_rbr *rbr, +int access_flags) +{ + int i = 0; + unsigned long page, final_page; + struct xenidc_vaddress_rbr_context *context; + trace(); + context = (struct xenidc_vaddress_rbr_context *) + xenidc_buffer_resource_provider_allocate_page(provider); + context->class = class; + context->provider = provider; + context->domain_id = xenidc_address_query_remote_domain_id(address); + memset(rbr, 0, sizeof(*rbr)); + rbr->type = XENIDC_RBR_TYPE_GRANT_TABLE; + page = (((unsigned long)(((char *)lbr->base) + lbr->byte_offset)) & + PAGE_MASK); + final_page = (((unsigned long)(((char *)lbr->base) + lbr->byte_offset + + lbr->byte_count - 1)) & PAGE_MASK); + for (;;) { + ((struct xenidc_grant_table_base *)&rbr->base)->reference[i] = + context->reference[i] = + xenidc_buffer_resource_provider_allocate_grant_reference( + provider); + gnttab_grant_foreign_access_ref(context->reference[i], + context->domain_id, virt_to_mfn(page), ((access_flags & + XENIDC_LBR_ACCESS_FLAGS_WRITE) == 0) ? 1 : 0); + i++; + if (page == final_page) + break; + page += PAGE_SIZE; + } + context->count = i; + rbr->byte_offset = (unsigned long)(((char *)lbr->base) + + lbr->byte_offset) & ~PAGE_MASK; + rbr->byte_count = lbr->byte_count; + return &context->class; +} + +static void +xenidc_vaddress_retry_revoke_rbr(struct xenidc_vaddress_rbr_context *context); + +static void +xenidc_vaddress_revoke_rbr(struct xenidc_lbr_concrete_class **context_in, +struct xenidc_callback *callback) +{ + struct xenidc_vaddress_rbr_context *context; + trace(); + context = container_of(context_in, struct xenidc_vaddress_rbr_context, + class); + context->callback = callback; + xenidc_vaddress_retry_revoke_rbr(context); +} + +static void +xenidc_vaddress_retry_revoke_rbr(struct xenidc_vaddress_rbr_context *context) +{ + int i = 0,j; + trace(); + while (i != context->count) { + if (gnttab_end_foreign_access_ref(context->reference[i], 0)) { + xenidc_buffer_resource_provider_free_grant_reference( + context->provider, context->reference[i]); + for (j = i + 1; j < context->count; j++) { + context->reference[j-1] = + context->reference[j]; + } + --context->count; + } else { + i++; + } + } + if (context->count == 0) { + struct xenidc_callback *callback = context->callback; + xenidc_buffer_resource_provider_free_page(context->provider, + context); + xenidc_callback_success(callback); + } else { + printk(KERN_WARNING + "xenidc_vaddress_revoke_rbr failed to end foreign access " + "granted to domain id %d. Will retry in 5 seconds.\n", + context->domain_id); + init_timer(&context->timer); + context->timer.data = (unsigned long)context; + context->timer.expires = jiffies + (5*HZ); + context->timer.function = (void (*)(unsigned long)) + xenidc_vaddress_retry_revoke_rbr; + add_timer(&context->timer); + } +} + +static void +xenidc_vaddress_copy(struct xenidc_lbr_copy_class *class, +struct xenidc_lbr *target, struct xenidc_lbr *source, +xenidc_buffer_byte_count byte_count) +{ + trace(); + memcpy(((char *)target->base) + target->byte_offset, + ((char *)source->base) + source->byte_offset, byte_count); +} + +static void xenidc_vaddress_init(void) +{ + static int initialised = 0; + static struct xenidc_lbr_concrete_class xenidc_vaddress_concrete_class; + static struct xenidc_lbr_copy_class xenidc_vaddress_copy_class; + static DEFINE_RWLOCK(xenidc_vaddress_lock); + unsigned long flags; + trace(); + read_lock_irqsave(&xenidc_vaddress_lock, flags); + if (initialised) { + read_unlock_irqrestore(&xenidc_vaddress_lock, flags); + return; + } + write_lock_irqsave(&xenidc_vaddress_lock, flags); + if (initialised) { + write_unlock_irqrestore(&xenidc_vaddress_lock, flags); + return; + } + xenidc_vaddress_type = xenidc_lbr_register_concrete_class( + &xenidc_vaddress_concrete_class, + xenidc_vaddress_copy_in_or_out, + xenidc_vaddress_zero, + xenidc_vaddress_calculate_rbr_resources, + xenidc_vaddress_create_rbr, + xenidc_vaddress_revoke_rbr); + + xenidc_lbr_register_copy_class(&xenidc_vaddress_copy_class, + xenidc_vaddress_type, xenidc_vaddress_type, + xenidc_vaddress_copy); + initialised = 1; + write_unlock_irqrestore(&xenidc_vaddress_lock, flags); +} + +struct xenidc_buffer_resource_list +xenidc_vaddress_calculate_buffer_resource_list( +xenidc_buffer_byte_count byte_count, xenidc_buffer_byte_count byte_alignment) +{ + struct xenidc_buffer_resource_list list; + xenidc_buffer_byte_count requested_page_count; + trace(); + xenidc_vaddress_init(); + list = xenidc_buffer_resource_list_null(); + if (byte_count > 0) { + list.pages = 1; + requested_page_count = ((((byte_alignment % PAGE_SIZE) + + byte_count - 1) / PAGE_SIZE) + 1); + list.grant_references = min(requested_page_count, + XENIDC_GRANT_TABLE_REFERENCE_COUNT); + } + return list; +} + +struct xenidc_lbr +xenidc_vaddress_create_lbr(void *address, xenidc_buffer_byte_count byte_count) +{ + struct xenidc_lbr lbr; + trace(); + xenidc_vaddress_init(); + lbr.type = xenidc_vaddress_type; + lbr.base = address; + lbr.byte_offset = 0; + lbr.byte_count = byte_count; + return lbr; +} + +EXPORT_SYMBOL(xenidc_vaddress_calculate_buffer_resource_list); +EXPORT_SYMBOL(xenidc_vaddress_create_lbr); diff -r ec6442c07549 -r 7c011e163562 linux-2.6-xen-sparse/include/asm-xen/xenidc_grant_table.h --- /dev/null Wed Nov 23 17:37:53 2005 +++ b/linux-2.6-xen-sparse/include/asm-xen/xenidc_grant_table.h Wed Nov 23 19:30:40 2005 @@ -0,0 +1,60 @@ +/*****************************************************************************/ +/* Support for remote buffer references of type grant-table. */ +/* */ +/* Copyright (c) 2005 Harry Butterworth IBM Corporation */ +/* */ +/* This program is free software; you can redistribute it and/or modify it */ +/* under the terms of the GNU General Public License as published by the */ +/* Free Software Foundation; either version 2 of the License, or (at your */ +/* option) any later version. */ +/* */ +/* This program is distributed in the hope that it will be useful, but */ +/* WITHOUT ANY WARRANTY; without even the implied warranty of */ +/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General */ +/* Public License for more details. */ +/* */ +/* You should have received a copy of the GNU General Public License along */ +/* with this program; if not, write to the Free Software Foundation, Inc., */ +/* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ +/* */ +/*****************************************************************************/ +/* */ +/* This type of remote buffer reference is used for example for granting */ +/* access to vaddress type local buffers of up-to 16 pages when the remote */ +/* domain is on the same physical node. At the time of writing this comment */ +/* this meets all the requirements of the only client of xenidc so this is */ +/* the only type of remote buffer reference. */ +/* Other types would be required for larger buffers (perhaps a type which */ +/* used a grant-reference to reference a table of grant-references in the */ +/* remote domain). Other types would also be required for domains on remote */ +/* nodes. */ + +#ifndef XENIDC_GRANT_TABLE_H +#define XENIDC_GRANT_TABLE_H + +#include +#include "xenidc_remote_buffer_reference.h" + +/* At the moment, the vaddress type lbr code just creates these directly. */ +/* If more lbr types start to create rbrs of this type we'd want to move the */ +/* common code into the .c file and provide an interface for creation here. */ +/* */ +/* The interface for mapping these rbrs is registered with the remote buffer */ +/* reference code. */ + +#define XENIDC_GRANT_TABLE_REFERENCE_COUNT \ +(XENIDC_RBR_BASE_BYTE_COUNT / sizeof(grant_ref_t)) + +struct xenidc_grant_table_base { + grant_ref_t reference[XENIDC_GRANT_TABLE_REFERENCE_COUNT]; +}; + +/* xenidc_grant_table_calculate_buffer_resource_list returns the worst-case */ +/* resource requirements for mapping an RBR of type grant_table into the */ +/* local address space given the size and alignment specified. */ + +extern struct xenidc_buffer_resource_list +xenidc_grant_table_calculate_buffer_resource_list( +xenidc_buffer_byte_count byte_count, xenidc_buffer_byte_count byte_alignment); + +#endif diff -r ec6442c07549 -r 7c011e163562 linux-2.6-xen-sparse/include/asm-xen/xenidc_vaddress.h --- /dev/null Wed Nov 23 17:37:53 2005 +++ b/linux-2.6-xen-sparse/include/asm-xen/xenidc_vaddress.h Wed Nov 23 19:30:40 2005 @@ -0,0 +1,43 @@ +/*****************************************************************************/ +/* Support for local buffer references of type vaddress which represent */ +/* buffers in the kernel virtual address space. */ +/* */ +/* Copyright (c) 2005 Harry Butterworth IBM Corporation */ +/* */ +/* This program is free software; you can redistribute it and/or modify it */ +/* under the terms of the GNU General Public License as published by the */ +/* Free Software Foundation; either version 2 of the License, or (at your */ +/* option) any later version. */ +/* */ +/* This program is distributed in the hope that it will be useful, but */ +/* WITHOUT ANY WARRANTY; without even the implied warranty of */ +/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General */ +/* Public License for more details. */ +/* */ +/* You should have received a copy of the GNU General Public License along */ +/* with this program; if not, write to the Free Software Foundation, Inc., */ +/* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ +/* */ +/*****************************************************************************/ + +#ifndef XENIDC_VADDRESS_H +#define XENIDC_VADDRESS_H + +#include "xenidc_local_buffer_reference.h" + +/* xenidc_vaddress_calculate_buffer_resource_list calculates the worst-case */ +/* resource requirements for creating an RBR from an LBR of type vaddress of */ +/* size and alignment as specified. */ + +extern struct xenidc_buffer_resource_list +xenidc_vaddress_calculate_buffer_resource_list( +xenidc_buffer_byte_count byte_count, xenidc_buffer_byte_count byte_alignment); + +/* xenidc_vaddress_create_lbr returns an LBR of type vaddress which */ +/* references the extent of the kernel virtual address space described by */ +/* the parameters. */ + +extern struct xenidc_lbr +xenidc_vaddress_create_lbr(void *address, xenidc_buffer_byte_count byte_count); + +#endif