Skip to contentSkip to conversation

tools/misc/xencov.c: Use MAP_WIRED on NetBSD

PATCH In review Christoph Egger 5 participants 11 messages May 30, 2013 – Jun 27, 2013

lore
Share & tools
lore
#0 lore raw

PATCH 1/1 tools/misc/xencov.c: Use MAP_WIRED on NetBSD

tools/xencov: MAP_LOCKED is Linux specific. NetBSD's equivalent is MAP_WIRED.

From: Miguel Clara <[email protected]>

tools/misc/xencov.c +5 -0
diff -r f1fa13daf4b7 -r 97a4f7e36a8f tools/misc/xencov.c
@@ -26,6 +26,11 @@
 #include <err.h>
 #include <sys/mman.h>
 
+#ifdef __NetBSD__
+/* MAP_LOCKED is Linux specific. MAP_WIRED is NetBSD's equivalent. */
+#define MAP_LOCKED MAP_WIRED
+#endif
+
 static xc_interface *gcov_xch = NULL;
 
 static void gcov_init(void)

# HG changeset patch
# User Christoph Egger <[email protected]>
# Date 1369917613 0
# Node ID 97a4f7e36a8fb0bc37f8a6dc04a0e33b1bc9835d
# Parent f1fa13daf4b78b027f081aca5be24cfa96813b42
tools/xencov: MAP_LOCKED is Linux specific. NetBSD's equivalent is MAP_WIRED.

From: Miguel Clara <[email protected]>

tools/misc/xencov.c +5 -0
diff -r f1fa13daf4b7 -r 97a4f7e36a8f tools/misc/xencov.c
@@ -26,6 +26,11 @@
 #include <err.h>
 #include <sys/mman.h>
 
+#ifdef __NetBSD__
+/* MAP_LOCKED is Linux specific. MAP_WIRED is NetBSD's equivalent. */
+#define MAP_LOCKED MAP_WIRED
+#endif
+
 static xc_interface *gcov_xch = NULL;
 
 static void gcov_init(void)

_______________________________________________
Xen-devel mailing list
[email protected]
http://lists.xen.org/xen-devel

#1 lore raw
Quoted 1 line · Christoph Egger

tools/xencov: MAP_LOCKED is Linux specific. NetBSD's equivalent is MAP_WIRED.

It looks to me as if xencov.c's shouldn't be using mmap in the first place. It should be using the libxc hypercall buffer code.

I think xencov.c should be using xc_hypercall_buffer_alloc(_pages) and gcov_get_info should be xc_gcov_get_info & inside libxc not open coded in this tool. Not least because of its abuse of the GUEST_HANDLE interface (going directly at .p instead of using xen_set_guest_handle(), which is forbidden).

Frediano, do you have time to sort this out?

NB On Linux the hypercall buffers currently turn into MAP_PRIVATE| MAP_ANONYMOUS|MAP_LOCKED but on netbsd it is just xc_memalign. Presumably netbsd doesn't have to worry about the hypercall buffer being unmapped/swapped/paged/etc under its feet? Or if it does it needs to be fixed in libxc...

Thanks,
Ian.

Quoted 18 lines

From: Miguel Clara <[email protected]>

diff -r f1fa13daf4b7 -r 97a4f7e36a8f tools/misc/xencov.c

tools/misc/xencov.c +5 -0
@@ -26,6 +26,11 @@
 #include <err.h>
 #include <sys/mman.h>
 
+#ifdef __NetBSD__
+/* MAP_LOCKED is Linux specific. MAP_WIRED is NetBSD's equivalent. */
+#define MAP_LOCKED MAP_WIRED
+#endif
+
 static xc_interface *gcov_xch = NULL;
 
 static void gcov_init(void)
#2 lore raw

Subject: [PATCH] gcov: Do not use mmap directly but use xc_hypercall_buffer_alloc

xencov.c did not compile on NetBSD so use xc_hypercall_buffer which is more portable.

---
 tools/misc/xencov.c |   19 +++++++------------
 1 file changed, 7 insertions(+), 12 deletions(-)

Here you are. It get tested on a x64 machine, if somebody could test it with a NetBSD would be great.

tools/misc/xencov.c +7 -12
index 6645a30..e38d473 100644
@@ -24,7 +24,6 @@
 #include <unistd.h>
 #include <errno.h>
 #include <err.h>
-#include <sys/mman.h>
 
 static xc_interface *gcov_xch = NULL;
 
@@ -35,7 +34,7 @@ static void gcov_init(void)
         err(1, "opening interface");
 }
 
-int gcov_get_info(int op, struct xen_sysctl *sys, void *ptr)
+int gcov_get_info(int op, struct xen_sysctl *sys, uint8_t *ptr)
 {
     struct xen_sysctl_coverage_op *cov;
 
@@ -44,7 +43,7 @@ int gcov_get_info(int op, struct xen_sysctl *sys, void *ptr)
 
     cov = &sys->u.coverage_op;
     cov->cmd = op;
-    cov->u.raw_info.p = ptr;
+    set_xen_guest_handle_raw(cov->u.raw_info, ptr);
 
     return xc_sysctl(gcov_xch, sys);
 }
@@ -52,10 +51,8 @@ int gcov_get_info(int op, struct xen_sysctl *sys, void *ptr)
 static void gcov_read(const char *fn, int reset)
 {
     struct xen_sysctl sys;
-    unsigned page_size = sysconf(_SC_PAGESIZE);
     uint32_t total_len;
-    uint8_t *p;
-    size_t size;
+    DECLARE_HYPERCALL_BUFFER(uint8_t, p);
     FILE *f;
     int op = reset ? XEN_SYSCTL_COVERAGE_read_and_reset :
                      XEN_SYSCTL_COVERAGE_read;
@@ -71,12 +68,9 @@ static void gcov_read(const char *fn, int reset)
         errx(1, "coverage size too big %u bytes\n", total_len);
 
     /* allocate */
-    size = total_len + page_size;
-    size -= (size % page_size);
-    p = mmap(0, size, PROT_WRITE|PROT_READ,
-             MAP_PRIVATE|MAP_ANON|MAP_LOCKED, -1, 0);
-    if ( p == (uint8_t *) -1 )
-        err(1, "mapping memory for coverage");
+    p = xc_hypercall_buffer_alloc(gcov_xch, p, total_len);
+    if ( p == NULL )
+        err(1, "allocating memory for coverage");
 
     /* get data */
     memset(p, 0, total_len);
@@ -94,6 +88,7 @@ static void gcov_read(const char *fn, int reset)
         err(1, "writing coverage to file");
     if (f != stdout)
         fclose(f);
+    xc_hypercall_buffer_free(gcov_xch, p);
 }
 
 static void gcov_reset(void)
Signature · 1 line
1.7.10.4
Quoted 43 lines · Ian Campbell
Quoted 1 line · Christoph Egger

tools/xencov: MAP_LOCKED is Linux specific. NetBSD's equivalent is MAP_WIRED.

It looks to me as if xencov.c's shouldn't be using mmap in the first place. It should be using the libxc hypercall buffer code.

I think xencov.c should be using xc_hypercall_buffer_alloc(_pages) and gcov_get_info should be xc_gcov_get_info & inside libxc not open coded in this tool. Not least because of its abuse of the GUEST_HANDLE interface (going directly at .p instead of using xen_set_guest_handle(), which is forbidden).

Frediano, do you have time to sort this out?

NB On Linux the hypercall buffers currently turn into MAP_PRIVATE| MAP_ANONYMOUS|MAP_LOCKED but on netbsd it is just xc_memalign. Presumably netbsd doesn't have to worry about the hypercall buffer being unmapped/swapped/paged/etc under its feet? Or if it does it needs to be fixed in libxc...

Thanks,
Ian.

Quoted 18 lines

From: Miguel Clara <[email protected]>

diff -r f1fa13daf4b7 -r 97a4f7e36a8f tools/misc/xencov.c

tools/misc/xencov.c +5 -0
@@ -26,6 +26,11 @@
 #include <err.h>
 #include <sys/mman.h>
 
+#ifdef __NetBSD__
+/* MAP_LOCKED is Linux specific. MAP_WIRED is NetBSD's equivalent. */
+#define MAP_LOCKED MAP_WIRED
+#endif
+
 static xc_interface *gcov_xch = NULL;
 
 static void gcov_init(void)
#3 lore raw
Quoted 35 lines · Frediano Ziglio

Subject: [PATCH] gcov: Do not use mmap directly but use xc_hypercall_buffer_alloc

xencov.c did not compile on NetBSD so use xc_hypercall_buffer which is more portable.

---
 tools/misc/xencov.c |   19 +++++++------------
 1 file changed, 7 insertions(+), 12 deletions(-)

Here you are. It get tested on a x64 machine, if somebody could test it with a NetBSD would be great.

tools/misc/xencov.c +1 -2
index 6645a30..e38d473 100644
@@ -24,7 +24,6 @@
 #include <unistd.h>
 #include <errno.h>
 #include <err.h>
-#include <sys/mman.h>
 
 static xc_interface *gcov_xch = NULL;
 
@@ -35,7 +34,7 @@ static void gcov_init(void)
         err(1, "opening interface");
 }
 
-int gcov_get_info(int op, struct xen_sysctl *sys, void *ptr)
+int gcov_get_info(int op, struct xen_sysctl *sys, uint8_t *ptr)
 {
     struct xen_sysctl_coverage_op *cov;
 

tools/misc/xencov.c int gcov_get_info(int op, struct xen_sysctl *sys, void *ptr) · line 46

Quoted 5 lines
tools/misc/xencov.c +1 -1
@@ -44,7 +43,7 @@ int gcov_get_info(int op, struct xen_sysctl *sys, void *ptr)
 
     cov = &sys->u.coverage_op;
     cov->cmd = op;
-    cov->u.raw_info.p = ptr;
+    set_xen_guest_handle_raw(cov->u.raw_info, ptr);

This isn't right I'm afraid. Your "void *ptr" here should become "struct xc_hypercall_buffer *ptr" and you should use DECLARE_HYPERCALL_BUFFER_ARGUMENT(ptr) in the body of the function and then drop the _raw from the set.

The caller of this function then needs to pass HYPERCALL_BUFFER(name) to the function (where it looks like name == p in this case).

xc_perfc_query() and its callers are an example of this pattern. Likewise xc_lockprof_query().

Quoted 39 lines
tools/misc/xencov.c +5 -9
     return xc_sysctl(gcov_xch, sys);
 }
@@ -52,10 +51,8 @@ int gcov_get_info(int op, struct xen_sysctl *sys, void *ptr)
 static void gcov_read(const char *fn, int reset)
 {
     struct xen_sysctl sys;
-    unsigned page_size = sysconf(_SC_PAGESIZE);
     uint32_t total_len;
-    uint8_t *p;
-    size_t size;
+    DECLARE_HYPERCALL_BUFFER(uint8_t, p);
     FILE *f;
     int op = reset ? XEN_SYSCTL_COVERAGE_read_and_reset :
                      XEN_SYSCTL_COVERAGE_read;
@@ -71,12 +68,9 @@ static void gcov_read(const char *fn, int reset)
         errx(1, "coverage size too big %u bytes\n", total_len);
 
     /* allocate */
-    size = total_len + page_size;
-    size -= (size % page_size);
-    p = mmap(0, size, PROT_WRITE|PROT_READ,
-             MAP_PRIVATE|MAP_ANON|MAP_LOCKED, -1, 0);
-    if ( p == (uint8_t *) -1 )
-        err(1, "mapping memory for coverage");
+    p = xc_hypercall_buffer_alloc(gcov_xch, p, total_len);
+    if ( p == NULL )
+        err(1, "allocating memory for coverage");
 
     /* get data */
     memset(p, 0, total_len);
@@ -94,6 +88,7 @@ static void gcov_read(const char *fn, int reset)
         err(1, "writing coverage to file");
     if (f != stdout)
         fclose(f);
+    xc_hypercall_buffer_free(gcov_xch, p);
 }
 
 static void gcov_reset(void)
#4 lore raw

Subject: [PATCH] gcov: Do not use mmap directly but use xc_hypercall_buffer_alloc

xencov.c did not compile on NetBSD so use xc_hypercall_buffer which is more portable.

---
 tools/misc/xencov.c |   22 +++++++++-------------
 1 file changed, 9 insertions(+), 13 deletions(-)

Here you are. It get tested on a x64 machine, if somebody could test it with a NetBSD would be great.

tools/misc/xencov.c +9 -13
index 6645a30..fb4b2ff 100644
@@ -24,7 +24,6 @@
 #include <unistd.h>
 #include <errno.h>
 #include <err.h>
-#include <sys/mman.h>
 
 static xc_interface *gcov_xch = NULL;
 
@@ -35,16 +34,17 @@ static void gcov_init(void)
         err(1, "opening interface");
 }
 
-int gcov_get_info(int op, struct xen_sysctl *sys, void *ptr)
+int gcov_get_info(int op, struct xen_sysctl *sys, struct xc_hypercall_buffer *ptr)
 {
     struct xen_sysctl_coverage_op *cov;
+    DECLARE_HYPERCALL_BUFFER_ARGUMENT(ptr);
 
     memset(sys, 0, sizeof(*sys));
     sys->cmd = XEN_SYSCTL_coverage_op;
 
     cov = &sys->u.coverage_op;
     cov->cmd = op;
-    cov->u.raw_info.p = ptr;
+    set_xen_guest_handle(cov->u.raw_info, ptr);
 
     return xc_sysctl(gcov_xch, sys);
 }
@@ -52,10 +52,8 @@ int gcov_get_info(int op, struct xen_sysctl *sys, void *ptr)
 static void gcov_read(const char *fn, int reset)
 {
     struct xen_sysctl sys;
-    unsigned page_size = sysconf(_SC_PAGESIZE);
     uint32_t total_len;
-    uint8_t *p;
-    size_t size;
+    DECLARE_HYPERCALL_BUFFER(uint8_t, p);
     FILE *f;
     int op = reset ? XEN_SYSCTL_COVERAGE_read_and_reset :
                      XEN_SYSCTL_COVERAGE_read;
@@ -71,16 +69,13 @@ static void gcov_read(const char *fn, int reset)
         errx(1, "coverage size too big %u bytes\n", total_len);
 
     /* allocate */
-    size = total_len + page_size;
-    size -= (size % page_size);
-    p = mmap(0, size, PROT_WRITE|PROT_READ,
-             MAP_PRIVATE|MAP_ANON|MAP_LOCKED, -1, 0);
-    if ( p == (uint8_t *) -1 )
-        err(1, "mapping memory for coverage");
+    p = xc_hypercall_buffer_alloc(gcov_xch, p, total_len);
+    if ( p == NULL )
+        err(1, "allocating memory for coverage");
 
     /* get data */
     memset(p, 0, total_len);
-    if ( gcov_get_info(op, &sys, p) < 0 )
+    if ( gcov_get_info(op, &sys, HYPERCALL_BUFFER(p)) < 0 )
         err(1, "getting coverage information");
 
     /* write to a file */
@@ -94,6 +89,7 @@ static void gcov_read(const char *fn, int reset)
         err(1, "writing coverage to file");
     if (f != stdout)
         fclose(f);
+    xc_hypercall_buffer_free(gcov_xch, p);
 }
 
 static void gcov_reset(void)
Signature · 1 line
1.7.10.4
Quoted 94 lines · Ian Campbell
Quoted 35 lines · Frediano Ziglio

Subject: [PATCH] gcov: Do not use mmap directly but use xc_hypercall_buffer_alloc

xencov.c did not compile on NetBSD so use xc_hypercall_buffer which is more portable.

---
 tools/misc/xencov.c |   19 +++++++------------
 1 file changed, 7 insertions(+), 12 deletions(-)

Here you are. It get tested on a x64 machine, if somebody could test it with a NetBSD would be great.

tools/misc/xencov.c +1 -2
index 6645a30..e38d473 100644
@@ -24,7 +24,6 @@
 #include <unistd.h>
 #include <errno.h>
 #include <err.h>
-#include <sys/mman.h>
 
 static xc_interface *gcov_xch = NULL;
 
@@ -35,7 +34,7 @@ static void gcov_init(void)
         err(1, "opening interface");
 }
 
-int gcov_get_info(int op, struct xen_sysctl *sys, void *ptr)
+int gcov_get_info(int op, struct xen_sysctl *sys, uint8_t *ptr)
 {
     struct xen_sysctl_coverage_op *cov;
 

tools/misc/xencov.c int gcov_get_info(int op, struct xen_sysctl *sys, void *ptr) · line 46

Quoted 5 lines
tools/misc/xencov.c +1 -1
@@ -44,7 +43,7 @@ int gcov_get_info(int op, struct xen_sysctl *sys, void *ptr)
 
     cov = &sys->u.coverage_op;
     cov->cmd = op;
-    cov->u.raw_info.p = ptr;
+    set_xen_guest_handle_raw(cov->u.raw_info, ptr);

This isn't right I'm afraid. Your "void *ptr" here should become "struct xc_hypercall_buffer *ptr" and you should use DECLARE_HYPERCALL_BUFFER_ARGUMENT(ptr) in the body of the function and then drop the _raw from the set.

The caller of this function then needs to pass HYPERCALL_BUFFER(name) to the function (where it looks like name == p in this case).

xc_perfc_query() and its callers are an example of this pattern. Likewise xc_lockprof_query().

Quoted 39 lines
tools/misc/xencov.c +5 -9
     return xc_sysctl(gcov_xch, sys);
 }
@@ -52,10 +51,8 @@ int gcov_get_info(int op, struct xen_sysctl *sys, void *ptr)
 static void gcov_read(const char *fn, int reset)
 {
     struct xen_sysctl sys;
-    unsigned page_size = sysconf(_SC_PAGESIZE);
     uint32_t total_len;
-    uint8_t *p;
-    size_t size;
+    DECLARE_HYPERCALL_BUFFER(uint8_t, p);
     FILE *f;
     int op = reset ? XEN_SYSCTL_COVERAGE_read_and_reset :
                      XEN_SYSCTL_COVERAGE_read;
@@ -71,12 +68,9 @@ static void gcov_read(const char *fn, int reset)
         errx(1, "coverage size too big %u bytes\n", total_len);
 
     /* allocate */
-    size = total_len + page_size;
-    size -= (size % page_size);
-    p = mmap(0, size, PROT_WRITE|PROT_READ,
-             MAP_PRIVATE|MAP_ANON|MAP_LOCKED, -1, 0);
-    if ( p == (uint8_t *) -1 )
-        err(1, "mapping memory for coverage");
+    p = xc_hypercall_buffer_alloc(gcov_xch, p, total_len);
+    if ( p == NULL )
+        err(1, "allocating memory for coverage");
 
     /* get data */
     memset(p, 0, total_len);
@@ -94,6 +88,7 @@ static void gcov_read(const char *fn, int reset)
         err(1, "writing coverage to file");
     if (f != stdout)
         fclose(f);
+    xc_hypercall_buffer_free(gcov_xch, p);
 }
 
 static void gcov_reset(void)
Acked-by
#5 lore raw
Quoted 6 lines · Frediano Ziglio

Subject: [PATCH] gcov: Do not use mmap directly but use xc_hypercall_buffer_alloc

xencov.c did not compile on NetBSD so use xc_hypercall_buffer which is more portable.

Looks good to me, thanks,

George, what is your feeling for the release? This is a somewhat obscure tool and IMHO the risk of regressing is small. The change fixes the default build on NetBSD.

Quoted 6 lines
---
 tools/misc/xencov.c |   22 +++++++++-------------
 1 file changed, 9 insertions(+), 13 deletions(-)

Here you are. It get tested on a x64 machine, if somebody could test it with a NetBSD would be great.

That would certainly be useful and appreciated although since it currently doesn't build on NetBSD there is not much chance of regressing there so I'll probably apply (subject to George's approval) in a day or so regardless (unless the test is done and fails of course).

Quoted 74 lines
tools/misc/xencov.c +9 -13
index 6645a30..fb4b2ff 100644
@@ -24,7 +24,6 @@
 #include <unistd.h>
 #include <errno.h>
 #include <err.h>
-#include <sys/mman.h>
 
 static xc_interface *gcov_xch = NULL;
 
@@ -35,16 +34,17 @@ static void gcov_init(void)
         err(1, "opening interface");
 }
 
-int gcov_get_info(int op, struct xen_sysctl *sys, void *ptr)
+int gcov_get_info(int op, struct xen_sysctl *sys, struct xc_hypercall_buffer *ptr)
 {
     struct xen_sysctl_coverage_op *cov;
+    DECLARE_HYPERCALL_BUFFER_ARGUMENT(ptr);
 
     memset(sys, 0, sizeof(*sys));
     sys->cmd = XEN_SYSCTL_coverage_op;
 
     cov = &sys->u.coverage_op;
     cov->cmd = op;
-    cov->u.raw_info.p = ptr;
+    set_xen_guest_handle(cov->u.raw_info, ptr);
 
     return xc_sysctl(gcov_xch, sys);
 }
@@ -52,10 +52,8 @@ int gcov_get_info(int op, struct xen_sysctl *sys, void *ptr)
 static void gcov_read(const char *fn, int reset)
 {
     struct xen_sysctl sys;
-    unsigned page_size = sysconf(_SC_PAGESIZE);
     uint32_t total_len;
-    uint8_t *p;
-    size_t size;
+    DECLARE_HYPERCALL_BUFFER(uint8_t, p);
     FILE *f;
     int op = reset ? XEN_SYSCTL_COVERAGE_read_and_reset :
                      XEN_SYSCTL_COVERAGE_read;
@@ -71,16 +69,13 @@ static void gcov_read(const char *fn, int reset)
         errx(1, "coverage size too big %u bytes\n", total_len);
 
     /* allocate */
-    size = total_len + page_size;
-    size -= (size % page_size);
-    p = mmap(0, size, PROT_WRITE|PROT_READ,
-             MAP_PRIVATE|MAP_ANON|MAP_LOCKED, -1, 0);
-    if ( p == (uint8_t *) -1 )
-        err(1, "mapping memory for coverage");
+    p = xc_hypercall_buffer_alloc(gcov_xch, p, total_len);
+    if ( p == NULL )
+        err(1, "allocating memory for coverage");
 
     /* get data */
     memset(p, 0, total_len);
-    if ( gcov_get_info(op, &sys, p) < 0 )
+    if ( gcov_get_info(op, &sys, HYPERCALL_BUFFER(p)) < 0 )
         err(1, "getting coverage information");
 
     /* write to a file */
@@ -94,6 +89,7 @@ static void gcov_read(const char *fn, int reset)
         err(1, "writing coverage to file");
     if (f != stdout)
         fclose(f);
+    xc_hypercall_buffer_free(gcov_xch, p);
 }
 
 static void gcov_reset(void)
Acked-by
#6 lore raw
Quoted 6 lines · Ian Campbell
Quoted 5 lines · Frediano Ziglio

Subject: [PATCH] gcov: Do not use mmap directly but use xc_hypercall_buffer_alloc

xencov.c did not compile on NetBSD so use xc_hypercall_buffer which is more portable.

Quoted 8 lines
Quoted 1 line

Looks good to me, thanks,

George, what is your feeling for the release? This is a somewhat obscure tool and IMHO the risk of regressing is small. The change fixes the default build on NetBSD.

Did we even have gcov in 4.2? Anyway I agree, the benefits are worth more than the risk.

Re the release:

-George

#7 lore raw
Quoted 10 lines · George Dunlap
Quoted 9 lines · Ian Campbell
Quoted 6 lines · Frediano Ziglio

Subject: [PATCH] gcov: Do not use mmap directly but use xc_hypercall_buffer_alloc

xencov.c did not compile on NetBSD so use xc_hypercall_buffer which is more portable.

Looks good to me, thanks,

Quoted 7 lines
Quoted 5 lines

George, what is your feeling for the release? This is a somewhat obscure tool and IMHO the risk of regressing is small. The change fixes the default build on NetBSD.

Did we even have gcov in 4.2?

Good point, no we didn't.

Quoted 13 lines

Anyway I agree, the benefits are worth
more than the risk.

Re the release:

-George

_______________________________________________
Xen-devel mailing list
[email protected]
http://lists.xen.org/xen-devel

#8 lore raw
In reply to George Dunlap
Quoted 10 lines · George Dunlap
Quoted 9 lines · Ian Campbell
Quoted 6 lines · Frediano Ziglio

Subject: [PATCH] gcov: Do not use mmap directly but use xc_hypercall_buffer_alloc

xencov.c did not compile on NetBSD so use xc_hypercall_buffer which is more portable.

Looks good to me, thanks,

Quoted 9 lines
Quoted 5 lines

George, what is your feeling for the release? This is a somewhat obscure tool and IMHO the risk of regressing is small. The change fixes the default build on NetBSD.

Did we even have gcov in 4.2? Anyway I agree, the benefits are worth more than the risk.

No, was introduced for 4.3.

Quoted 5 lines

Re the release:

-George

Frediano

author Acked-by
#10 lore raw
In reply to Frediano Ziglio
Quoted 6 lines · Frediano Ziglio

Subject: [PATCH] gcov: Do not use mmap directly but use xc_hypercall_buffer_alloc

xencov.c did not compile on NetBSD so use xc_hypercall_buffer which is more portable.

Quoted 81 lines
---
 tools/misc/xencov.c |   22 +++++++++-------------
 1 file changed, 9 insertions(+), 13 deletions(-)

Here you are. It get tested on a x64 machine, if somebody could test it with a NetBSD would be great.

tools/misc/xencov.c +9 -13
index 6645a30..fb4b2ff 100644
@@ -24,7 +24,6 @@
 #include <unistd.h>
 #include <errno.h>
 #include <err.h>
-#include <sys/mman.h>
 
 static xc_interface *gcov_xch = NULL;
 
@@ -35,16 +34,17 @@ static void gcov_init(void)
         err(1, "opening interface");
 }
 
-int gcov_get_info(int op, struct xen_sysctl *sys, void *ptr)
+int gcov_get_info(int op, struct xen_sysctl *sys, struct xc_hypercall_buffer *ptr)
 {
     struct xen_sysctl_coverage_op *cov;
+    DECLARE_HYPERCALL_BUFFER_ARGUMENT(ptr);
 
     memset(sys, 0, sizeof(*sys));
     sys->cmd = XEN_SYSCTL_coverage_op;
 
     cov = &sys->u.coverage_op;
     cov->cmd = op;
-    cov->u.raw_info.p = ptr;
+    set_xen_guest_handle(cov->u.raw_info, ptr);
 
     return xc_sysctl(gcov_xch, sys);
 }
@@ -52,10 +52,8 @@ int gcov_get_info(int op, struct xen_sysctl *sys, void *ptr)
 static void gcov_read(const char *fn, int reset)
 {
     struct xen_sysctl sys;
-    unsigned page_size = sysconf(_SC_PAGESIZE);
     uint32_t total_len;
-    uint8_t *p;
-    size_t size;
+    DECLARE_HYPERCALL_BUFFER(uint8_t, p);
     FILE *f;
     int op = reset ? XEN_SYSCTL_COVERAGE_read_and_reset :
                      XEN_SYSCTL_COVERAGE_read;
@@ -71,16 +69,13 @@ static void gcov_read(const char *fn, int reset)
         errx(1, "coverage size too big %u bytes\n", total_len);
 
     /* allocate */
-    size = total_len + page_size;
-    size -= (size % page_size);
-    p = mmap(0, size, PROT_WRITE|PROT_READ,
-             MAP_PRIVATE|MAP_ANON|MAP_LOCKED, -1, 0);
-    if ( p == (uint8_t *) -1 )
-        err(1, "mapping memory for coverage");
+    p = xc_hypercall_buffer_alloc(gcov_xch, p, total_len);
+    if ( p == NULL )
+        err(1, "allocating memory for coverage");
 
     /* get data */
     memset(p, 0, total_len);
-    if ( gcov_get_info(op, &sys, p) < 0 )
+    if ( gcov_get_info(op, &sys, HYPERCALL_BUFFER(p)) < 0 )
         err(1, "getting coverage information");
 
     /* write to a file */
@@ -94,6 +89,7 @@ static void gcov_read(const char *fn, int reset)
         err(1, "writing coverage to file");
     if (f != stdout)
         fclose(f);
+    xc_hypercall_buffer_free(gcov_xch, p);
 }
 
 static void gcov_reset(void)
#9 lore raw
In reply to George Dunlap
Quoted 16 lines · George Dunlap
Quoted 6 lines · Ian Campbell
Quoted 5 lines · Frediano Ziglio

Subject: [PATCH] gcov: Do not use mmap directly but use xc_hypercall_buffer_alloc

xencov.c did not compile on NetBSD so use xc_hypercall_buffer which is more portable.

Quoted 8 lines
Quoted 1 line

Looks good to me, thanks,

George, what is your feeling for the release? This is a somewhat obscure tool and IMHO the risk of regressing is small. The change fixes the default build on NetBSD.

Quoted 5 lines

Did we even have gcov in 4.2? Anyway I agree, the benefits are worth more than the risk.

Re the release:

This was a little while ago, but I've committed.