[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[Xen-devel] Re: [PATCH 1/3] xen/granttable: Introducing grant table V2 stucture



On Wed, 2011-11-16 at 13:48 +0000, annie.li@xxxxxxxxxx wrote:
> From: Annie Li <annie.li@xxxxxxxxxx>
> 
> This patch introduces new structures of grant table V2, grant table V2 is an
> extension from V1. Grant table is shared between guest and Xen, and Xen is
> responsible to do corresponding work for grant operations, such as: figure
> out guest's grant table version, perform different actions based on
> different grant table version, etc. Although full-page structure of V2
> is different from V1, it play the same role as V1.
> 
> Signed-off-by: Annie Li <annie.li@xxxxxxxxxx>
> ---
>  arch/x86/xen/grant-table.c          |    7 +-
>  drivers/xen/grant-table.c           |  181 
> +++++++++++++++++++++++++++--------
>  include/xen/grant_table.h           |    4 +-
>  include/xen/interface/grant_table.h |  167 +++++++++++++++++++++++++++++++-
>  include/xen/interface/xen.h         |    2 +
>  5 files changed, 311 insertions(+), 50 deletions(-)
> 
> diff --git a/arch/x86/xen/grant-table.c b/arch/x86/xen/grant-table.c
> index 6bbfd7a..c6ab2e7 100644
> --- a/arch/x86/xen/grant-table.c
> +++ b/arch/x86/xen/grant-table.c
> @@ -64,10 +64,10 @@ static int unmap_pte_fn(pte_t *pte, struct page *pmd_page,
> 
>  int arch_gnttab_map_shared(unsigned long *frames, unsigned long nr_gframes,
>                            unsigned long max_nr_gframes,
> -                          struct grant_entry **__shared)
> +                          void **__shared)
>  {
>         int rc;
> -       struct grant_entry *shared = *__shared;
> +       void *shared = *__shared;
> 
>         if (shared == NULL) {
>                 struct vm_struct *area =
> @@ -83,8 +83,7 @@ int arch_gnttab_map_shared(unsigned long *frames, unsigned 
> long nr_gframes,
>         return rc;
>  }
> 
> -void arch_gnttab_unmap_shared(struct grant_entry *shared,
> -                             unsigned long nr_gframes)
> +void arch_gnttab_unmap_shared(void *shared, unsigned long nr_gframes)
>  {
>         apply_to_page_range(&init_mm, (unsigned long)shared,
>                             PAGE_SIZE * nr_gframes, unmap_pte_fn, NULL);
> diff --git a/drivers/xen/grant-table.c b/drivers/xen/grant-table.c
> index bf1c094..1bd9d5f 100644
> --- a/drivers/xen/grant-table.c
> +++ b/drivers/xen/grant-table.c
> @@ -53,7 +53,7 @@
>  /* External tools reserve first few grant table entries. */
>  #define NR_RESERVED_ENTRIES 8
>  #define GNTTAB_LIST_END 0xffffffff
> -#define GREFS_PER_GRANT_FRAME (PAGE_SIZE / sizeof(struct grant_entry))
> +#define GREFS_PER_GRANT_FRAME (PAGE_SIZE / sizeof(struct grant_entry_v1))
> 
>  static grant_ref_t **gnttab_list;
>  static unsigned int nr_grant_frames;
> @@ -64,7 +64,61 @@ static DEFINE_SPINLOCK(gnttab_list_lock);
>  unsigned long xen_hvm_resume_frames;
>  EXPORT_SYMBOL_GPL(xen_hvm_resume_frames);
> 
> -static struct grant_entry *shared;
> +static union {
> +       struct grant_entry_v1 *v1;
> +       void *addr;
> +} gnttab_shared;
> +
> +/*This is a structure of function pointers for grant table*/
> +static struct {
> +       /*
> +        * Mapping a list of frames for storing grant entries. First input
> +        * parameter is used to storing grant table address when grant table
> +        * being setup, second parameter is the number of frames to map grant
> +        * table. Returning GNTST_okay means success and negative value means
> +        * failure.
> +        */
> +       int (*map_frames)(unsigned long *, unsigned int);
> +       /*
> +        * Release a list of frames which are mapped in map_frames for grant
> +        * entry status.
> +        */
> +       void (*unmap_frames)(void);
> +       /*
> +        * Introducing a valid entry into the grant table, granting the frame
> +        * of this grant entry to domain for accessing, or transfering, or
> +        * transitively accessing. First input parameter is reference of this
> +        * introduced grant entry, second one is domid of granted domain, 
> third
> +        * one is the frame to be granted, and the last one is status of the
> +        * grant entry to be updated.
> +        */
> +       void (*update_entry)(grant_ref_t, domid_t, unsigned long, unsigned);
> +       /*
> +        * Stop granting a grant entry to domain for accessing. First input
> +        * parameter is reference of a grant entry whose grant access will be
> +        * stopped, second one is not in use now. If the grant entry is
> +        * currently mapped for reading or writing, just return failure(==0)
> +        * directly and don't tear down the grant access. Otherwise, stop 
> grant
> +        * access for this entry and return success(==1).
> +        */
> +       int (*end_foreign_access_ref)(grant_ref_t, int);
> +       /*
> +        * Stop granting a grant entry to domain for transfer. If tranfer has
> +        * not started, just reclaim the grant entry and return failure(==0).
> +        * Otherwise, wait for the transfer to complete and then return the
> +        * frame.
> +        */
> +       unsigned long (*end_foreign_transfer_ref)(grant_ref_t);
> +       /*
> +        * Query the status of a grant entry. Input parameter is reference of
> +        * queried grant entry, return value is the status of queried entry.
> +        * Detailed status(writing/reading) can be gotten from the return 
> value
> +        * by bit operations.
> +        */
> +       int (*query_foreign_access)(grant_ref_t);
> +} gnttab_interface;
> +
> +static int grant_table_version;
> 
>  static struct gnttab_free_callback *gnttab_free_callback_list;
> 
> @@ -142,23 +196,23 @@ static void put_free_entry(grant_ref_t ref)
>         spin_unlock_irqrestore(&gnttab_list_lock, flags);
>  }
> 
> -static void update_grant_entry(grant_ref_t ref, domid_t domid,
> -                              unsigned long frame, unsigned flags)
> +/*
> + * Introducing a valid entry into the grant table:
> + *  1. Write ent->domid.
> + *  2. Write ent->frame:
> + *      GTF_permit_access:   Frame to which access is permitted.
> + *      GTF_accept_transfer: Pseudo-phys frame slot being filled by new
> + *                           frame, or zero if none.
> + *  3. Write memory barrier (WMB).
> + *  4. Write ent->flags, inc. valid type.
> + */
> +static void update_grant_entry_v1(grant_ref_t ref, domid_t domid,
> +                                 unsigned long frame, unsigned flags)
>  {
> -       /*
> -        * Introducing a valid entry into the grant table:
> -        *  1. Write ent->domid.
> -        *  2. Write ent->frame:
> -        *      GTF_permit_access:   Frame to which access is permitted.
> -        *      GTF_accept_transfer: Pseudo-phys frame slot being filled by 
> new
> -        *                           frame, or zero if none.
> -        *  3. Write memory barrier (WMB).
> -        *  4. Write ent->flags, inc. valid type.
> -        */
> -       shared[ref].frame = frame;
> -       shared[ref].domid = domid;
> +       gnttab_shared.v1[ref].domid = domid;
> +       gnttab_shared.v1[ref].frame = frame;
>         wmb();
> -       shared[ref].flags = flags;
> +       gnttab_shared.v1[ref].flags = flags;
>  }
> 
>  /*
> @@ -167,7 +221,7 @@ static void update_grant_entry(grant_ref_t ref, domid_t 
> domid,
>  void gnttab_grant_foreign_access_ref(grant_ref_t ref, domid_t domid,
>                                      unsigned long frame, int readonly)
>  {
> -       update_grant_entry(ref, domid, frame,
> +       gnttab_interface.update_entry(ref, domid, frame,
>                            GTF_permit_access | (readonly ? GTF_readonly : 0));
>  }
>  EXPORT_SYMBOL_GPL(gnttab_grant_foreign_access_ref);
> @@ -187,31 +241,40 @@ int gnttab_grant_foreign_access(domid_t domid, unsigned 
> long frame,
>  }
>  EXPORT_SYMBOL_GPL(gnttab_grant_foreign_access);
> 
> -int gnttab_query_foreign_access(grant_ref_t ref)
> +static int gnttab_query_foreign_access_v1(grant_ref_t ref)
>  {
> -       u16 nflags;
> -
> -       nflags = shared[ref].flags;
> +       return gnttab_shared.v1[ref].flags & (GTF_reading|GTF_writing);
> +}
> -       return nflags & (GTF_reading|GTF_writing);
> +int gnttab_query_foreign_access(grant_ref_t ref)
> +{
> +       return gnttab_interface.query_foreign_access(ref);
>  }
>  EXPORT_SYMBOL_GPL(gnttab_query_foreign_access);
> 
> -int gnttab_end_foreign_access_ref(grant_ref_t ref, int readonly)
> +static int gnttab_end_foreign_access_ref_v1(grant_ref_t ref, int readonly)
>  {
>         u16 flags, nflags;
> +       u16 *pflags;
> 
> -       nflags = shared[ref].flags;
> +       pflags = &gnttab_shared.v1[ref].flags;
> +       nflags = *pflags;
>         do {
>                 flags = nflags;
>                 if (flags & (GTF_reading|GTF_writing)) {
>                         printk(KERN_ALERT "WARNING: g.e. still in use!\n");
>                         return 0;
>                 }
> -       } while ((nflags = sync_cmpxchg(&shared[ref].flags, flags, 0)) != 
> flags);
> +       } while ((nflags = sync_cmpxchg(&gnttab_shared.v1[ref].flags, flags, 
> 0))
> +                       != flags);

I think this is one of those cases where strictly adhering to an
80-column rule hurts the readability of the code.

If you had left the static global as "shared" rather than
"gnttab_shared" you wouldn't have this issue. If you want a more
descriptive name why not just call it "gnttab"?

> 
>         return 1;
>  }
> +
> +int gnttab_end_foreign_access_ref(grant_ref_t ref, int readonly)
> +{
> +       return gnttab_interface.end_foreign_access_ref(ref, readonly);
> +}
>  EXPORT_SYMBOL_GPL(gnttab_end_foreign_access_ref);
> 
>  void gnttab_end_foreign_access(grant_ref_t ref, int readonly,
> @@ -246,37 +309,45 @@ EXPORT_SYMBOL_GPL(gnttab_grant_foreign_transfer);
>  void gnttab_grant_foreign_transfer_ref(grant_ref_t ref, domid_t domid,
>                                        unsigned long pfn)
>  {
> -       update_grant_entry(ref, domid, pfn, GTF_accept_transfer);
> +       gnttab_interface.update_entry(ref, domid, pfn, GTF_accept_transfer);
>  }
>  EXPORT_SYMBOL_GPL(gnttab_grant_foreign_transfer_ref);
> 
> -unsigned long gnttab_end_foreign_transfer_ref(grant_ref_t ref)
> +static unsigned long gnttab_end_foreign_transfer_ref_v1(grant_ref_t ref)
>  {
>         unsigned long frame;
>         u16           flags;
> +       u16          *pflags;
> +
> +       pflags = &gnttab_shared.v1[ref].flags;

It would be nice if these refactoring bits could be separated out from
the more mechanical renaming and abstracting to fn pointer aspects of
the patch.
> 
>         /*
>          * If a transfer is not even yet started, try to reclaim the grant
>          * reference and return failure (== 0).
>          */
> -       while (!((flags = shared[ref].flags) & GTF_transfer_committed)) {
> -               if (sync_cmpxchg(&shared[ref].flags, flags, 0) == flags)
> +       while (!((flags = *pflags) & GTF_transfer_committed)) {
> +               if (sync_cmpxchg(pflags, flags, 0) == flags)
>                         return 0;
>                 cpu_relax();
>         }
> 
>         /* If a transfer is in progress then wait until it is completed. */
>         while (!(flags & GTF_transfer_completed)) {
> -               flags = shared[ref].flags;
> +               flags = *pflags;
>                 cpu_relax();
>         }
> 
>         rmb();  /* Read the frame number /after/ reading completion status. */
> -       frame = shared[ref].frame;
> +       frame = gnttab_shared.v1[ref].frame;
>         BUG_ON(frame == 0);
> 
>         return frame;
>  }
> +
> +unsigned long gnttab_end_foreign_transfer_ref(grant_ref_t ref)
> +{
> +       return gnttab_interface.end_foreign_transfer_ref(ref);
> +}
>  EXPORT_SYMBOL_GPL(gnttab_end_foreign_transfer_ref);
> 
>  unsigned long gnttab_end_foreign_transfer(grant_ref_t ref)
> @@ -520,6 +591,23 @@ int gnttab_unmap_refs(struct gnttab_unmap_grant_ref 
> *unmap_ops,
>  }
>  EXPORT_SYMBOL_GPL(gnttab_unmap_refs);
> 
> +static int gnttab_map_frames_v1(unsigned long *frames, unsigned int 
> nr_gframes)
> +{
> +       int rc;
> +
> +       rc = arch_gnttab_map_shared(frames, nr_gframes,
> +                                   gnttab_max_grant_frames(),
> +                                   &gnttab_shared.addr);
> +       BUG_ON(rc);
> +
> +       return 0;
> +}
> +
> +static void gnttab_unmap_frames_v1(void)
> +{
> +       arch_gnttab_unmap_shared(gnttab_shared.addr, nr_grant_frames);
> +}
> +
>  static int gnttab_map(unsigned int start_idx, unsigned int end_idx)
>  {
>         struct gnttab_setup_table setup;
> @@ -567,19 +655,33 @@ static int gnttab_map(unsigned int start_idx, unsigned 
> int end_idx)
> 
>         BUG_ON(rc || setup.status);
> 
> -       rc = arch_gnttab_map_shared(frames, nr_gframes, 
> gnttab_max_grant_frames(),
> -                                   &shared);
> -       BUG_ON(rc);
> +       rc = gnttab_interface.map_frames(frames, nr_gframes);

Nothing checks rc here now?

In fact the gnttab_map_frames_v1 function has its own BUG_ON(rc) and
always returns 0 if it returns at all so perhaps that hook should be
returning void?

> 
>         kfree(frames);
> 
>         return 0;
>  }
> 
> +static void gnttab_request_version(void)
> +{
> +       grant_table_version = 1;
> +       gnttab_interface.map_frames = gnttab_map_frames_v1;
> +       gnttab_interface.unmap_frames = gnttab_unmap_frames_v1;
> +       gnttab_interface.update_entry = update_grant_entry_v1;
> +       gnttab_interface.end_foreign_access_ref =
> +                                       gnttab_end_foreign_access_ref_v1;
> +       gnttab_interface.end_foreign_transfer_ref =
> +                                       gnttab_end_foreign_transfer_ref_v1;
> +       gnttab_interface.query_foreign_access = 
> gnttab_query_foreign_access_v1;

The more normal way to do this would be to make gnttab_interface a
pointer, define gnttab_v1_ops and do:
        gnttab_interface = &gnttab_v1_ops;
or if the pointer overhead is significant remove that and just do a
struct assignment:
        gnttab_interface = gnttab_v1_ops;

> +       printk(KERN_INFO "Grant tables using version %d layout.\n",
> +               grant_table_version);
> +}
> +
>  int gnttab_resume(void)
>  {
>         unsigned int max_nr_gframes;
> 
> +       gnttab_request_version();
>         max_nr_gframes = gnttab_max_grant_frames();
>         if (max_nr_gframes < nr_grant_frames)
>                 return -ENOSYS;
> @@ -587,9 +689,10 @@ int gnttab_resume(void)
>         if (xen_pv_domain())
>                 return gnttab_map(0, nr_grant_frames - 1);
> 
> -       if (!shared) {
> -               shared = ioremap(xen_hvm_resume_frames, PAGE_SIZE * 
> max_nr_gframes);
> -               if (shared == NULL) {
> +       if (gnttab_shared.addr == NULL) {
> +               gnttab_shared.addr = ioremap(xen_hvm_resume_frames,
> +                                               PAGE_SIZE * max_nr_gframes);
> +               if (gnttab_shared.addr == NULL) {
>                         printk(KERN_WARNING
>                                         "Failed to ioremap gnttab share 
> frames!");
>                         return -ENOMEM;
> @@ -603,7 +706,7 @@ int gnttab_resume(void)
> 
>  int gnttab_suspend(void)
>  {
> -       arch_gnttab_unmap_shared(shared, nr_grant_frames);
> +       gnttab_interface.unmap_frames();
>         return 0;
>  }
> 
> diff --git a/include/xen/grant_table.h b/include/xen/grant_table.h
> index 11e2dfc..c7a40f8 100644
> --- a/include/xen/grant_table.h
> +++ b/include/xen/grant_table.h
> @@ -145,8 +145,8 @@ gnttab_set_unmap_op(struct gnttab_unmap_grant_ref *unmap, 
> phys_addr_t addr,
> 
>  int arch_gnttab_map_shared(unsigned long *frames, unsigned long nr_gframes,
>                            unsigned long max_nr_gframes,
> -                          struct grant_entry **__shared);
> -void arch_gnttab_unmap_shared(struct grant_entry *shared,
> +                          void **__shared);
> +void arch_gnttab_unmap_shared(void *shared,
>                               unsigned long nr_gframes);
> 
>  extern unsigned long xen_hvm_resume_frames;
> diff --git a/include/xen/interface/grant_table.h 
> b/include/xen/interface/grant_table.h
> index 39e5717..a17d844 100644
> --- a/include/xen/interface/grant_table.h
> +++ b/include/xen/interface/grant_table.h
> @@ -85,12 +85,22 @@
>   */
> 
>  /*
> + * Reference to a grant entry in a specified domain's grant table.
> + */
> +typedef uint32_t grant_ref_t;
> +
> +/*
>   * A grant table comprises a packed array of grant entries in one or more
>   * page frames shared between Xen and a guest.
>   * [XEN]: This field is written by Xen and read by the sharing guest.
>   * [GST]: This field is written by the guest and read by Xen.
>   */
> -struct grant_entry {
> +
> +/*
> + * Version 1 of the grant table entry structure is maintained purely
> + * for backwards compatibility.  New guests should use version 2.
> + */
> +struct grant_entry_v1 {
>      /* GTF_xxx: various type and flag information.  [XEN,GST] */
>      uint16_t flags;
>      /* The domain being granted foreign privileges. [GST] */
> @@ -108,10 +118,13 @@ struct grant_entry {
>   *  GTF_permit_access: Allow @domid to map/access @frame.
>   *  GTF_accept_transfer: Allow @domid to transfer ownership of one page frame
>   *                       to this guest. Xen writes the page number to @frame.
> + *  GTF_transitive: Allow @domid to transitively access a subrange of
> + *                  @trans_grant in @trans_domid.  No mappings are allowed.
>   */
>  #define GTF_invalid         (0U<<0)
>  #define GTF_permit_access   (1U<<0)
>  #define GTF_accept_transfer (2U<<0)
> +#define GTF_transitive      (3U<<0)
>  #define GTF_type_mask       (3U<<0)
> 
>  /*
> @@ -119,6 +132,9 @@ struct grant_entry {
>   *  GTF_readonly: Restrict @domid to read-only mappings and accesses. [GST]
>   *  GTF_reading: Grant entry is currently mapped for reading by @domid. [XEN]
>   *  GTF_writing: Grant entry is currently mapped for writing by @domid. [XEN]
> + *  GTF_sub_page: Grant access to only a subrange of the page.  @domid
> + *                will only be allowed to copy from the grant, and not
> + *                map it. [GST]
>   */
>  #define _GTF_readonly       (2)
>  #define GTF_readonly        (1U<<_GTF_readonly)
> @@ -126,6 +142,8 @@ struct grant_entry {
>  #define GTF_reading         (1U<<_GTF_reading)
>  #define _GTF_writing        (4)
>  #define GTF_writing         (1U<<_GTF_writing)
> +#define _GTF_sub_page       (8)
> +#define GTF_sub_page        (1U<<_GTF_sub_page)
> 
>  /*
>   * Subflags for GTF_accept_transfer:
> @@ -142,15 +160,81 @@ struct grant_entry {
>  #define _GTF_transfer_completed (3)
>  #define GTF_transfer_completed  (1U<<_GTF_transfer_completed)
> 
> +/*
> + * Version 2 grant table entries.  These fulfil the same role as
> + * version 1 entries, but can represent more complicated operations.
> + * Any given domain will have either a version 1 or a version 2 table,
> + * and every entry in the table will be the same version.
> + *
> + * The interface by which domains use grant references does not depend
> + * on the grant table version in use by the other domain.
> + */
> 
> -/***********************************
> - * GRANT TABLE QUERIES AND USES
> +/*
> + * Version 1 and version 2 grant entries share a common prefix.  The
> + * fields of the prefix are documented as part of struct
> + * grant_entry_v1.
>   */
> +struct grant_entry_header {
> +    uint16_t flags;
> +    domid_t  domid;
> +};
> 
>  /*
> - * Reference to a grant entry in a specified domain's grant table.
> + * Version 2 of the grant entry structure, here is an union because three
> + * different types are suppotted: full_page, sub_page and transitive.
> + */
> +union grant_entry_v2 {
> +    struct grant_entry_header hdr;
> +
> +    /*
> +     * This member is used for V1-style full page grants, where either:
> +     *
> +     * -- hdr.type is GTF_accept_transfer, or
> +     * -- hdr.type is GTF_permit_access and GTF_sub_page is not set.
> +     *
> +     * In that case, the frame field has the same semantics as the
> +     * field of the same name in the V1 entry structure.
> +     */
> +    struct {
> +       struct grant_entry_header hdr;
> +       uint32_t pad0;
> +       uint64_t frame;
> +    } full_page;
> +
> +    /*
> +     * If the grant type is GTF_grant_access and GTF_sub_page is set,
> +     * @domid is allowed to access bytes [@page_off,@page_off+@length)
> +     * in frame @frame.
> +     */
> +    struct {
> +       struct grant_entry_header hdr;
> +       uint16_t page_off;
> +       uint16_t length;
> +       uint64_t frame;
> +    } sub_page;
> +
> +    /*
> +     * If the grant is GTF_transitive, @domid is allowed to use the
> +     * grant @gref in domain @trans_domid, as if it was the local
> +     * domain.  Obviously, the transitive access must be compatible
> +     * with the original grant.
> +     */
> +    struct {
> +       struct grant_entry_header hdr;
> +       domid_t trans_domid;
> +       uint16_t pad0;
> +       grant_ref_t gref;
> +    } transitive;
> +
> +    uint32_t __spacer[4]; /* Pad to a power of two */
> +};
> +
> +typedef uint16_t grant_status_t;
> +
> +/***********************************
> + * GRANT TABLE QUERIES AND USES
>   */
> -typedef uint32_t grant_ref_t;
> 
>  /*
>   * Handle to track a mapping created via a grant reference.
> @@ -322,6 +406,79 @@ struct gnttab_query_size {
>  DEFINE_GUEST_HANDLE_STRUCT(gnttab_query_size);
> 
>  /*
> + * GNTTABOP_unmap_and_replace: Destroy one or more grant-reference mappings
> + * tracked by <handle> but atomically replace the page table entry with one
> + * pointing to the machine address under <new_addr>.  <new_addr> will be
> + * redirected to the null entry.
> + * NOTES:
> + *  1. The call may fail in an undefined manner if either mapping is not
> + *     tracked by <handle>.
> + *  2. After executing a batch of unmaps, it is guaranteed that no stale
> + *     mappings will remain in the device or host TLBs.
> + */
> +#define GNTTABOP_unmap_and_replace    7
> +struct gnttab_unmap_and_replace {
> +    /* IN parameters. */
> +    uint64_t host_addr;
> +    uint64_t new_addr;
> +    grant_handle_t handle;
> +    /* OUT parameters. */
> +    int16_t  status;              /* GNTST_* */
> +};
> +DEFINE_GUEST_HANDLE_STRUCT(gnttab_unmap_and_replace);
> +
> +/*
> + * GNTTABOP_set_version: Request a particular version of the grant
> + * table shared table structure.  This operation can only be performed
> + * once in any given domain.  It must be performed before any grants
> + * are activated; otherwise, the domain will be stuck with version 1.
> + * The only defined versions are 1 and 2.
> + */
> +#define GNTTABOP_set_version          8
> +struct gnttab_set_version {
> +    /* IN parameters */
> +    uint32_t version;
> +};
> +DEFINE_GUEST_HANDLE_STRUCT(gnttab_set_version);
> +
> +/*
> + * GNTTABOP_get_status_frames: Get the list of frames used to store grant
> + * status for <dom>. In grant format version 2, the status is separated
> + * from the other shared grant fields to allow more efficient synchronization
> + * using barriers instead of atomic cmpexch operations.
> + * <nr_frames> specify the size of vector <frame_list>.
> + * The frame addresses are returned in the <frame_list>.
> + * Only <nr_frames> addresses are returned, even if the table is larger.
> + * NOTES:
> + *  1. <dom> may be specified as DOMID_SELF.
> + *  2. Only a sufficiently-privileged domain may specify <dom> != DOMID_SELF.
> + */
> +#define GNTTABOP_get_status_frames     9
> +struct gnttab_get_status_frames {
> +    /* IN parameters. */
> +    uint32_t nr_frames;
> +    domid_t  dom;
> +    /* OUT parameters. */
> +    int16_t  status;              /* GNTST_* */
> +    GUEST_HANDLE(uint64_t) frame_list;
> +};
> +DEFINE_GUEST_HANDLE_STRUCT(gnttab_get_status_frames);
> +
> +/*
> + * GNTTABOP_get_version: Get the grant table version which is in
> + * effect for domain <dom>.
> + */
> +#define GNTTABOP_get_version          10
> +struct gnttab_get_version {
> +    /* IN parameters */
> +    domid_t dom;
> +    uint16_t pad;
> +    /* OUT parameters */
> +    uint32_t version;
> +};
> +DEFINE_GUEST_HANDLE_STRUCT(gnttab_get_version);
> +
> +/*
>   * Bitfield values for update_pin_status.flags.
>   */
>   /* Map the grant entry for access by I/O devices. */
> diff --git a/include/xen/interface/xen.h b/include/xen/interface/xen.h
> index 6a6e914..710afe0 100644
> --- a/include/xen/interface/xen.h
> +++ b/include/xen/interface/xen.h
> @@ -523,6 +523,8 @@ struct tmem_op {
>         } u;
>  };
> 
> +DEFINE_GUEST_HANDLE(uint64_t);

The kernel uses uN style types rather than the uintN_t style ones,
although include/xen/interface/grant_table.h seems not to adhere to that
at the moment. It might be worth cleaning that up as you go passed.

> +
>  #else /* __ASSEMBLY__ */
> 
>  /* In assembly code we cannot use C numeric constant suffixes. */
> --
> 1.7.6.4
> 



_______________________________________________
Xen-devel mailing list
Xen-devel@xxxxxxxxxxxxxxxxxxx
http://lists.xensource.com/xen-devel


 


Rackspace

Lists.xenproject.org is hosted with RackSpace, monitoring our
servers 24x7x365 and backed by RackSpace's Fanatical Support®.