[kvm-unit-tests PATCH v2 0/4] s390x: css: pv: css test adaptation for PV

[kvm-unit-tests PATCH v2 0/4] s390x: css: pv: css test adaptation for PV

[Pierre Morel]

Hi all,

I send a v2 even I got not a lot of answers for v1 because:
1 I forgot the kvm-unit-test header
2 the patch on uv.h was very bad
3 I saw some stupid errors I can correct myself like
  to zero the allocated page before use or free it on error.

That said, here what is done:

To adapt the CSS I/O tests to protected virtualisation we need
utilities to:

1- allocate the I/O buffers in a private page (patch 3)
   It must be in a dedicated page to avoid exporting code or
   guest private data to the host.

2- share  the I/O buffer with the host (patch 2)

3- be sure to allocate memory under 2Gb (patch 1)

The 3 first patches are the implementation of the tools,
patch 4 is the modification of the css.c test for PV.

regards,
Pierre

Pierre Morel (4):
  memory: allocation in low memory
  s390x: pv: implement routine to share/unshare memory
  s390x: define UV compatible I/O allocation
  s390x: css: pv: css test adaptation for PV

 lib/alloc_dma_page.c  | 57 +++++++++++++++++++++++++++++++++++++++++++
 lib/alloc_dma_page.h  | 24 ++++++++++++++++++
 lib/s390x/asm/uv.h    | 50 +++++++++++++++++++++++++++++++++++++
 lib/s390x/css.h       |  3 +--
 lib/s390x/css_lib.c   | 28 ++++++---------------
 lib/s390x/malloc_io.c | 49 +++++++++++++++++++++++++++++++++++++
 lib/s390x/malloc_io.h | 18 ++++++++++++++
 lib/s390x/sclp.c      |  2 ++
 s390x/Makefile        |  2 ++
 s390x/css.c           | 35 +++++++++++++++++---------
 10 files changed, 235 insertions(+), 33 deletions(-)
 create mode 100644 lib/alloc_dma_page.c
 create mode 100644 lib/alloc_dma_page.h
 create mode 100644 lib/s390x/malloc_io.c
 create mode 100644 lib/s390x/malloc_io.h

-- 
2.25.1

changelog:

from v1:

- add the kvm-unit-test header

- correct checks for errors on Set/Remove Shared Access

- Add report for uv Set/Remove Shared Access

- zero the allocated I/O page before use

- free the page on error.

[kvm-unit-tests PATCH v2 1/4] memory: allocation in low memory

[Pierre Morel]

Some architectures need allocations to be done under a
specific address limit to allow DMA from I/O.

We propose here a very simple page allocator to get
pages allocated under this specific limit.

The DMA page allocator will only use part of the available memory
under the DMA address limit to let room for the standard allocator.

Signed-off-by: Pierre Morel <pmorel@linux.ibm.com>
---
 lib/alloc_dma_page.c | 57 ++++++++++++++++++++++++++++++++++++++++++++
 lib/alloc_dma_page.h | 24 +++++++++++++++++++
 lib/s390x/sclp.c     |  2 ++
 s390x/Makefile       |  1 +
 4 files changed, 84 insertions(+)
 create mode 100644 lib/alloc_dma_page.c
 create mode 100644 lib/alloc_dma_page.h

diff --git a/lib/alloc_dma_page.c b/lib/alloc_dma_page.c
new file mode 100644
index 0000000..6a16e38
--- /dev/null
+++ b/lib/alloc_dma_page.c
@@ -0,0 +1,57 @@
+/*
+ * Page allocator for DMA
+ *
+ * Copyright (c) IBM, Corp. 2020
+ *
+ * Authors:
+ *  Pierre Morel <pmorel@linux.ibm.com>
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Library General Public License version 2.
+ */
+#include <libcflat.h>
+#include <asm/spinlock.h>
+#include <alloc_dma_page.h>
+
+static struct spinlock lock;
+static void *dma_freelist = 0;
+
+void put_dma_page(void *dma_page)
+{
+	spin_lock(&lock);
+	*(void **)dma_page = dma_freelist;
+	dma_freelist = dma_page;
+	spin_unlock(&lock);
+}
+
+void *get_dma_page(void)
+{
+	void *p = NULL;
+
+	spin_lock(&lock);
+	if (!dma_freelist)
+		goto end_unlock;
+
+	p = dma_freelist;
+	dma_freelist = *(void **)dma_freelist;
+
+end_unlock:
+	spin_unlock(&lock);
+	return p;
+}
+
+phys_addr_t dma_page_alloc_init(phys_addr_t start, phys_addr_t end)
+{
+	int start_pfn = start >> PAGE_SHIFT;
+	int nb_pfn = ((end - start) >> PAGE_SHIFT) - 1;
+	int max, pfn;
+
+	max = start_pfn + nb_pfn / DMA_ALLOC_RATIO;
+	if (max > DMA_MAX_PFN)
+		max = DMA_MAX_PFN;
+
+	for (pfn = start_pfn; pfn < max; pfn++)
+		put_dma_page((void *)((unsigned long) pfn << PAGE_SHIFT));
+
+	return (phys_addr_t)pfn << PAGE_SHIFT;
+}
diff --git a/lib/alloc_dma_page.h b/lib/alloc_dma_page.h
new file mode 100644
index 0000000..85e1d2f
--- /dev/null
+++ b/lib/alloc_dma_page.h
@@ -0,0 +1,24 @@
+/*
+ * Page allocator for DMA definitions
+ *
+ * Copyright (c) IBM, Corp. 2020
+ *
+ * Authors:
+ *  Pierre Morel <pmorel@linux.ibm.com>
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Library General Public License version 2.
+ */
+#ifndef _ALLOC_DMA_PAGE_H_
+#define _ALLOC_DMA_PAGE_H_
+
+#include <asm/page.h>
+
+void put_dma_page(void *dma_page);
+void *get_dma_page(void);
+phys_addr_t dma_page_alloc_init(phys_addr_t start_pfn, phys_addr_t nb_pages);
+
+#define DMA_MAX_PFN	(0x80000000 >> PAGE_SHIFT)
+#define DMA_ALLOC_RATIO	8
+
+#endif /* _ALLOC_DMA_PAGE_H_ */
diff --git a/lib/s390x/sclp.c b/lib/s390x/sclp.c
index 4054d0e..9c95ca5 100644
--- a/lib/s390x/sclp.c
+++ b/lib/s390x/sclp.c
@@ -19,6 +19,7 @@
 #include "sclp.h"
 #include <alloc_phys.h>
 #include <alloc_page.h>
+#include <alloc_dma_page.h>
 
 extern unsigned long stacktop;
 
@@ -35,6 +36,7 @@ static void mem_init(phys_addr_t mem_end)
 	phys_addr_t freemem_start = (phys_addr_t)&stacktop;
 	phys_addr_t base, top;
 
+	freemem_start = dma_page_alloc_init(freemem_start, mem_end);
 	phys_alloc_init(freemem_start, mem_end - freemem_start);
 	phys_alloc_get_unused(&base, &top);
 	base = (base + PAGE_SIZE - 1) & -PAGE_SIZE;
diff --git a/s390x/Makefile b/s390x/Makefile
index 9144d57..109ef9f 100644
--- a/s390x/Makefile
+++ b/s390x/Makefile
@@ -52,6 +52,7 @@ cflatobjs += lib/alloc_phys.o
 cflatobjs += lib/alloc_page.o
 cflatobjs += lib/vmalloc.o
 cflatobjs += lib/alloc_phys.o
+cflatobjs += lib/alloc_dma_page.o
 cflatobjs += lib/s390x/io.o
 cflatobjs += lib/s390x/stack.o
 cflatobjs += lib/s390x/sclp.o
-- 
2.25.1

[kvm-unit-tests PATCH v2 2/4] s390x: pv: implement routine to share/unshare memory

[Pierre Morel]

When communicating with the host we need to share part of
the memory.

Let's implement the ultravisor calls for this.

Signed-off-by: Pierre Morel <pmorel@linux.ibm.com>
Suggested-by: Janosch Frank <frankja@linux.ibm.com>
---
 lib/s390x/asm/uv.h | 50 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 50 insertions(+)

diff --git a/lib/s390x/asm/uv.h b/lib/s390x/asm/uv.h
index 4c2fc48..f7690a2 100644
--- a/lib/s390x/asm/uv.h
+++ b/lib/s390x/asm/uv.h
@@ -71,4 +71,54 @@ static inline int uv_call(unsigned long r1, unsigned long r2)
 	return cc;
 }
 
+static inline int share(unsigned long addr, u16 cmd)
+{
+	struct uv_cb_share uvcb = {
+		.header.cmd = cmd,
+		.header.len = sizeof(uvcb),
+		.paddr = addr
+	};
+	int cc;
+
+	cc = uv_call(0, (u64)&uvcb);
+	if (!cc && (uvcb.header.rc == 0x0001))
+		return 0;
+
+	report(0, "cc %d response code: %04x", cc, uvcb.header.rc);
+	return -1;
+}
+
+/*
+ * Guest 2 request to the Ultravisor to make a page shared with the
+ * hypervisor for IO.
+ *
+ * @addr: Real or absolute address of the page to be shared
+ */
+static inline int uv_set_shared(unsigned long addr)
+{
+	int ret;
+
+	report_prefix_push("PV Set Shared access");
+	ret = share(addr, UVC_CMD_SET_SHARED_ACCESS);
+	report_prefix_pop();
+
+	return ret;
+}
+
+/*
+ * Guest 2 request to the Ultravisor to make a page unshared.
+ *
+ * @addr: Real or absolute address of the page to be unshared
+ */
+static inline int uv_remove_shared(unsigned long addr)
+{
+	int ret;
+
+	report_prefix_push("PV Remove Shared access");
+	ret = share(addr, UVC_CMD_REMOVE_SHARED_ACCESS);
+	report_prefix_pop();
+
+	return ret;
+}
+
 #endif
-- 
2.25.1

[kvm-unit-tests PATCH v2 3/4] s390x: define UV compatible I/O allocation

[Pierre Morel]

To centralize the memory allocation for I/O we define
the alloc/free_io_page() functions which share the I/O
memory with the host in case the guest runs with
protected virtualization.

Signed-off-by: Pierre Morel <pmorel@linux.ibm.com>
---
 lib/s390x/malloc_io.c | 49 +++++++++++++++++++++++++++++++++++++++++++
 lib/s390x/malloc_io.h | 18 ++++++++++++++++
 s390x/Makefile        |  1 +
 3 files changed, 68 insertions(+)
 create mode 100644 lib/s390x/malloc_io.c
 create mode 100644 lib/s390x/malloc_io.h

diff --git a/lib/s390x/malloc_io.c b/lib/s390x/malloc_io.c
new file mode 100644
index 0000000..388e568
--- /dev/null
+++ b/lib/s390x/malloc_io.c
@@ -0,0 +1,49 @@
+/*
+ * I/O page allocation
+ *
+ * Copyright (c) 2020 IBM Corp
+ *
+ * Authors:
+ *  Pierre Morel <pmorel@linux.ibm.com>
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2.
+ *
+ * Using this interface provide host access to the allocated pages in
+ * case the guest is a secure guest.
+ * This is needed for I/O buffers.
+ *
+ */
+#include <libcflat.h>
+#include <alloc_dma_page.h>
+#include <asm/uv.h>
+#include <malloc_io.h>
+#include <asm/facility.h>
+
+void *alloc_io_page(int size)
+{
+	void *p;
+
+	assert(size <= PAGE_SIZE);
+
+	p = get_dma_page();
+	if (!p)
+		return NULL;
+	memset(p, 0, PAGE_SIZE);
+
+	if (!test_facility(158))
+		return p;
+
+	if (uv_set_shared((unsigned long)p) == 0)
+		return p;
+
+	put_dma_page(p);
+	return NULL;
+}
+
+void free_io_page(void *p)
+{
+	if (test_facility(158))
+		uv_remove_shared((unsigned long)p);
+	put_dma_page(p);
+}
diff --git a/lib/s390x/malloc_io.h b/lib/s390x/malloc_io.h
new file mode 100644
index 0000000..c6ed481
--- /dev/null
+++ b/lib/s390x/malloc_io.h
@@ -0,0 +1,18 @@
+/*
+ * I/O allocations
+ *
+ * Copyright (c) 2020 IBM Corp
+ *
+ * Authors:
+ *  Pierre Morel <pmorel@linux.ibm.com>
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2.
+ */
+#ifndef _S390X_MALLOC_IO_H_
+#define _S390X_MALLOC_IO_H_
+
+void *alloc_io_page(int size);
+void free_io_page(void *p);
+
+#endif /* _S390X_MALLOC_IO_H_ */
diff --git a/s390x/Makefile b/s390x/Makefile
index 109ef9f..1b1dc9f 100644
--- a/s390x/Makefile
+++ b/s390x/Makefile
@@ -63,6 +63,7 @@ cflatobjs += lib/s390x/smp.o
 cflatobjs += lib/s390x/vm.o
 cflatobjs += lib/s390x/css_dump.o
 cflatobjs += lib/s390x/css_lib.o
+cflatobjs += lib/s390x/malloc_io.o
 
 OBJDIRS += lib/s390x
 
-- 
2.25.1

[kvm-unit-tests PATCH v2 4/4] s390x: css: pv: css test adaptation for PV

[Pierre Morel]

We want the tests to automatically work with or without protected
virtualisation.
To do this we need to share the I/O memory with the host.

Let's replace all static allocations with dynamic allocations
to clearly separate shared and private memory.

Signed-off-by: Pierre Morel <pmorel@linux.ibm.com>
---
 lib/s390x/css.h     |  3 +--
 lib/s390x/css_lib.c | 28 ++++++++--------------------
 s390x/css.c         | 35 ++++++++++++++++++++++++-----------
 3 files changed, 33 insertions(+), 33 deletions(-)

diff --git a/lib/s390x/css.h b/lib/s390x/css.h
index 221b67c..e3dee9f 100644
--- a/lib/s390x/css.h
+++ b/lib/s390x/css.h
@@ -283,8 +283,7 @@ int css_enable(int schid, int isc);
 
 /* Library functions */
 int start_ccw1_chain(unsigned int sid, struct ccw1 *ccw);
-int start_single_ccw(unsigned int sid, int code, void *data, int count,
-		     unsigned char flags);
+struct ccw1 *ccw_alloc(int code, void *data, int count, unsigned char flags);
 void css_irq_io(void);
 int css_residual_count(unsigned int schid);
 
diff --git a/lib/s390x/css_lib.c b/lib/s390x/css_lib.c
index 8e02371..6a0a0ec 100644
--- a/lib/s390x/css_lib.c
+++ b/lib/s390x/css_lib.c
@@ -18,6 +18,7 @@
 #include <asm/time.h>
 #include <asm/arch_def.h>
 
+#include <malloc_io.h>
 #include <css.h>
 
 static struct schib schib;
@@ -202,33 +203,20 @@ int start_ccw1_chain(unsigned int sid, struct ccw1 *ccw)
 	return ssch(sid, &orb);
 }
 
-/*
- * In the future, we want to implement support for CCW chains;
- * for that, we will need to work with ccw1 pointers.
- */
-static struct ccw1 unique_ccw;
-
-int start_single_ccw(unsigned int sid, int code, void *data, int count,
-		     unsigned char flags)
+struct ccw1 *ccw_alloc(int code, void *data, int count, unsigned char flags)
 {
-	int cc;
-	struct ccw1 *ccw = &unique_ccw;
+	struct ccw1 *ccw;
+
+	ccw = alloc_io_page(sizeof(*ccw));
+	if (!ccw)
+		return NULL;
 
-	report_prefix_push("start_subchannel");
-	/* Build the CCW chain with a single CCW */
 	ccw->code = code;
 	ccw->flags = flags;
 	ccw->count = count;
 	ccw->data_address = (int)(unsigned long)data;
 
-	cc = start_ccw1_chain(sid, ccw);
-	if (cc) {
-		report(0, "cc = %d", cc);
-		report_prefix_pop();
-		return cc;
-	}
-	report_prefix_pop();
-	return 0;
+	return ccw;
 }
 
 /* wait_and_check_io_completion:
diff --git a/s390x/css.c b/s390x/css.c
index ee3bc83..4b0b6b1 100644
--- a/s390x/css.c
+++ b/s390x/css.c
@@ -17,13 +17,15 @@
 #include <interrupt.h>
 #include <asm/arch_def.h>
 
+#include <malloc_io.h>
 #include <css.h>
+#include <asm/barrier.h>
 
 #define DEFAULT_CU_TYPE		0x3832 /* virtio-ccw */
 static unsigned long cu_type = DEFAULT_CU_TYPE;
 
 static int test_device_sid;
-static struct senseid senseid;
+static struct senseid *senseid;
 
 static void test_enumerate(void)
 {
@@ -57,6 +59,7 @@ static void test_enable(void)
  */
 static void test_sense(void)
 {
+	struct ccw1 *ccw;
 	int ret;
 	int len;
 
@@ -80,9 +83,15 @@ static void test_sense(void)
 
 	lowcore_ptr->io_int_param = 0;
 
-	memset(&senseid, 0, sizeof(senseid));
-	ret = start_single_ccw(test_device_sid, CCW_CMD_SENSE_ID,
-			       &senseid, sizeof(senseid), CCW_F_SLI);
+	senseid = alloc_io_page(sizeof(*senseid));
+	if (!senseid)
+		goto error_senseid;
+
+	ccw = ccw_alloc(CCW_CMD_SENSE_ID, senseid, sizeof(*senseid), CCW_F_SLI);
+	if (!ccw)
+		goto error_ccw;
+
+	ret = start_ccw1_chain(test_device_sid, ccw);
 	if (ret)
 		goto error;
 
@@ -97,7 +106,7 @@ static void test_sense(void)
 	if (ret < 0) {
 		report_info("no valid residual count");
 	} else if (ret != 0) {
-		len = sizeof(senseid) - ret;
+		len = sizeof(*senseid) - ret;
 		if (ret && len < CSS_SENSEID_COMMON_LEN) {
 			report(0, "transferred a too short length: %d", ret);
 			goto error;
@@ -105,21 +114,25 @@ static void test_sense(void)
 			report_info("transferred a shorter length: %d", len);
 	}
 
-	if (senseid.reserved != 0xff) {
-		report(0, "transferred garbage: 0x%02x", senseid.reserved);
+	if (senseid->reserved != 0xff) {
+		report(0, "transferred garbage: 0x%02x", senseid->reserved);
 		goto error;
 	}
 
 	report_prefix_pop();
 
 	report_info("reserved 0x%02x cu_type 0x%04x cu_model 0x%02x dev_type 0x%04x dev_model 0x%02x",
-		    senseid.reserved, senseid.cu_type, senseid.cu_model,
-		    senseid.dev_type, senseid.dev_model);
+		    senseid->reserved, senseid->cu_type, senseid->cu_model,
+		    senseid->dev_type, senseid->dev_model);
 
-	report(senseid.cu_type == cu_type, "cu_type expected 0x%04x got 0x%04x",
-	       (uint16_t) cu_type, senseid.cu_type);
+	report(senseid->cu_type == cu_type, "cu_type expected 0x%04x got 0x%04x",
+	       (uint16_t) cu_type, senseid->cu_type);
 
 error:
+	free_io_page(ccw);
+error_ccw:
+	free_io_page(senseid);
+error_senseid:
 	unregister_io_int_func(css_irq_io);
 }
 
-- 
2.25.1

Re: [kvm-unit-tests PATCH v2 1/4] memory: allocation in low memory

[Cornelia Huck]

On Mon, 28 Sep 2020 16:23:34 +0200
Pierre Morel <pmorel@linux.ibm.com> wrote:

> Some architectures need allocations to be done under a
> specific address limit to allow DMA from I/O.
> 
> We propose here a very simple page allocator to get
> pages allocated under this specific limit.
> 
> The DMA page allocator will only use part of the available memory
> under the DMA address limit to let room for the standard allocator.
> 
> Signed-off-by: Pierre Morel <pmorel@linux.ibm.com>
> ---
>  lib/alloc_dma_page.c | 57 ++++++++++++++++++++++++++++++++++++++++++++
>  lib/alloc_dma_page.h | 24 +++++++++++++++++++
>  lib/s390x/sclp.c     |  2 ++
>  s390x/Makefile       |  1 +
>  4 files changed, 84 insertions(+)
>  create mode 100644 lib/alloc_dma_page.c
>  create mode 100644 lib/alloc_dma_page.h

(...)

> diff --git a/lib/alloc_dma_page.h b/lib/alloc_dma_page.h
> new file mode 100644
> index 0000000..85e1d2f
> --- /dev/null
> +++ b/lib/alloc_dma_page.h
> @@ -0,0 +1,24 @@
> +/*
> + * Page allocator for DMA definitions
> + *
> + * Copyright (c) IBM, Corp. 2020
> + *
> + * Authors:
> + *  Pierre Morel <pmorel@linux.ibm.com>
> + *
> + * This code is free software; you can redistribute it and/or modify it
> + * under the terms of the GNU Library General Public License version 2.
> + */
> +#ifndef _ALLOC_DMA_PAGE_H_
> +#define _ALLOC_DMA_PAGE_H_
> +
> +#include <asm/page.h>
> +
> +void put_dma_page(void *dma_page);
> +void *get_dma_page(void);
> +phys_addr_t dma_page_alloc_init(phys_addr_t start_pfn, phys_addr_t nb_pages);
> +
> +#define DMA_MAX_PFN	(0x80000000 >> PAGE_SHIFT)
> +#define DMA_ALLOC_RATIO	8

Hm, shouldn't the architecture be able to decide where a dma page can
be located? Or am I misunderstanding?

> +
> +#endif /* _ALLOC_DMA_PAGE_H_ */
(...)

Re: [kvm-unit-tests PATCH v2 1/4] memory: allocation in low memory

[Janosch Frank]

[-- Attachment #1.1: Type: text/plain, Size: 2145 bytes --]

On 9/28/20 5:31 PM, Cornelia Huck wrote:
> On Mon, 28 Sep 2020 16:23:34 +0200
> Pierre Morel <pmorel@linux.ibm.com> wrote:
> 
>> Some architectures need allocations to be done under a
>> specific address limit to allow DMA from I/O.
>>
>> We propose here a very simple page allocator to get
>> pages allocated under this specific limit.
>>
>> The DMA page allocator will only use part of the available memory
>> under the DMA address limit to let room for the standard allocator.
>>
>> Signed-off-by: Pierre Morel <pmorel@linux.ibm.com>
>> ---
>>  lib/alloc_dma_page.c | 57 ++++++++++++++++++++++++++++++++++++++++++++
>>  lib/alloc_dma_page.h | 24 +++++++++++++++++++
>>  lib/s390x/sclp.c     |  2 ++
>>  s390x/Makefile       |  1 +
>>  4 files changed, 84 insertions(+)
>>  create mode 100644 lib/alloc_dma_page.c
>>  create mode 100644 lib/alloc_dma_page.h
> 
> (...)
> 
>> diff --git a/lib/alloc_dma_page.h b/lib/alloc_dma_page.h
>> new file mode 100644
>> index 0000000..85e1d2f
>> --- /dev/null
>> +++ b/lib/alloc_dma_page.h
>> @@ -0,0 +1,24 @@
>> +/*
>> + * Page allocator for DMA definitions
>> + *
>> + * Copyright (c) IBM, Corp. 2020
>> + *
>> + * Authors:
>> + *  Pierre Morel <pmorel@linux.ibm.com>
>> + *
>> + * This code is free software; you can redistribute it and/or modify it
>> + * under the terms of the GNU Library General Public License version 2.
>> + */
>> +#ifndef _ALLOC_DMA_PAGE_H_
>> +#define _ALLOC_DMA_PAGE_H_
>> +
>> +#include <asm/page.h>
>> +
>> +void put_dma_page(void *dma_page);
>> +void *get_dma_page(void);
>> +phys_addr_t dma_page_alloc_init(phys_addr_t start_pfn, phys_addr_t nb_pages);
>> +
>> +#define DMA_MAX_PFN	(0x80000000 >> PAGE_SHIFT)
>> +#define DMA_ALLOC_RATIO	8
> 
> Hm, shouldn't the architecture be able to decide where a dma page can
> be located? Or am I misunderstanding?

Before we start any other discussion on this patch we should clear up if
this is still necessary after Claudio's alloc revamp.

I think he added options to request special types of memory.

> 
>> +
>> +#endif /* _ALLOC_DMA_PAGE_H_ */
> (...)
> 



[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 833 bytes --]

Re: [kvm-unit-tests PATCH v2 2/4] s390x: pv: implement routine to share/unshare memory

[Cornelia Huck]

On Mon, 28 Sep 2020 16:23:35 +0200
Pierre Morel <pmorel@linux.ibm.com> wrote:

> When communicating with the host we need to share part of
> the memory.
> 
> Let's implement the ultravisor calls for this.
> 
> Signed-off-by: Pierre Morel <pmorel@linux.ibm.com>
> Suggested-by: Janosch Frank <frankja@linux.ibm.com>
> ---
>  lib/s390x/asm/uv.h | 50 ++++++++++++++++++++++++++++++++++++++++++++++
>  1 file changed, 50 insertions(+)

Acked-by: Cornelia Huck <cohuck@redhat.com>

Re: [kvm-unit-tests PATCH v2 1/4] memory: allocation in low memory

[Pierre Morel]

On 9/29/20 9:19 AM, Janosch Frank wrote:
> On 9/28/20 5:31 PM, Cornelia Huck wrote:
>> On Mon, 28 Sep 2020 16:23:34 +0200
>> Pierre Morel <pmorel@linux.ibm.com> wrote:
>>
>>> Some architectures need allocations to be done under a
>>> specific address limit to allow DMA from I/O.
>>>
>>> We propose here a very simple page allocator to get
>>> pages allocated under this specific limit.
>>>
>>> The DMA page allocator will only use part of the available memory
>>> under the DMA address limit to let room for the standard allocator.
>>>

...snip...

> 
> Before we start any other discussion on this patch we should clear up if
> this is still necessary after Claudio's alloc revamp.
> 
> I think he added options to request special types of memory.

Isn't it possible to go on with this patch series.
It can be adapted later to the changes that will be introduced by 
Claudio when it is final.


-- 
Pierre Morel
IBM Lab Boeblingen

Re: [kvm-unit-tests PATCH v2 1/4] memory: allocation in low memory

[Janosch Frank]

On 11/5/20 1:16 PM, Pierre Morel wrote:
> 
> 
> On 9/29/20 9:19 AM, Janosch Frank wrote:
>> On 9/28/20 5:31 PM, Cornelia Huck wrote:
>>> On Mon, 28 Sep 2020 16:23:34 +0200
>>> Pierre Morel <pmorel@linux.ibm.com> wrote:
>>>
>>>> Some architectures need allocations to be done under a
>>>> specific address limit to allow DMA from I/O.
>>>>
>>>> We propose here a very simple page allocator to get
>>>> pages allocated under this specific limit.
>>>>
>>>> The DMA page allocator will only use part of the available memory
>>>> under the DMA address limit to let room for the standard allocator.
>>>>
> 
> ...snip...
> 
>>
>> Before we start any other discussion on this patch we should clear up if
>> this is still necessary after Claudio's alloc revamp.
>>
>> I think he added options to request special types of memory.
> 
> Isn't it possible to go on with this patch series.
> It can be adapted later to the changes that will be introduced by 
> Claudio when it is final.
> 
> 

Pierre, that's outside of my jurisdiction, you're adding code to the
common code library.

I've set Paolo CC, let's see if he finds this thread :)

Re: [kvm-unit-tests PATCH v2 1/4] memory: allocation in low memory

[Andrew Jones]

On Thu, Nov 05, 2020 at 03:15:47PM +0100, Janosch Frank wrote:
> On 11/5/20 1:16 PM, Pierre Morel wrote:
> > 
> > 
> > On 9/29/20 9:19 AM, Janosch Frank wrote:
> >> On 9/28/20 5:31 PM, Cornelia Huck wrote:
> >>> On Mon, 28 Sep 2020 16:23:34 +0200
> >>> Pierre Morel <pmorel@linux.ibm.com> wrote:
> >>>
> >>>> Some architectures need allocations to be done under a
> >>>> specific address limit to allow DMA from I/O.
> >>>>
> >>>> We propose here a very simple page allocator to get
> >>>> pages allocated under this specific limit.
> >>>>
> >>>> The DMA page allocator will only use part of the available memory
> >>>> under the DMA address limit to let room for the standard allocator.
> >>>>
> > 
> > ...snip...
> > 
> >>
> >> Before we start any other discussion on this patch we should clear up if
> >> this is still necessary after Claudio's alloc revamp.
> >>
> >> I think he added options to request special types of memory.
> > 
> > Isn't it possible to go on with this patch series.
> > It can be adapted later to the changes that will be introduced by 
> > Claudio when it is final.
> > 
> > 
> 
> Pierre, that's outside of my jurisdiction, you're adding code to the
> common code library.
> 
> I've set Paolo CC, let's see if he finds this thread :)
>

I'll also try to find some time to revisit this.

Thanks,
drew 

Re: [kvm-unit-tests PATCH v2 1/4] memory: allocation in low memory

[Paolo Bonzini]

On 05/11/20 15:15, Janosch Frank wrote:
>> Isn't it possible to go on with this patch series.
>> It can be adapted later to the changes that will be introduced by
>> Claudio when it is final.
>>
>>
> Pierre, that's outside of my jurisdiction, you're adding code to the
> common code library.
> 
> I've set Paolo CC, let's see if he finds this thread:)
> 

I have queued Claudio's series already, so let's start from there.

Paolo

Re: [kvm-unit-tests PATCH v2 1/4] memory: allocation in low memory

[Pierre Morel]

On 11/6/20 2:25 PM, Paolo Bonzini wrote:
> On 05/11/20 15:15, Janosch Frank wrote:
>>> Isn't it possible to go on with this patch series.
>>> It can be adapted later to the changes that will be introduced by
>>> Claudio when it is final.
>>>
>>>
>> Pierre, that's outside of my jurisdiction, you're adding code to the
>> common code library.
>>
>> I've set Paolo CC, let's see if he finds this thread:)
>>
> 
> I have queued Claudio's series already, so let's start from there.
> 
> Paolo
> 

OK, thanks

Pierre

-- 
Pierre Morel
IBM Lab Boeblingen