| Message ID | 1466584733-19459-2-git-send-email-paulinaszubarczyk@gmail.com (mailing list archive) |
|---|---|
| State | New, archived |
| Headers | show |
On 22/06/16 09:38, Paulina Szubarczyk wrote: > In a linux part an ioctl(gntdev, IOCTL_GNTDEV_GRANT_COPY, ..) > system call is invoked. In mini-os the operation is yet not > implemented. For other OSs there is a dummy implementation. [...] > --- a/tools/libs/gnttab/linux.c > +++ b/tools/libs/gnttab/linux.c > @@ -235,6 +235,51 @@ int osdep_gnttab_unmap(xengnttab_handle *xgt, > return 0; > } > > +int osdep_gnttab_grant_copy(xengnttab_handle *xgt, > + uint32_t count, > + xengnttab_grant_copy_segment_t *segs) > +{ > + int i, rc; > + int fd = xgt->fd; > + struct ioctl_gntdev_grant_copy copy; > + > + copy.segments = calloc(count, sizeof(struct ioctl_gntdev_grant_copy_segment)); > + copy.count = count; > + for (i = 0; i < count; i++) > + { > + copy.segments[i].flags = segs[i].flags; > + copy.segments[i].len = segs[i].len; > + if (segs[i].flags == GNTCOPY_dest_gref) > + { > + copy.segments[i].dest.foreign.ref = segs[i].dest.foreign.ref; > + copy.segments[i].dest.foreign.domid = segs[i].dest.foreign.domid; > + copy.segments[i].dest.foreign.offset = segs[i].dest.foreign.offset; > + copy.segments[i].source.virt = segs[i].source.virt; > + } > + else > + { > + copy.segments[i].source.foreign.ref = segs[i].source.foreign.ref; > + copy.segments[i].source.foreign.domid = segs[i].source.foreign.domid; > + copy.segments[i].source.foreign.offset = segs[i].source.foreign.offset; > + copy.segments[i].dest.virt = segs[i].dest.virt; > + } > + } > + > + rc = ioctl(fd, IOCTL_GNTDEV_GRANT_COPY, ©); > + if (rc) > + { > + GTERROR(xgt->logger, "ioctl GRANT COPY failed %d ", errno); > + } > + else > + { > + for (i = 0; i < count; i++) > + segs[i].status = copy.segments[i].status; > + } > + > + free(copy.segments); > + return rc; > +} I know Wei asked for this but you've replaced what should be a single pointer assignment with a memory allocation and two loops over all the segments. This is a hot path and the two structures (the libxengnttab one and the Linux kernel one) are both part of their respective ABIs and won't change so Wei's concern that they might change in the future is unfounded. This change makes xengnttab_grant_copy() useless for our (XenServer's) use case. David
On Wed, 22 Jun 2016 10:37:24 +0100 David Vrabel <david.vrabel@citrix.com> wrote: > On 22/06/16 09:38, Paulina Szubarczyk wrote: > > In a linux part an ioctl(gntdev, IOCTL_GNTDEV_GRANT_COPY, ..) > > system call is invoked. In mini-os the operation is yet not > > implemented. For other OSs there is a dummy implementation. > [...] > > --- a/tools/libs/gnttab/linux.c > > +++ b/tools/libs/gnttab/linux.c > > @@ -235,6 +235,51 @@ int osdep_gnttab_unmap(xengnttab_handle *xgt, > > return 0; > > } > > > > +int osdep_gnttab_grant_copy(xengnttab_handle *xgt, > > + uint32_t count, > > + xengnttab_grant_copy_segment_t *segs) > > +{ > > + int i, rc; > > + int fd = xgt->fd; > > + struct ioctl_gntdev_grant_copy copy; > > + > > + copy.segments = calloc(count, sizeof(struct > > ioctl_gntdev_grant_copy_segment)); > > + copy.count = count; > > + for (i = 0; i < count; i++) > > + { > > + copy.segments[i].flags = segs[i].flags; > > + copy.segments[i].len = segs[i].len; > > + if (segs[i].flags == GNTCOPY_dest_gref) > > + { > > + copy.segments[i].dest.foreign.ref = segs[i].dest.foreign.ref; > > + copy.segments[i].dest.foreign.domid = > > segs[i].dest.foreign.domid; > > + copy.segments[i].dest.foreign.offset = > > segs[i].dest.foreign.offset; > > + copy.segments[i].source.virt = segs[i].source.virt; > > + } > > + else > > + { > > + copy.segments[i].source.foreign.ref = > > segs[i].source.foreign.ref; > > + copy.segments[i].source.foreign.domid = > > segs[i].source.foreign.domid; > > + copy.segments[i].source.foreign.offset = > > segs[i].source.foreign.offset; > > + copy.segments[i].dest.virt = segs[i].dest.virt; > > + } > > + } > > + > > + rc = ioctl(fd, IOCTL_GNTDEV_GRANT_COPY, ©); > > + if (rc) > > + { > > + GTERROR(xgt->logger, "ioctl GRANT COPY failed %d ", errno); > > + } > > + else > > + { > > + for (i = 0; i < count; i++) > > + segs[i].status = copy.segments[i].status; > > + } > > + > > + free(copy.segments); > > + return rc; > > +} > > I know Wei asked for this but you've replaced what should be a single > pointer assignment with a memory allocation and two loops over all the > segments. > > This is a hot path and the two structures (the libxengnttab one and the > Linux kernel one) are both part of their respective ABIs and won't > change so Wei's concern that they might change in the future is unfounded. > > This change makes xengnttab_grant_copy() useless for our (XenServer's) > use case. > > David As Wei and Ian are maintainers of toolstack if they agree on the previous cast that was here I will revert the changes. Paulina
On Wed, Jun 22, 2016 at 10:37:24AM +0100, David Vrabel wrote: > On 22/06/16 09:38, Paulina Szubarczyk wrote: > > In a linux part an ioctl(gntdev, IOCTL_GNTDEV_GRANT_COPY, ..) > > system call is invoked. In mini-os the operation is yet not > > implemented. For other OSs there is a dummy implementation. > [...] > > --- a/tools/libs/gnttab/linux.c > > +++ b/tools/libs/gnttab/linux.c > > @@ -235,6 +235,51 @@ int osdep_gnttab_unmap(xengnttab_handle *xgt, > > return 0; > > } > > > > +int osdep_gnttab_grant_copy(xengnttab_handle *xgt, > > + uint32_t count, > > + xengnttab_grant_copy_segment_t *segs) > > +{ > > + int i, rc; > > + int fd = xgt->fd; > > + struct ioctl_gntdev_grant_copy copy; > > + > > + copy.segments = calloc(count, sizeof(struct ioctl_gntdev_grant_copy_segment)); > > + copy.count = count; > > + for (i = 0; i < count; i++) > > + { > > + copy.segments[i].flags = segs[i].flags; > > + copy.segments[i].len = segs[i].len; > > + if (segs[i].flags == GNTCOPY_dest_gref) > > + { > > + copy.segments[i].dest.foreign.ref = segs[i].dest.foreign.ref; > > + copy.segments[i].dest.foreign.domid = segs[i].dest.foreign.domid; > > + copy.segments[i].dest.foreign.offset = segs[i].dest.foreign.offset; > > + copy.segments[i].source.virt = segs[i].source.virt; > > + } > > + else > > + { > > + copy.segments[i].source.foreign.ref = segs[i].source.foreign.ref; > > + copy.segments[i].source.foreign.domid = segs[i].source.foreign.domid; > > + copy.segments[i].source.foreign.offset = segs[i].source.foreign.offset; > > + copy.segments[i].dest.virt = segs[i].dest.virt; > > + } > > + } > > + > > + rc = ioctl(fd, IOCTL_GNTDEV_GRANT_COPY, ©); > > + if (rc) > > + { > > + GTERROR(xgt->logger, "ioctl GRANT COPY failed %d ", errno); > > + } > > + else > > + { > > + for (i = 0; i < count; i++) > > + segs[i].status = copy.segments[i].status; > > + } > > + > > + free(copy.segments); > > + return rc; > > +} > > I know Wei asked for this but you've replaced what should be a single > pointer assignment with a memory allocation and two loops over all the > segments. > > This is a hot path and the two structures (the libxengnttab one and the > Linux kernel one) are both part of their respective ABIs and won't > change so Wei's concern that they might change in the future is unfounded. > The fundamental question is: will the ABI between the library and the kernel ever go mismatch? My answer is "maybe". My rationale is that everything goes across boundary of components need to be considered with caution. And I tend to assume the worst things will happen. To guarantee that they will never go mismatch is to have typedef ioctl_gntdev_grant_copy_segment xengnttab_grant_copy_segment_t; But that's not how the code is written. I would like to hear a third opinion. Is my concern unfounded? Am I too cautious? Is there any compelling argument that I missed? Somewhat related, can we have some numbers please? It could well be the cost of the two loops is much cheaper than whatever is going on inside the kernel / hypervisor. And it could turn out that the numbers render this issue moot. Wei.
On Wed, Jun 22, 2016 at 11:53:00AM +0200, Paulina Szubarczyk wrote: [...] > > I know Wei asked for this but you've replaced what should be a single > > pointer assignment with a memory allocation and two loops over all the > > segments. > > > > This is a hot path and the two structures (the libxengnttab one and the > > Linux kernel one) are both part of their respective ABIs and won't > > change so Wei's concern that they might change in the future is unfounded. > > > > This change makes xengnttab_grant_copy() useless for our (XenServer's) > > use case. > > > > David > > As Wei and Ian are maintainers of toolstack if they agree on the previous cast > that was here I will revert the changes. > Do you have the most up to date numbers? How do they compare to the numbers in previous version? If there is degradation, how big is that in terms of percentage? Wei. > Paulina
On 22/06/16 12:21, Wei Liu wrote: > On Wed, Jun 22, 2016 at 10:37:24AM +0100, David Vrabel wrote: >> On 22/06/16 09:38, Paulina Szubarczyk wrote: >>> In a linux part an ioctl(gntdev, IOCTL_GNTDEV_GRANT_COPY, ..) >>> system call is invoked. In mini-os the operation is yet not >>> implemented. For other OSs there is a dummy implementation. >> [...] >>> --- a/tools/libs/gnttab/linux.c >>> +++ b/tools/libs/gnttab/linux.c >>> @@ -235,6 +235,51 @@ int osdep_gnttab_unmap(xengnttab_handle *xgt, >>> return 0; >>> } >>> >>> +int osdep_gnttab_grant_copy(xengnttab_handle *xgt, >>> + uint32_t count, >>> + xengnttab_grant_copy_segment_t *segs) >>> +{ >>> + int i, rc; >>> + int fd = xgt->fd; >>> + struct ioctl_gntdev_grant_copy copy; >>> + >>> + copy.segments = calloc(count, sizeof(struct ioctl_gntdev_grant_copy_segment)); >>> + copy.count = count; >>> + for (i = 0; i < count; i++) >>> + { >>> + copy.segments[i].flags = segs[i].flags; >>> + copy.segments[i].len = segs[i].len; >>> + if (segs[i].flags == GNTCOPY_dest_gref) >>> + { >>> + copy.segments[i].dest.foreign.ref = segs[i].dest.foreign.ref; >>> + copy.segments[i].dest.foreign.domid = segs[i].dest.foreign.domid; >>> + copy.segments[i].dest.foreign.offset = segs[i].dest.foreign.offset; >>> + copy.segments[i].source.virt = segs[i].source.virt; >>> + } >>> + else >>> + { >>> + copy.segments[i].source.foreign.ref = segs[i].source.foreign.ref; >>> + copy.segments[i].source.foreign.domid = segs[i].source.foreign.domid; >>> + copy.segments[i].source.foreign.offset = segs[i].source.foreign.offset; >>> + copy.segments[i].dest.virt = segs[i].dest.virt; >>> + } >>> + } >>> + >>> + rc = ioctl(fd, IOCTL_GNTDEV_GRANT_COPY, ©); >>> + if (rc) >>> + { >>> + GTERROR(xgt->logger, "ioctl GRANT COPY failed %d ", errno); >>> + } >>> + else >>> + { >>> + for (i = 0; i < count; i++) >>> + segs[i].status = copy.segments[i].status; >>> + } >>> + >>> + free(copy.segments); >>> + return rc; >>> +} >> >> I know Wei asked for this but you've replaced what should be a single >> pointer assignment with a memory allocation and two loops over all the >> segments. >> >> This is a hot path and the two structures (the libxengnttab one and the >> Linux kernel one) are both part of their respective ABIs and won't >> change so Wei's concern that they might change in the future is unfounded. >> > > The fundamental question is: will the ABI between the library and the > kernel ever go mismatch? > > My answer is "maybe". My rationale is that everything goes across > boundary of components need to be considered with caution. And I tend to > assume the worst things will happen. > > To guarantee that they will never go mismatch is to have > > typedef ioctl_gntdev_grant_copy_segment xengnttab_grant_copy_segment_t; > > But that's not how the code is written. > > I would like to hear a third opinion. Is my concern unfounded? Am I too > cautious? Is there any compelling argument that I missed? > > Somewhat related, can we have some numbers please? It could well be the > cost of the two loops is much cheaper than whatever is going on inside > the kernel / hypervisor. And it could turn out that the numbers render > this issue moot. I did some (very) adhoc measurements and with the worst case of single short segments for each ioctl, the optimized version of osdep_gnttab_grant_copy() looks to be ~5% faster. This is enough of a difference that we should use the optimized version. The unoptimized version also adds an additional failure path (the calloc) which would be best avoided. David
On Wed, 22 Jun 2016 12:24:16 +0100 Wei Liu <wei.liu2@citrix.com> wrote: > On Wed, Jun 22, 2016 at 11:53:00AM +0200, Paulina Szubarczyk wrote: > [...] > > > I know Wei asked for this but you've replaced what should be a single > > > pointer assignment with a memory allocation and two loops over all the > > > segments. > > > > > > This is a hot path and the two structures (the libxengnttab one and the > > > Linux kernel one) are both part of their respective ABIs and won't > > > change so Wei's concern that they might change in the future is unfounded. > > > > > > This change makes xengnttab_grant_copy() useless for our (XenServer's) > > > use case. > > > > > > David > > > > As Wei and Ian are maintainers of toolstack if they agree on the previous > > cast that was here I will revert the changes. > > > > Do you have the most up to date numbers? How do they compare to the > numbers in previous version? If there is degradation, how big is that in > terms of percentage? > > Wei. > In the file [1] in the sheets with *-domU there are the results for the new implementation with comparisons to grant map implementation which I run yesterday/today. I also rebase to the newest staging version before the tests and there is some improvement for both grant map and grant copy implementation comparing to previous results, that is way I would not compare the results from the previous test and I am going to run the test for the implementation with casting the structures again today. But single test that I made take around 90 minutes, since there is 5 min warm up and 1 min x 14 size of blocks for iodepth in range [1, 4, 8, 64, 256]. And I usually did them at least three times.. [1]https://docs.google.com/spreadsheets/d/1E6AMiB8ceJpExL6jWpH9u2yy6DZxzhmDUyFf-eUuJ0c/edit?usp=sharing Paulina
To unblock Paulina on her series, I would be ok with the cast provided there is compile-time check to ensure the user-space structure is identical to the ioctl structure. That would involve: 1. Introducing BUILD_BUG_ON, offsetof, alignof to libs/ if they are not already available. 2. BUILD_BUG_ON(sizeof(A) != sizeof(B)) 3. BUILD_BUG_ON(offsetof(A, f1) != offsetof(B, f1)) (enumerate all fields) 4. BUILD_BUG_ON(alignof(A) != alignof(B)) Paulina, let me know if you would be interested in doing #1. Normally this requires reading compiler manuals and some coding. I can give you more details if you're up for the task, otherwise I will try to find some time to do it myself. Wei.
On Fri, Jul 08, 2016 at 02:18:46PM +0100, Wei Liu wrote: > To unblock Paulina on her series, I would be ok with the cast provided > there is compile-time check to ensure the user-space structure is > identical to the ioctl structure. > > That would involve: > 1. Introducing BUILD_BUG_ON, offsetof, alignof to libs/ if they are not > already available. I just checked all these. BUILD_BUG_ON is not there. A patch for it is trivial. I will do that soon. offsetof can be found in stddef.h. alignof is C11 (we require C99), but there is __alignof__ gcc extension, which clang also supports. We've been using that for quite a long time, so I don't think we need to do anything about it. Wei.
diff --git a/tools/include/xen-sys/Linux/gntdev.h b/tools/include/xen-sys/Linux/gntdev.h index caf6fb4..0ca07c9 100644 --- a/tools/include/xen-sys/Linux/gntdev.h +++ b/tools/include/xen-sys/Linux/gntdev.h @@ -147,4 +147,25 @@ struct ioctl_gntdev_unmap_notify { /* Send an interrupt on the indicated event channel */ #define UNMAP_NOTIFY_SEND_EVENT 0x2 +struct ioctl_gntdev_grant_copy_segment { + union { + void *virt; + struct { + uint32_t ref; + uint16_t offset; + uint16_t domid; + } foreign; + } source, dest; + uint16_t len; + uint16_t flags; + int16_t status; +}; + +#define IOCTL_GNTDEV_GRANT_COPY \ +_IOC(_IOC_NONE, 'G', 8, sizeof(struct ioctl_gntdev_grant_copy)) +struct ioctl_gntdev_grant_copy { + unsigned int count; + struct ioctl_gntdev_grant_copy_segment *segments; +}; + #endif /* __LINUX_PUBLIC_GNTDEV_H__ */ diff --git a/tools/libs/gnttab/Makefile b/tools/libs/gnttab/Makefile index af64542..95c2cd8 100644 --- a/tools/libs/gnttab/Makefile +++ b/tools/libs/gnttab/Makefile @@ -2,7 +2,7 @@ XEN_ROOT = $(CURDIR)/../../.. include $(XEN_ROOT)/tools/Rules.mk MAJOR = 1 -MINOR = 0 +MINOR = 1 SHLIB_LDFLAGS += -Wl,--version-script=libxengnttab.map CFLAGS += -Werror -Wmissing-prototypes diff --git a/tools/libs/gnttab/gnttab_core.c b/tools/libs/gnttab/gnttab_core.c index 5d0474d..968c833 100644 --- a/tools/libs/gnttab/gnttab_core.c +++ b/tools/libs/gnttab/gnttab_core.c @@ -113,6 +113,12 @@ int xengnttab_unmap(xengnttab_handle *xgt, void *start_address, uint32_t count) return osdep_gnttab_unmap(xgt, start_address, count); } +int xengnttab_grant_copy(xengnttab_handle *xgt, + uint32_t count, + xengnttab_grant_copy_segment_t *segs) +{ + return osdep_gnttab_grant_copy(xgt, count, segs); +} /* * Local variables: * mode: C diff --git a/tools/libs/gnttab/gnttab_unimp.c b/tools/libs/gnttab/gnttab_unimp.c index b3a4a20..829eced 100644 --- a/tools/libs/gnttab/gnttab_unimp.c +++ b/tools/libs/gnttab/gnttab_unimp.c @@ -78,6 +78,12 @@ int xengnttab_unmap(xengnttab_handle *xgt, void *start_address, uint32_t count) abort(); } +int xengnttab_copy_grant(xengnttab_handle *xgt, + uint32_t count, + xengnttab_copy_grant_segment_t *segs) +{ + abort(); +} /* * Local variables: * mode: C diff --git a/tools/libs/gnttab/include/xengnttab.h b/tools/libs/gnttab/include/xengnttab.h index 0431dcf..949fd9e 100644 --- a/tools/libs/gnttab/include/xengnttab.h +++ b/tools/libs/gnttab/include/xengnttab.h @@ -258,6 +258,34 @@ int xengnttab_unmap(xengnttab_handle *xgt, void *start_address, uint32_t count); int xengnttab_set_max_grants(xengnttab_handle *xgt, uint32_t nr_grants); +struct xengnttab_grant_copy_segment { + union xengnttab_copy_ptr { + void *virt; + struct { + uint32_t ref; + uint16_t offset; + uint16_t domid; + } foreign; + } source, dest; + uint16_t len; + uint16_t flags; + int16_t status; +}; + +typedef struct xengnttab_grant_copy_segment xengnttab_grant_copy_segment_t; + +/** + * Copy memory from or to grant references. The information of each operations + * are contained in 'xengnttab_grant_copy_segment_t'. The @flag value indicate + * the direction of an operation (GNTCOPY_source_gref\GNTCOPY_dest_gref). + * + * The sum of fields @offset[i] and @len[i] of 'xengnttab_grant_copy_segment_t' + * should not exceed XEN_PAGE_SIZE + */ +int xengnttab_grant_copy(xengnttab_handle *xgt, + uint32_t count, + xengnttab_grant_copy_segment_t *segs); + /* * Grant Sharing Interface (allocating and granting pages to others) */ diff --git a/tools/libs/gnttab/libxengnttab.map b/tools/libs/gnttab/libxengnttab.map index dc737ac..f78da22 100644 --- a/tools/libs/gnttab/libxengnttab.map +++ b/tools/libs/gnttab/libxengnttab.map @@ -21,3 +21,8 @@ VERS_1.0 { xengntshr_unshare; local: *; /* Do not expose anything by default */ }; + +VERS_1.1 { + global: + xengnttab_grant_copy; +} VERS_1.0; diff --git a/tools/libs/gnttab/linux.c b/tools/libs/gnttab/linux.c index 7b0fba4..62ad7bd 100644 --- a/tools/libs/gnttab/linux.c +++ b/tools/libs/gnttab/linux.c @@ -235,6 +235,51 @@ int osdep_gnttab_unmap(xengnttab_handle *xgt, return 0; } +int osdep_gnttab_grant_copy(xengnttab_handle *xgt, + uint32_t count, + xengnttab_grant_copy_segment_t *segs) +{ + int i, rc; + int fd = xgt->fd; + struct ioctl_gntdev_grant_copy copy; + + copy.segments = calloc(count, sizeof(struct ioctl_gntdev_grant_copy_segment)); + copy.count = count; + for (i = 0; i < count; i++) + { + copy.segments[i].flags = segs[i].flags; + copy.segments[i].len = segs[i].len; + if (segs[i].flags == GNTCOPY_dest_gref) + { + copy.segments[i].dest.foreign.ref = segs[i].dest.foreign.ref; + copy.segments[i].dest.foreign.domid = segs[i].dest.foreign.domid; + copy.segments[i].dest.foreign.offset = segs[i].dest.foreign.offset; + copy.segments[i].source.virt = segs[i].source.virt; + } + else + { + copy.segments[i].source.foreign.ref = segs[i].source.foreign.ref; + copy.segments[i].source.foreign.domid = segs[i].source.foreign.domid; + copy.segments[i].source.foreign.offset = segs[i].source.foreign.offset; + copy.segments[i].dest.virt = segs[i].dest.virt; + } + } + + rc = ioctl(fd, IOCTL_GNTDEV_GRANT_COPY, ©); + if (rc) + { + GTERROR(xgt->logger, "ioctl GRANT COPY failed %d ", errno); + } + else + { + for (i = 0; i < count; i++) + segs[i].status = copy.segments[i].status; + } + + free(copy.segments); + return rc; +} + int osdep_gntshr_open(xengntshr_handle *xgs) { int fd = open(DEVXEN "gntalloc", O_RDWR); diff --git a/tools/libs/gnttab/minios.c b/tools/libs/gnttab/minios.c index 7e04174..0951bc9 100644 --- a/tools/libs/gnttab/minios.c +++ b/tools/libs/gnttab/minios.c @@ -106,6 +106,12 @@ int osdep_gnttab_set_max_grants(xengnttab_handle *xgt, uint32_t count) return ret; } +int osdep_gnttab_grant_copy(xengnttab_handle *xgt, + uint32_t count, + xengnttab_grant_copy_segment_t *segs) +{ + return -1; +} /* * Local variables: * mode: C diff --git a/tools/libs/gnttab/private.h b/tools/libs/gnttab/private.h index d286c86..d6c5594 100644 --- a/tools/libs/gnttab/private.h +++ b/tools/libs/gnttab/private.h @@ -23,6 +23,10 @@ void *osdep_gnttab_grant_map(xengnttab_handle *xgt, int osdep_gnttab_unmap(xengnttab_handle *xgt, void *start_address, uint32_t count); +int osdep_gnttab_grant_copy(xengnttab_handle *xgt, + uint32_t count, + xengnttab_grant_copy_segment_t *segs); + int osdep_gntshr_open(xengntshr_handle *xgs); int osdep_gntshr_close(xengntshr_handle *xgs);
In a linux part an ioctl(gntdev, IOCTL_GNTDEV_GRANT_COPY, ..) system call is invoked. In mini-os the operation is yet not implemented. For other OSs there is a dummy implementation. Signed-off-by: Paulina Szubarczyk <paulinaszubarczyk@gmail.com> --- Changes since v2: - dropped the changes in libxc/include/xenctrl_compat - changed the MINOR version in Makefile - replaced 'return -1' -> 'abort()'in libs/gnttab/gnttab_unimp.c - moved the struct 'xengnttab_copy_grant_segment' to libs/gnttab/include/xengnttab.h - added explicit assingment to ioctl_gntdev_grant_copy_segment to the linux part tools/include/xen-sys/Linux/gntdev.h | 21 ++++++++++++++++ tools/libs/gnttab/Makefile | 2 +- tools/libs/gnttab/gnttab_core.c | 6 +++++ tools/libs/gnttab/gnttab_unimp.c | 6 +++++ tools/libs/gnttab/include/xengnttab.h | 28 ++++++++++++++++++++++ tools/libs/gnttab/libxengnttab.map | 5 ++++ tools/libs/gnttab/linux.c | 45 +++++++++++++++++++++++++++++++++++ tools/libs/gnttab/minios.c | 6 +++++ tools/libs/gnttab/private.h | 4 ++++ 9 files changed, 122 insertions(+), 1 deletion(-)