|
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index] [Xen-changelog] [xen-unstable] [XEN] Add a new type of grant copy operation.
# HG changeset patch
# User kfraser@xxxxxxxxxxxxxxxxxxxxx
# Node ID 247fc1245b217d33d299abfe88d10fa3ddb6a026
# Parent 4ee64035c0a3def8034ac3ed89b954eb985246a4
[XEN] Add a new type of grant copy operation.
Based on an original patch from Rolf Neugebauer at Intel.
Signed-off-by: Steven Smith <ssmith@xxxxxxxxxxxxx>
Signed-off-by: Keir Fraser <keir@xxxxxxxxxxxxx>
---
xen/common/grant_table.c | 221 +++++++++++++++++++++++++++++++++++++++
xen/include/public/grant_table.h | 47 ++++++++
2 files changed, 267 insertions(+), 1 deletion(-)
diff -r 4ee64035c0a3 -r 247fc1245b21 xen/common/grant_table.c
--- a/xen/common/grant_table.c Thu Aug 10 11:36:27 2006 +0100
+++ b/xen/common/grant_table.c Thu Aug 10 11:54:15 2006 +0100
@@ -704,6 +704,218 @@ gnttab_transfer(
return 0;
}
+/* Undo __acquire_grant_for_copy. Again, this has no effect on page
+ type and reference counts. */
+static void
+__release_grant_for_copy(
+ struct domain *rd, unsigned long gref, int readonly)
+{
+ grant_entry_t *const sha = &rd->grant_table->shared[gref];
+ struct active_grant_entry *const act = &rd->grant_table->active[gref];
+ const unsigned long r_frame = act->frame;
+
+ if ( !readonly )
+ gnttab_log_dirty(rd, r_frame);
+
+ spin_lock(&rd->grant_table->lock);
+ if ( readonly )
+ act->pin -= GNTPIN_hstr_inc;
+ else
+ act->pin -= GNTPIN_hstw_inc;
+
+ if ( !(act->pin & GNTPIN_hstw_mask) && !readonly )
+ clear_bit(_GTF_writing, &sha->flags);
+
+ if ( !act->pin )
+ clear_bit(_GTF_reading, &sha->flags);
+ spin_unlock(&rd->grant_table->lock);
+}
+
+/* Grab a frame number from a grant entry and update the flags and pin
+ count as appropriate. Note that this does *not* update the page
+ type or reference counts. */
+static int
+__acquire_grant_for_copy(
+ struct domain *rd, unsigned long gref, int readonly,
+ unsigned long *frame)
+{
+ grant_entry_t *sha;
+ struct active_grant_entry *act;
+ s16 rc = GNTST_okay;
+ int retries = 0;
+ u16 sflags;
+ domid_t sdom;
+
+ if ( unlikely(gref >= NR_GRANT_ENTRIES) )
+ PIN_FAIL(error_out, GNTST_bad_gntref,
+ "Bad grant reference %ld\n", gref);
+
+ act = &rd->grant_table->active[gref];
+ sha = &rd->grant_table->shared[gref];
+
+ spin_lock(&rd->grant_table->lock);
+
+ if ( !act->pin ||
+ (!readonly && !(act->pin & GNTPIN_hstw_mask)) )
+ {
+ sflags = sha->flags;
+ sdom = sha->domid;
+
+ for ( ; ; )
+ {
+ u32 scombo;
+ u32 prev_scombo;
+ u32 new_scombo;
+
+ if ( unlikely((sflags & GTF_type_mask) != GTF_permit_access ||
+ sdom != current->domain->domain_id ) )
+ PIN_FAIL(unlock_out, GNTST_general_error,
+ "Bad flags (%x) or dom (%d). (NB. expected dom %d)\n",
+ sflags, sdom, current->domain->domain_id);
+ scombo = ((u32)sdom << 16) | (u32)sflags;
+ new_scombo = scombo | GTF_reading;
+ if ( !readonly )
+ {
+ new_scombo |= GTF_writing;
+ if ( unlikely(sflags & GTF_readonly) )
+ PIN_FAIL(unlock_out, GNTST_general_error,
+ "Attempt to write-pin a r/o grant entry.\n");
+ }
+ prev_scombo = cmpxchg((u32 *)&sha->flags, scombo, new_scombo);
+ if ( likely(prev_scombo == scombo) )
+ break;
+
+ if ( retries++ == 4 )
+ PIN_FAIL(unlock_out, GNTST_general_error,
+ "Shared grant entry is unstable.\n");
+ sflags = (u16)prev_scombo;
+ sdom = (u16)(prev_scombo >> 16);
+ }
+
+ if ( !act->pin )
+ {
+ act->domid = sdom;
+ act->frame = gmfn_to_mfn(rd, sha->frame);
+ }
+ }
+ else if ( (act->pin & 0x80808080U) != 0 )
+ PIN_FAIL(unlock_out, ENOSPC,
+ "Risk of counter overflow %08x\n", act->pin);
+
+ act->pin += readonly ? GNTPIN_hstr_inc : GNTPIN_hstw_inc;
+
+ *frame = act->frame;
+
+ unlock_out:
+ spin_unlock(&rd->grant_table->lock);
+ error_out:
+ return rc;
+}
+
+static void
+__gnttab_copy(
+ struct gnttab_copy *op)
+{
+ struct domain *sd = NULL, *dd = NULL;
+ unsigned long s_frame, d_frame;
+ void *sp, *dp;
+ s16 rc = GNTST_okay;
+ int have_d_grant = 0, have_s_grant = 0;
+
+ if ( ((op->source.offset + op->len) > PAGE_SIZE) ||
+ ((op->dest.offset + op->len) > PAGE_SIZE) )
+ PIN_FAIL(error_out, GNTST_bad_copy_arg, "copy beyond page area.\n");
+
+ if ( op->source.domid == DOMID_SELF )
+ {
+ sd = current->domain;
+ get_knownalive_domain(sd);
+ }
+ else if ( (sd = find_domain_by_id(op->source.domid)) == NULL )
+ {
+ PIN_FAIL(error_out, GNTST_bad_domain,
+ "couldn't find %d\n", op->source.domid);
+ }
+
+ if ( op->dest.domid == DOMID_SELF )
+ {
+ dd = current->domain;
+ get_knownalive_domain(dd);
+ }
+ else if ( (dd = find_domain_by_id(op->dest.domid)) == NULL )
+ {
+ PIN_FAIL(error_out, GNTST_bad_domain,
+ "couldn't find %d\n", op->dest.domid);
+ }
+
+ if ( op->flags & GNTCOPY_source_gref )
+ {
+ rc = __acquire_grant_for_copy(sd, op->source.u.ref, 1, &s_frame);
+ if ( rc != GNTST_okay )
+ goto error_out;
+ have_s_grant = 1;
+ }
+ else
+ {
+ s_frame = gmfn_to_mfn(sd, op->source.u.gmfn);
+ }
+ if ( !get_page(mfn_to_page(s_frame), sd) )
+ PIN_FAIL(error_out, GNTST_general_error,
+ "could not get source frame %lx.\n", s_frame);
+
+ if ( op->flags & GNTCOPY_dest_gref )
+ {
+ rc = __acquire_grant_for_copy(dd, op->dest.u.ref, 0, &d_frame);
+ if ( rc != GNTST_okay )
+ goto error_out;
+ have_d_grant = 1;
+ }
+ else
+ {
+ d_frame = gmfn_to_mfn(sd, op->dest.u.gmfn);
+ }
+ if ( !get_page_and_type(mfn_to_page(d_frame), dd, PGT_writable_page) )
+ PIN_FAIL(error_out, GNTST_general_error,
+ "could not get source frame %lx.\n", d_frame);
+
+ sp = map_domain_page(s_frame);
+ dp = map_domain_page(d_frame);
+
+ memcpy(dp + op->dest.offset, sp + op->source.offset, op->len);
+
+ unmap_domain_page(dp);
+ unmap_domain_page(sp);
+
+ error_out:
+ if ( have_s_grant )
+ __release_grant_for_copy(sd, op->source.u.ref, 1);
+ if ( have_d_grant )
+ __release_grant_for_copy(dd, op->dest.u.ref, 0);
+ if ( sd )
+ put_domain(sd);
+ if ( dd )
+ put_domain(dd);
+ op->status = rc;
+}
+
+static long
+gnttab_copy(
+ XEN_GUEST_HANDLE(gnttab_copy_t) uop, unsigned int count)
+{
+ int i;
+ struct gnttab_copy op;
+
+ for ( i = 0; i < count; i++ )
+ {
+ if ( unlikely(__copy_from_guest_offset(&op, uop, i, 1)) )
+ return -EFAULT;
+ __gnttab_copy(&op);
+ if ( unlikely(__copy_to_guest_offset(uop, i, &op, 1)) )
+ return -EFAULT;
+ }
+ return 0;
+}
+
long
do_grant_table_op(
unsigned int cmd, XEN_GUEST_HANDLE(void) uop, unsigned int count)
@@ -754,6 +966,15 @@ do_grant_table_op(
rc = gnttab_transfer(transfer, count);
break;
}
+ case GNTTABOP_copy:
+ {
+ XEN_GUEST_HANDLE(gnttab_copy_t) copy =
+ guest_handle_cast(uop, gnttab_copy_t);
+ if ( unlikely(!guest_handle_okay(copy, count)) )
+ goto out;
+ rc = gnttab_copy(copy, count);
+ break;
+ }
default:
rc = -ENOSYS;
break;
diff -r 4ee64035c0a3 -r 247fc1245b21 xen/include/public/grant_table.h
--- a/xen/include/public/grant_table.h Thu Aug 10 11:36:27 2006 +0100
+++ b/xen/include/public/grant_table.h Thu Aug 10 11:54:15 2006 +0100
@@ -248,6 +248,49 @@ struct gnttab_transfer {
};
typedef struct gnttab_transfer gnttab_transfer_t;
DEFINE_XEN_GUEST_HANDLE(gnttab_transfer_t);
+
+
+/*
+ * GNTTABOP_copy: Hypervisor based copy
+ * source and destinations can be eithers MFNs or, for foreign domains,
+ * grant references. the foreign domain has to grant read/write access
+ * in its grant table.
+ *
+ * The flags specify what type source and destinations are (either MFN
+ * or grant reference).
+ *
+ * Note that this can also be used to copy data between two domains
+ * via a third party if the source and destination domains had previously
+ * grant appropriate access to their pages to the third party.
+ *
+ * source_offset specifies an offset in the source frame, dest_offset
+ * the offset in the target frame and len specifies the number of
+ * bytes to be copied.
+ */
+
+#define _GNTCOPY_source_gref (0)
+#define GNTCOPY_source_gref (1<<_GNTCOPY_source_gref)
+#define _GNTCOPY_dest_gref (1)
+#define GNTCOPY_dest_gref (1<<_GNTCOPY_dest_gref)
+
+#define GNTTABOP_copy 5
+typedef struct gnttab_copy {
+ /* IN parameters. */
+ struct {
+ union {
+ grant_ref_t ref;
+ xen_pfn_t gmfn;
+ } u;
+ domid_t domid;
+ uint16_t offset;
+ } source, dest;
+ uint16_t len;
+ uint16_t flags; /* GNTCOPY_* */
+ /* OUT parameters. */
+ int16_t status;
+} gnttab_copy_t;
+DEFINE_XEN_GUEST_HANDLE(gnttab_copy_t);
+
/*
* Bitfield values for update_pin_status.flags.
@@ -290,6 +333,7 @@ DEFINE_XEN_GUEST_HANDLE(gnttab_transfer_
#define GNTST_no_device_space (-7) /* Out of space in I/O MMU. */
#define GNTST_permission_denied (-8) /* Not enough privilege for operation. */
#define GNTST_bad_page (-9) /* Specified page was invalid for op. */
+#define GNTST_bad_copy_arg (-10) /* copy arguments cross page boundary */
#define GNTTABOP_error_msgs { \
"okay", \
@@ -301,7 +345,8 @@ DEFINE_XEN_GUEST_HANDLE(gnttab_transfer_
"invalid device address", \
"no spare translation slot in the I/O MMU", \
"permission denied", \
- "bad page" \
+ "bad page", \
+ "copy arguments cross page boundary" \
}
#endif /* __XEN_PUBLIC_GRANT_TABLE_H__ */
_______________________________________________
Xen-changelog mailing list
Xen-changelog@xxxxxxxxxxxxxxxxxxx
http://lists.xensource.com/xen-changelog
|
 |
Lists.xenproject.org is hosted with RackSpace, monitoring our |