Skip to contentSkip to conversation

mmap_vmcore: skip non-ram pages reported by hypervisors

PATCH In review Vitaly Kuznetsov 6 participants 21 messages Jul 7, 2014 – Jul 9, 2014

Subsystems (2)
lore
Share & tools
lore
#0 lore raw

PATCH 1/1 mmap_vmcore: skip non-ram pages reported by hypervisors

we have a special check in read_vmcore() handler to check if the page was reported as ram or not by the hypervisor (pfn_is_ram()). However, when vmcore is read with mmap() no such check is performed. That can lead to unpredictable results, e.g. when running Xen PVHVM guest memcpy() after mmap() on /proc/vmcore will hang processing HVMMEM_mmio_dm pages creating enormous load in both DomU and Dom0.

Fix the issue by mapping each non-ram page to the zero page. Keep direct path with remap_oldmem_pfn_range() to avoid looping through all pages on bare metal.

The issue can also be solved by overriding remap_oldmem_pfn_range() in xen-specific code, as remap_oldmem_pfn_range() was been designed for. That, however, would involve non-obvious xen code path for all x86 builds with CONFIG_XEN_PVHVM=y and would prevent all other hypervisor-specific code on x86 arch from doing the same override.

---
 fs/proc/vmcore.c | 68 +++++++++++++++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 62 insertions(+), 6 deletions(-)
fs/proc/vmcore.c +62 -6
index 382aa89..2716e19 100644
@@ -328,6 +328,46 @@ static inline char *alloc_elfnotes_buf(size_t notes_sz)
  * virtually contiguous user-space in ELF layout.
  */
 #ifdef CONFIG_MMU
+static u64 remap_oldmem_pfn_checked(struct vm_area_struct *vma, u64 len,
+				    unsigned long pfn, unsigned long page_count)
+{
+	unsigned long pos;
+	size_t size;
+	unsigned long vma_addr;
+	unsigned long emptypage_pfn = __pa(empty_zero_page) >> PAGE_SHIFT;
+
+	for (pos = pfn; (pos - pfn) <= page_count; pos++) {
+		if (!pfn_is_ram(pos) || (pos - pfn) == page_count) {
+			/* we hit a page which is not ram or reached the end */
+			if (pos - pfn > 0) {
+				/* remapping continuous region */
+				size = (pos - pfn) << PAGE_SHIFT;
+				vma_addr = vma->vm_start + len;
+				if (remap_oldmem_pfn_range(vma, vma_addr,
+							   pfn, size,
+							   vma->vm_page_prot))
+					return len;
+				len += size;
+				page_count -= (pos - pfn);
+			}
+			if (page_count > 0) {
+				/* we hit a page which is not ram, replacing
+				   with an empty one */
+				vma_addr = vma->vm_start + len;
+				if (remap_oldmem_pfn_range(vma, vma_addr,
+							   emptypage_pfn,
+							   PAGE_SIZE,
+							   vma->vm_page_prot))
+					return len;
+				len += PAGE_SIZE;
+				pfn = pos + 1;
+				page_count--;
+			}
+		}
+	}
+	return len;
+}
+
 static int mmap_vmcore(struct file *file, struct vm_area_struct *vma)
 {
 	size_t size = vma->vm_end - vma->vm_start;
@@ -383,17 +423,33 @@ static int mmap_vmcore(struct file *file, struct vm_area_struct *vma)
 
 	list_for_each_entry(m, &vmcore_list, list) {
 		if (start < m->offset + m->size) {
-			u64 paddr = 0;
+			u64 paddr = 0, original_len;
+			unsigned long pfn, page_count;
 
 			tsz = min_t(size_t, m->offset + m->size - start, size);
 			paddr = m->paddr + start - m->offset;
-			if (remap_oldmem_pfn_range(vma, vma->vm_start + len,
-						   paddr >> PAGE_SHIFT, tsz,
-						   vma->vm_page_prot))
-				goto fail;
+
+			/* check if oldmem_pfn_is_ram was registered to avoid
+			   looping over all pages without a reason */
+			if (oldmem_pfn_is_ram) {
+				pfn = paddr >> PAGE_SHIFT;
+				page_count = tsz >> PAGE_SHIFT;
+				original_len = len;
+				len = remap_oldmem_pfn_checked(vma, len, pfn,
+							       page_count);
+				if (len != original_len + tsz)
+					goto fail;
+			} else {
+				if (remap_oldmem_pfn_range(vma,
+							   vma->vm_start + len,
+							   paddr >> PAGE_SHIFT,
+							   tsz,
+							   vma->vm_page_prot))
+					goto fail;
+				len += tsz;
+			}
 			size -= tsz;
 			start += tsz;
-			len += tsz;
 
 			if (size == 0)
 				return 0;
Signature · 1 line
1.9.3
maintainer
#1 lore raw
Quoted 11 lines · On Mon, 7 Jul 2014 17:05:49 +0200 Vitaly Kuznetsov <[email protected]> wrote:

we have a special check in read_vmcore() handler to check if the page was reported as ram or not by the hypervisor (pfn_is_ram()). However, when vmcore is read with mmap() no such check is performed. That can lead to unpredictable results, e.g. when running Xen PVHVM guest memcpy() after mmap() on /proc/vmcore will hang processing HVMMEM_mmio_dm pages creating enormous load in both DomU and Dom0.

Fix the issue by mapping each non-ram page to the zero page. Keep direct path with remap_oldmem_pfn_range() to avoid looping through all pages on bare metal.

Quoted 5 lines

The issue can also be solved by overriding remap_oldmem_pfn_range() in xen-specific code, as remap_oldmem_pfn_range() was been designed for. That, however, would involve non-obvious xen code path for all x86 builds with CONFIG_XEN_PVHVM=y and would prevent all other hypervisor-specific code on x86 arch from doing the same override.

I'd like to get some reviewed-by's and tested-by's on this one please.

fs/proc/vmcore.c static inline char *alloc_elfnotes_buf(size_t notes_sz) · line 337

Quoted 13 lines
fs/proc/vmcore.c +7 -0
@@ -328,6 +328,46 @@ static inline char *alloc_elfnotes_buf(size_t notes_sz)
  * virtually contiguous user-space in ELF layout.
  */
 #ifdef CONFIG_MMU
+static u64 remap_oldmem_pfn_checked(struct vm_area_struct *vma, u64 len,
+				    unsigned long pfn, unsigned long page_count)
+{
+	unsigned long pos;
+	size_t size;
+	unsigned long vma_addr;
+	unsigned long emptypage_pfn = __pa(empty_zero_page) >> PAGE_SHIFT;

That's old-school. Can we use my_zero_pfn() here?

Also, "zeropage_pfn" is a better name - let's not introduce the hitherto unknown concept of an "empty page".

Quoted 7 lines
fs/proc/vmcore.c +7 -0
+	for (pos = pfn; (pos - pfn) <= page_count; pos++) {
+		if (!pfn_is_ram(pos) || (pos - pfn) == page_count) {
+			/* we hit a page which is not ram or reached the end */
+			if (pos - pfn > 0) {
+				/* remapping continuous region */
+				size = (pos - pfn) << PAGE_SHIFT;
+				vma_addr = vma->vm_start + len;

fs/proc/vmcore.c static inline char *alloc_elfnotes_buf(size_t notes_sz) · line 355

Quoted 10 lines
fs/proc/vmcore.c +10 -0
+				if (remap_oldmem_pfn_range(vma, vma_addr,
+							   pfn, size,
+							   vma->vm_page_prot))
+					return len;
+				len += size;
+				page_count -= (pos - pfn);
+			}
+			if (page_count > 0) {
+				/* we hit a page which is not ram, replacing
+				   with an empty one */

I suggest

				/*
				 * We hit a page which is not ram.  Replace it
				 * with the zero page.
				 */
Quoted 4 lines
fs/proc/vmcore.c +4 -0
+				vma_addr = vma->vm_start + len;
+				if (remap_oldmem_pfn_range(vma, vma_addr,
+							   emptypage_pfn,
+							   PAGE_SIZE,

fs/proc/vmcore.c static inline char *alloc_elfnotes_buf(size_t notes_sz) · line 369

Quoted 10 lines
fs/proc/vmcore.c +10 -0
+							   vma->vm_page_prot))
+					return len;
+				len += PAGE_SIZE;
+				pfn = pos + 1;
+				page_count--;
+			}
+		}
+	}
+	return len;
+}

Also, this loop seems unnecessarily hard to follow. It *look* like the `for' statement has an off-by-one because of the "<=", but page_count is mofidied inside the loop! Despite it being an incoming formal argument.

None of this is made any easier by the function's lack of documentation. Some description of the incoming args would help, along with an overall description of the function's responsibilities.

That being said, can't we just do something nice and simple like

	pos = pfn;
	while (pos < pfn + page_count) {
		stuff which advances `pos'
	}

?

Quoted 10 lines
fs/proc/vmcore.c +2 -1
 static int mmap_vmcore(struct file *file, struct vm_area_struct *vma)
 {
 	size_t size = vma->vm_end - vma->vm_start;
@@ -383,17 +423,33 @@ static int mmap_vmcore(struct file *file, struct vm_area_struct *vma)
 
 	list_for_each_entry(m, &vmcore_list, list) {
 		if (start < m->offset + m->size) {
-			u64 paddr = 0;
+			u64 paddr = 0, original_len;
+			unsigned long pfn, page_count;

fs/proc/vmcore.c static int mmap_vmcore(struct file *file, struct vm_area_struct *vma) · line 433

Quoted 10 lines
fs/proc/vmcore.c +3 -4
 
 			tsz = min_t(size_t, m->offset + m->size - start, size);
 			paddr = m->paddr + start - m->offset;
-			if (remap_oldmem_pfn_range(vma, vma->vm_start + len,
-						   paddr >> PAGE_SHIFT, tsz,
-						   vma->vm_page_prot))
-				goto fail;
+
+			/* check if oldmem_pfn_is_ram was registered to avoid
+			   looping over all pages without a reason */

Please lay out the comments in the usual fashion:

	/*
	 * ...
	 * ..
	 */

And sentences start whith upper-case letters!

Quoted 23 lines
fs/proc/vmcore.c +17 -1
+			if (oldmem_pfn_is_ram) {
+				pfn = paddr >> PAGE_SHIFT;
+				page_count = tsz >> PAGE_SHIFT;
+				original_len = len;
+				len = remap_oldmem_pfn_checked(vma, len, pfn,
+							       page_count);
+				if (len != original_len + tsz)
+					goto fail;
+			} else {
+				if (remap_oldmem_pfn_range(vma,
+							   vma->vm_start + len,
+							   paddr >> PAGE_SHIFT,
+							   tsz,
+							   vma->vm_page_prot))
+					goto fail;
+				len += tsz;
+			}
 			size -= tsz;
 			start += tsz;
-			len += tsz;
 
 			if (size == 0)
 				return 0;
#2 lore raw
Quoted 13 lines · Andrew Morton
Quoted 11 lines · On Mon, 7 Jul 2014 17:05:49 +0200 Vitaly Kuznetsov <[email protected]> wrote:

we have a special check in read_vmcore() handler to check if the page was reported as ram or not by the hypervisor (pfn_is_ram()). However, when vmcore is read with mmap() no such check is performed. That can lead to unpredictable results, e.g. when running Xen PVHVM guest memcpy() after mmap() on /proc/vmcore will hang processing HVMMEM_mmio_dm pages creating enormous load in both DomU and Dom0.

Fix the issue by mapping each non-ram page to the zero page. Keep direct path with remap_oldmem_pfn_range() to avoid looping through all pages on bare metal.

Quoted 8 lines
Quoted 5 lines

The issue can also be solved by overriding remap_oldmem_pfn_range() in xen-specific code, as remap_oldmem_pfn_range() was been designed for. That, however, would involve non-obvious xen code path for all x86 builds with CONFIG_XEN_PVHVM=y and would prevent all other hypervisor-specific code on x86 arch from doing the same override.

I'd like to get some reviewed-by's and tested-by's on this one please.

This patch can be tested with Xen PVHVM guest only as it is the only platform which registers oldmem_pfn_is_ram atm.

Quoted 16 lines

fs/proc/vmcore.c static inline char *alloc_elfnotes_buf(size_t notes_sz) · line 337

Quoted 13 lines
fs/proc/vmcore.c +7 -0
@@ -328,6 +328,46 @@ static inline char *alloc_elfnotes_buf(size_t notes_sz)
  * virtually contiguous user-space in ELF layout.
  */
 #ifdef CONFIG_MMU
+static u64 remap_oldmem_pfn_checked(struct vm_area_struct *vma, u64 len,
+				    unsigned long pfn, unsigned long page_count)
+{
+	unsigned long pos;
+	size_t size;
+	unsigned long vma_addr;
+	unsigned long emptypage_pfn = __pa(empty_zero_page) >> PAGE_SHIFT;

That's old-school. Can we use my_zero_pfn() here?

Quoted 3 lines

Also, "zeropage_pfn" is a better name - let's not introduce the hitherto unknown concept of an "empty page".

Sure!

Quoted 20 lines
Quoted 7 lines
fs/proc/vmcore.c +7 -0
+	for (pos = pfn; (pos - pfn) <= page_count; pos++) {
+		if (!pfn_is_ram(pos) || (pos - pfn) == page_count) {
+			/* we hit a page which is not ram or reached the end */
+			if (pos - pfn > 0) {
+				/* remapping continuous region */
+				size = (pos - pfn) << PAGE_SHIFT;
+				vma_addr = vma->vm_start + len;

fs/proc/vmcore.c static inline char *alloc_elfnotes_buf(size_t notes_sz) · line 355

Quoted 10 lines
fs/proc/vmcore.c +10 -0
+				if (remap_oldmem_pfn_range(vma, vma_addr,
+							   pfn, size,
+							   vma->vm_page_prot))
+					return len;
+				len += size;
+				page_count -= (pos - pfn);
+			}
+			if (page_count > 0) {
+				/* we hit a page which is not ram, replacing
+				   with an empty one */

I suggest

Quoted 5 lines
				/*
				 * We hit a page which is not ram.  Replace it
				 * with the zero page.
				 */

:-)

Quoted 11 lines
Quoted 11 lines
fs/proc/vmcore.c +11 -0
+				vma_addr = vma->vm_start + len;
+				if (remap_oldmem_pfn_range(vma, vma_addr,
+							   emptypage_pfn,
+							   PAGE_SIZE,
+							   vma->vm_page_prot))
+					return len;
+				len += PAGE_SIZE;
+				pfn = pos + 1;
+				page_count--;
+			}
+		}
Quoted 8 lines

fs/proc/vmcore.c static inline char *alloc_elfnotes_buf(size_t notes_sz) · line 365

Quoted 3 lines
fs/proc/vmcore.c +3 -0
+	}
+	return len;
+}

Also, this loop seems unnecessarily hard to follow. It *look* like the `for' statement has an off-by-one because of the "<=", but page_count is mofidied inside the loop! Despite it being an incoming formal argument.

There is no off-by-one error here (I believe) as I'm checking two possible conditions to remap the continuous region:
1) We hit a non-ram page
2) We reached the end
so we exclude the page pos is pointing us to in both cases.

I tried to avoid code duplication e.g. having one 'remap continuous region' inside the loop to do the remapping when we hit a non-ram page and having the other one outside the loop to remap the tail.

Quoted 5 lines

None of this is made any easier by the function's lack of documentation. Some description of the incoming args would help, along with an overall description of the function's responsibilities.

Quoted 9 lines

That being said, can't we just do something nice and simple like

	pos = pfn;
	while (pos < pfn + page_count) {
		stuff which advances `pos'
	}

?

I completely agree it's possible to make this code easier to understand, will do.

Quoted 51 lines
Quoted 10 lines
fs/proc/vmcore.c +2 -1
 static int mmap_vmcore(struct file *file, struct vm_area_struct *vma)
 {
 	size_t size = vma->vm_end - vma->vm_start;
@@ -383,17 +423,33 @@ static int mmap_vmcore(struct file *file, struct vm_area_struct *vma)
 
 	list_for_each_entry(m, &vmcore_list, list) {
 		if (start < m->offset + m->size) {
-			u64 paddr = 0;
+			u64 paddr = 0, original_len;
+			unsigned long pfn, page_count;

fs/proc/vmcore.c static int mmap_vmcore(struct file *file, struct vm_area_struct *vma) · line 433

Quoted 10 lines
fs/proc/vmcore.c +3 -4
 
 			tsz = min_t(size_t, m->offset + m->size - start, size);
 			paddr = m->paddr + start - m->offset;
-			if (remap_oldmem_pfn_range(vma, vma->vm_start + len,
-						   paddr >> PAGE_SHIFT, tsz,
-						   vma->vm_page_prot))
-				goto fail;
+
+			/* check if oldmem_pfn_is_ram was registered to avoid
+			   looping over all pages without a reason */

Please lay out the comments in the usual fashion:

	/*
	 * ...
	 * ..
	 */

And sentences start whith upper-case letters!

Quoted 21 lines
fs/proc/vmcore.c +17 -1
+			if (oldmem_pfn_is_ram) {
+				pfn = paddr >> PAGE_SHIFT;
+				page_count = tsz >> PAGE_SHIFT;
+				original_len = len;
+				len = remap_oldmem_pfn_checked(vma, len, pfn,
+							       page_count);
+				if (len != original_len + tsz)
+					goto fail;
+			} else {
+				if (remap_oldmem_pfn_range(vma,
+							   vma->vm_start + len,
+							   paddr >> PAGE_SHIFT,
+							   tsz,
+							   vma->vm_page_prot))
+					goto fail;
+				len += tsz;
+			}
 			size -= tsz;
 			start += tsz;
-			len += tsz;
 
Quoted 2 lines

fs/proc/vmcore.c static int mmap_vmcore(struct file *file, struct vm_area_struct *vma) · line 455

Quoted 2 lines
fs/proc/vmcore.c +0 -0
 			if (size == 0)
 				return 0;

Thank you very much for your review! I'm working on v2.

Signature · 1 line
  Vitaly
#3 lore raw
In reply to Andrew Morton
Quoted 13 lines · Andrew Morton
Quoted 11 lines · On Mon, 7 Jul 2014 17:05:49 +0200 Vitaly Kuznetsov <[email protected]> wrote:

we have a special check in read_vmcore() handler to check if the page was reported as ram or not by the hypervisor (pfn_is_ram()). However, when vmcore is read with mmap() no such check is performed. That can lead to unpredictable results, e.g. when running Xen PVHVM guest memcpy() after mmap() on /proc/vmcore will hang processing HVMMEM_mmio_dm pages creating enormous load in both DomU and Dom0.

Fix the issue by mapping each non-ram page to the zero page. Keep direct path with remap_oldmem_pfn_range() to avoid looping through all pages on bare metal.

Quoted 8 lines
Quoted 5 lines

The issue can also be solved by overriding remap_oldmem_pfn_range() in xen-specific code, as remap_oldmem_pfn_range() was been designed for. That, however, would involve non-obvious xen code path for all x86 builds with CONFIG_XEN_PVHVM=y and would prevent all other hypervisor-specific code on x86 arch from doing the same override.

I'd like to get some reviewed-by's and tested-by's on this one please.

This patch can be tested with Xen PVHVM guest only as it is the only platform which registers oldmem_pfn_is_ram atm.

Quoted 16 lines

fs/proc/vmcore.c static inline char *alloc_elfnotes_buf(size_t notes_sz) · line 337

Quoted 13 lines
fs/proc/vmcore.c +7 -0
@@ -328,6 +328,46 @@ static inline char *alloc_elfnotes_buf(size_t notes_sz)
  * virtually contiguous user-space in ELF layout.
  */
 #ifdef CONFIG_MMU
+static u64 remap_oldmem_pfn_checked(struct vm_area_struct *vma, u64 len,
+				    unsigned long pfn, unsigned long page_count)
+{
+	unsigned long pos;
+	size_t size;
+	unsigned long vma_addr;
+	unsigned long emptypage_pfn = __pa(empty_zero_page) >> PAGE_SHIFT;

That's old-school. Can we use my_zero_pfn() here?

Quoted 3 lines

Also, "zeropage_pfn" is a better name - let's not introduce the hitherto unknown concept of an "empty page".

Sure!

Quoted 20 lines
Quoted 7 lines
fs/proc/vmcore.c +7 -0
+	for (pos = pfn; (pos - pfn) <= page_count; pos++) {
+		if (!pfn_is_ram(pos) || (pos - pfn) == page_count) {
+			/* we hit a page which is not ram or reached the end */
+			if (pos - pfn > 0) {
+				/* remapping continuous region */
+				size = (pos - pfn) << PAGE_SHIFT;
+				vma_addr = vma->vm_start + len;

fs/proc/vmcore.c static inline char *alloc_elfnotes_buf(size_t notes_sz) · line 355

Quoted 10 lines
fs/proc/vmcore.c +10 -0
+				if (remap_oldmem_pfn_range(vma, vma_addr,
+							   pfn, size,
+							   vma->vm_page_prot))
+					return len;
+				len += size;
+				page_count -= (pos - pfn);
+			}
+			if (page_count > 0) {
+				/* we hit a page which is not ram, replacing
+				   with an empty one */

I suggest

Quoted 5 lines
				/*
				 * We hit a page which is not ram.  Replace it
				 * with the zero page.
				 */

:-)

Quoted 11 lines
Quoted 11 lines
fs/proc/vmcore.c +11 -0
+				vma_addr = vma->vm_start + len;
+				if (remap_oldmem_pfn_range(vma, vma_addr,
+							   emptypage_pfn,
+							   PAGE_SIZE,
+							   vma->vm_page_prot))
+					return len;
+				len += PAGE_SIZE;
+				pfn = pos + 1;
+				page_count--;
+			}
+		}
Quoted 8 lines

fs/proc/vmcore.c static inline char *alloc_elfnotes_buf(size_t notes_sz) · line 365

Quoted 3 lines
fs/proc/vmcore.c +3 -0
+	}
+	return len;
+}

Also, this loop seems unnecessarily hard to follow. It *look* like the `for' statement has an off-by-one because of the "<=", but page_count is mofidied inside the loop! Despite it being an incoming formal argument.

There is no off-by-one error here (I believe) as I'm checking two possible conditions to remap the continuous region:
1) We hit a non-ram page
2) We reached the end
so we exclude the page pos is pointing us to in both cases.

I tried to avoid code duplication e.g. having one 'remap continuous region' inside the loop to do the remapping when we hit a non-ram page and having the other one outside the loop to remap the tail.

Quoted 5 lines

None of this is made any easier by the function's lack of documentation. Some description of the incoming args would help, along with an overall description of the function's responsibilities.

Quoted 9 lines

That being said, can't we just do something nice and simple like

	pos = pfn;
	while (pos < pfn + page_count) {
		stuff which advances `pos'
	}

?

I completely agree it's possible to make this code easier to understand, will do.

Quoted 51 lines
Quoted 10 lines
fs/proc/vmcore.c +2 -1
 static int mmap_vmcore(struct file *file, struct vm_area_struct *vma)
 {
 	size_t size = vma->vm_end - vma->vm_start;
@@ -383,17 +423,33 @@ static int mmap_vmcore(struct file *file, struct vm_area_struct *vma)
 
 	list_for_each_entry(m, &vmcore_list, list) {
 		if (start < m->offset + m->size) {
-			u64 paddr = 0;
+			u64 paddr = 0, original_len;
+			unsigned long pfn, page_count;

fs/proc/vmcore.c static int mmap_vmcore(struct file *file, struct vm_area_struct *vma) · line 433

Quoted 10 lines
fs/proc/vmcore.c +3 -4
 
 			tsz = min_t(size_t, m->offset + m->size - start, size);
 			paddr = m->paddr + start - m->offset;
-			if (remap_oldmem_pfn_range(vma, vma->vm_start + len,
-						   paddr >> PAGE_SHIFT, tsz,
-						   vma->vm_page_prot))
-				goto fail;
+
+			/* check if oldmem_pfn_is_ram was registered to avoid
+			   looping over all pages without a reason */

Please lay out the comments in the usual fashion:

	/*
	 * ...
	 * ..
	 */

And sentences start whith upper-case letters!

Quoted 21 lines
fs/proc/vmcore.c +17 -1
+			if (oldmem_pfn_is_ram) {
+				pfn = paddr >> PAGE_SHIFT;
+				page_count = tsz >> PAGE_SHIFT;
+				original_len = len;
+				len = remap_oldmem_pfn_checked(vma, len, pfn,
+							       page_count);
+				if (len != original_len + tsz)
+					goto fail;
+			} else {
+				if (remap_oldmem_pfn_range(vma,
+							   vma->vm_start + len,
+							   paddr >> PAGE_SHIFT,
+							   tsz,
+							   vma->vm_page_prot))
+					goto fail;
+				len += tsz;
+			}
 			size -= tsz;
 			start += tsz;
-			len += tsz;
 
Quoted 2 lines

fs/proc/vmcore.c static int mmap_vmcore(struct file *file, struct vm_area_struct *vma) · line 455

Quoted 2 lines
fs/proc/vmcore.c +0 -0
 			if (size == 0)
 				return 0;

Thank you very much for your review! I'm working on v2.

Signature · 1 line
  Vitaly
#4 lore raw
In reply to Andrew Morton
Quoted 8 lines · Andrew Morton
Quoted 6 lines · On Mon, 7 Jul 2014 17:05:49 +0200 Vitaly Kuznetsov <[email protected]> wrote:

we have a special check in read_vmcore() handler to check if the page was reported as ram or not by the hypervisor (pfn_is_ram()). However, when vmcore is read with mmap() no such check is performed. That can lead to unpredictable results, e.g. when running Xen PVHVM guest memcpy() after mmap() on /proc/vmcore will hang processing HVMMEM_mmio_dm pages creating enormous load in both DomU and Dom0.

Does make forward progress though? Or is it ending up in a repeatedly retrying the same instruction?

Is it failing on a ballooned page in a RAM region? Or is mapping non-RAM regions as well?

Quoted 9 lines
Quoted 9 lines

Fix the issue by mapping each non-ram page to the zero page. Keep direct path with remap_oldmem_pfn_range() to avoid looping through all pages on bare metal.

The issue can also be solved by overriding remap_oldmem_pfn_range() in xen-specific code, as remap_oldmem_pfn_range() was been designed for. That, however, would involve non-obvious xen code path for all x86 builds with CONFIG_XEN_PVHVM=y and would prevent all other hypervisor-specific code on x86 arch from doing the same override.

The oldmem_pfn_is_ram() is Xen-specific but this problem (ballooned pages) must be common to KVM. How does KVM handle this?

David

#5 lore raw
Quoted 10 lines · David Vrabel
Quoted 8 lines · Andrew Morton
Quoted 6 lines · On Mon, 7 Jul 2014 17:05:49 +0200 Vitaly Kuznetsov <[email protected]> wrote:

we have a special check in read_vmcore() handler to check if the page was reported as ram or not by the hypervisor (pfn_is_ram()). However, when vmcore is read with mmap() no such check is performed. That can lead to unpredictable results, e.g. when running Xen PVHVM guest memcpy() after mmap() on /proc/vmcore will hang processing HVMMEM_mmio_dm pages creating enormous load in both DomU and Dom0.

Quoted 2 lines

Does make forward progress though? Or is it ending up in a repeatedly retrying the same instruction?

If memcpy is using SSE2 optimization 16-byte 'movdqu' instruction never finishes (repeatedly retrying to issue two 8-byte requests to qemu-dm). qemu-dm decides that it's hitting 'Neither RAM nor known MMIO space' and returns 8 0xff bytes for both of this requests (I was testing with qemu-traditional).

Quoted 3 lines

Is it failing on a ballooned page in a RAM region? Or is mapping non-RAM regions as well?

I wasn't using ballooning, it happens that oldmem has several (two in my test) pages which are HVMMEM_mmio_dm but qemu-dm considers them being neither ram nor mmio.

Quoted 5 lines
Quoted 5 lines
Quoted 5 lines

Fix the issue by mapping each non-ram page to the zero page. Keep direct path with remap_oldmem_pfn_range() to avoid looping through all pages on bare metal.

Quoted 8 lines
Quoted 5 lines
Quoted 5 lines

The issue can also be solved by overriding remap_oldmem_pfn_range() in xen-specific code, as remap_oldmem_pfn_range() was been designed for. That, however, would involve non-obvious xen code path for all x86 builds with CONFIG_XEN_PVHVM=y and would prevent all other hypervisor-specific code on x86 arch from doing the same override.

The oldmem_pfn_is_ram() is Xen-specific but this problem (ballooned pages) must be common to KVM. How does KVM handle this?

Is far as I'm concearned the issue was never hit with KVM. I *think* the issue has something to do with the conjunction of 16-byte 'movdqu' emulation for io pages in xen hypervisor, 8-byte event channel requests and qemu-traditional. But even if it gets fixed on hypervisor side I believe fixing the issue kernel-side still worth it as there are non-fixed hypervisors out there (e.g. AWS EC2).

Quoted 2 lines

David

Signature · 1 line
  Vitaly
#6 lore raw
In reply to David Vrabel
Quoted 10 lines · David Vrabel
Quoted 8 lines · Andrew Morton
Quoted 6 lines · On Mon, 7 Jul 2014 17:05:49 +0200 Vitaly Kuznetsov <[email protected]> wrote:

we have a special check in read_vmcore() handler to check if the page was reported as ram or not by the hypervisor (pfn_is_ram()). However, when vmcore is read with mmap() no such check is performed. That can lead to unpredictable results, e.g. when running Xen PVHVM guest memcpy() after mmap() on /proc/vmcore will hang processing HVMMEM_mmio_dm pages creating enormous load in both DomU and Dom0.

Quoted 2 lines

Does make forward progress though? Or is it ending up in a repeatedly retrying the same instruction?

If memcpy is using SSE2 optimization 16-byte 'movdqu' instruction never finishes (repeatedly retrying to issue two 8-byte requests to qemu-dm). qemu-dm decides that it's hitting 'Neither RAM nor known MMIO space' and returns 8 0xff bytes for both of this requests (I was testing with qemu-traditional).

Quoted 3 lines

Is it failing on a ballooned page in a RAM region? Or is mapping non-RAM regions as well?

I wasn't using ballooning, it happens that oldmem has several (two in my test) pages which are HVMMEM_mmio_dm but qemu-dm considers them being neither ram nor mmio.

Quoted 5 lines
Quoted 5 lines
Quoted 5 lines

Fix the issue by mapping each non-ram page to the zero page. Keep direct path with remap_oldmem_pfn_range() to avoid looping through all pages on bare metal.

Quoted 8 lines
Quoted 5 lines
Quoted 5 lines

The issue can also be solved by overriding remap_oldmem_pfn_range() in xen-specific code, as remap_oldmem_pfn_range() was been designed for. That, however, would involve non-obvious xen code path for all x86 builds with CONFIG_XEN_PVHVM=y and would prevent all other hypervisor-specific code on x86 arch from doing the same override.

The oldmem_pfn_is_ram() is Xen-specific but this problem (ballooned pages) must be common to KVM. How does KVM handle this?

Is far as I'm concearned the issue was never hit with KVM. I *think* the issue has something to do with the conjunction of 16-byte 'movdqu' emulation for io pages in xen hypervisor, 8-byte event channel requests and qemu-traditional. But even if it gets fixed on hypervisor side I believe fixing the issue kernel-side still worth it as there are non-fixed hypervisors out there (e.g. AWS EC2).

Quoted 2 lines

David

Signature · 1 line
  Vitaly
Acked-by
#7 lore raw
Quoted 12 lines · Vitaly Kuznetsov
Quoted 10 lines · David Vrabel
Quoted 8 lines · Andrew Morton
Quoted 6 lines · On Mon, 7 Jul 2014 17:05:49 +0200 Vitaly Kuznetsov <[email protected]> wrote:

we have a special check in read_vmcore() handler to check if the page was reported as ram or not by the hypervisor (pfn_is_ram()). However, when vmcore is read with mmap() no such check is performed. That can lead to unpredictable results, e.g. when running Xen PVHVM guest memcpy() after mmap() on /proc/vmcore will hang processing HVMMEM_mmio_dm pages creating enormous load in both DomU and Dom0.

Quoted 8 lines
Quoted 2 lines

Does make forward progress though? Or is it ending up in a repeatedly retrying the same instruction?

If memcpy is using SSE2 optimization 16-byte 'movdqu' instruction never finishes (repeatedly retrying to issue two 8-byte requests to qemu-dm). qemu-dm decides that it's hitting 'Neither RAM nor known MMIO space' and returns 8 0xff bytes for both of this requests (I was testing with qemu-traditional).

Yes, the emulation of instructions with 16-byte operands is a bit broken. I should be fixed.

Quoted 6 lines
Quoted 2 lines

Is it failing on a ballooned page in a RAM region? Or is mapping non-RAM regions as well?

I wasn't using ballooning, it happens that oldmem has several (two in my test) pages which are HVMMEM_mmio_dm but qemu-dm considers them being neither ram nor mmio.

I think this would also happen with ballooned pages, which are also not-present in the p2m and thus would show up as HVMMEM_mmio_dm type and accesses will also be forwarded to qemu (qemu gets everything by default).

Quoted 13 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines

Fix the issue by mapping each non-ram page to the zero page. Keep direct path with remap_oldmem_pfn_range() to avoid looping through all pages on bare metal.

Quoted 8 lines
Quoted 5 lines
Quoted 5 lines

The issue can also be solved by overriding remap_oldmem_pfn_range() in xen-specific code, as remap_oldmem_pfn_range() was been designed for. That, however, would involve non-obvious xen code path for all x86 builds with CONFIG_XEN_PVHVM=y and would prevent all other hypervisor-specific code on x86 arch from doing the same override.

The oldmem_pfn_is_ram() is Xen-specific but this problem (ballooned pages) must be common to KVM. How does KVM handle this?

Quoted 6 lines

Is far as I'm concearned the issue was never hit with KVM. I *think* the issue has something to do with the conjunction of 16-byte 'movdqu' emulation for io pages in xen hypervisor, 8-byte event channel requests and qemu-traditional. But even if it gets fixed on hypervisor side I believe fixing the issue kernel-side still worth it as there are non-fixed hypervisors out there (e.g. AWS EC2).

I think it would be preferrable to fix this on the hypervisor side so Xen guests behaves in the same way as KVM guests.

But if this needs to work on non-fixed hypervisors then this patch looks sensible. FWIW,

David

Acked-by
#8 lore raw
In reply to Vitaly Kuznetsov
Quoted 12 lines · Vitaly Kuznetsov
Quoted 10 lines · David Vrabel
Quoted 8 lines · Andrew Morton
Quoted 6 lines · On Mon, 7 Jul 2014 17:05:49 +0200 Vitaly Kuznetsov <[email protected]> wrote:

we have a special check in read_vmcore() handler to check if the page was reported as ram or not by the hypervisor (pfn_is_ram()). However, when vmcore is read with mmap() no such check is performed. That can lead to unpredictable results, e.g. when running Xen PVHVM guest memcpy() after mmap() on /proc/vmcore will hang processing HVMMEM_mmio_dm pages creating enormous load in both DomU and Dom0.

Quoted 8 lines
Quoted 2 lines

Does make forward progress though? Or is it ending up in a repeatedly retrying the same instruction?

If memcpy is using SSE2 optimization 16-byte 'movdqu' instruction never finishes (repeatedly retrying to issue two 8-byte requests to qemu-dm). qemu-dm decides that it's hitting 'Neither RAM nor known MMIO space' and returns 8 0xff bytes for both of this requests (I was testing with qemu-traditional).

Yes, the emulation of instructions with 16-byte operands is a bit broken. I should be fixed.

Quoted 6 lines
Quoted 2 lines

Is it failing on a ballooned page in a RAM region? Or is mapping non-RAM regions as well?

I wasn't using ballooning, it happens that oldmem has several (two in my test) pages which are HVMMEM_mmio_dm but qemu-dm considers them being neither ram nor mmio.

I think this would also happen with ballooned pages, which are also not-present in the p2m and thus would show up as HVMMEM_mmio_dm type and accesses will also be forwarded to qemu (qemu gets everything by default).

Quoted 13 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines

Fix the issue by mapping each non-ram page to the zero page. Keep direct path with remap_oldmem_pfn_range() to avoid looping through all pages on bare metal.

Quoted 8 lines
Quoted 5 lines
Quoted 5 lines

The issue can also be solved by overriding remap_oldmem_pfn_range() in xen-specific code, as remap_oldmem_pfn_range() was been designed for. That, however, would involve non-obvious xen code path for all x86 builds with CONFIG_XEN_PVHVM=y and would prevent all other hypervisor-specific code on x86 arch from doing the same override.

The oldmem_pfn_is_ram() is Xen-specific but this problem (ballooned pages) must be common to KVM. How does KVM handle this?

Quoted 6 lines

Is far as I'm concearned the issue was never hit with KVM. I *think* the issue has something to do with the conjunction of 16-byte 'movdqu' emulation for io pages in xen hypervisor, 8-byte event channel requests and qemu-traditional. But even if it gets fixed on hypervisor side I believe fixing the issue kernel-side still worth it as there are non-fixed hypervisors out there (e.g. AWS EC2).

I think it would be preferrable to fix this on the hypervisor side so Xen guests behaves in the same way as KVM guests.

But if this needs to work on non-fixed hypervisors then this patch looks sensible. FWIW,

David

#9 lore raw
In reply to Andrew Morton
Quoted 8 lines · Andrew Morton
Quoted 6 lines · On Mon, 7 Jul 2014 17:05:49 +0200 Vitaly Kuznetsov <[email protected]> wrote:

we have a special check in read_vmcore() handler to check if the page was reported as ram or not by the hypervisor (pfn_is_ram()). However, when vmcore is read with mmap() no such check is performed. That can lead to unpredictable results, e.g. when running Xen PVHVM guest memcpy() after mmap() on /proc/vmcore will hang processing HVMMEM_mmio_dm pages creating enormous load in both DomU and Dom0.

Does make forward progress though? Or is it ending up in a repeatedly retrying the same instruction?

Is it failing on a ballooned page in a RAM region? Or is mapping non-RAM regions as well?

Quoted 9 lines
Quoted 9 lines

Fix the issue by mapping each non-ram page to the zero page. Keep direct path with remap_oldmem_pfn_range() to avoid looping through all pages on bare metal.

The issue can also be solved by overriding remap_oldmem_pfn_range() in xen-specific code, as remap_oldmem_pfn_range() was been designed for. That, however, would involve non-obvious xen code path for all x86 builds with CONFIG_XEN_PVHVM=y and would prevent all other hypervisor-specific code on x86 arch from doing the same override.

The oldmem_pfn_is_ram() is Xen-specific but this problem (ballooned pages) must be common to KVM. How does KVM handle this?

David

maintainer
#10 lore raw
In reply to Vitaly Kuznetsov
Quoted 11 lines · On Mon, 7 Jul 2014 17:05:49 +0200 Vitaly Kuznetsov <[email protected]> wrote:

we have a special check in read_vmcore() handler to check if the page was reported as ram or not by the hypervisor (pfn_is_ram()). However, when vmcore is read with mmap() no such check is performed. That can lead to unpredictable results, e.g. when running Xen PVHVM guest memcpy() after mmap() on /proc/vmcore will hang processing HVMMEM_mmio_dm pages creating enormous load in both DomU and Dom0.

Fix the issue by mapping each non-ram page to the zero page. Keep direct path with remap_oldmem_pfn_range() to avoid looping through all pages on bare metal.

Quoted 5 lines

The issue can also be solved by overriding remap_oldmem_pfn_range() in xen-specific code, as remap_oldmem_pfn_range() was been designed for. That, however, would involve non-obvious xen code path for all x86 builds with CONFIG_XEN_PVHVM=y and would prevent all other hypervisor-specific code on x86 arch from doing the same override.

I'd like to get some reviewed-by's and tested-by's on this one please.

fs/proc/vmcore.c static inline char *alloc_elfnotes_buf(size_t notes_sz) · line 337

Quoted 13 lines
fs/proc/vmcore.c +7 -0
@@ -328,6 +328,46 @@ static inline char *alloc_elfnotes_buf(size_t notes_sz)
  * virtually contiguous user-space in ELF layout.
  */
 #ifdef CONFIG_MMU
+static u64 remap_oldmem_pfn_checked(struct vm_area_struct *vma, u64 len,
+				    unsigned long pfn, unsigned long page_count)
+{
+	unsigned long pos;
+	size_t size;
+	unsigned long vma_addr;
+	unsigned long emptypage_pfn = __pa(empty_zero_page) >> PAGE_SHIFT;

That's old-school. Can we use my_zero_pfn() here?

Also, "zeropage_pfn" is a better name - let's not introduce the hitherto unknown concept of an "empty page".

Quoted 7 lines
fs/proc/vmcore.c +7 -0
+	for (pos = pfn; (pos - pfn) <= page_count; pos++) {
+		if (!pfn_is_ram(pos) || (pos - pfn) == page_count) {
+			/* we hit a page which is not ram or reached the end */
+			if (pos - pfn > 0) {
+				/* remapping continuous region */
+				size = (pos - pfn) << PAGE_SHIFT;
+				vma_addr = vma->vm_start + len;

fs/proc/vmcore.c static inline char *alloc_elfnotes_buf(size_t notes_sz) · line 355

Quoted 10 lines
fs/proc/vmcore.c +10 -0
+				if (remap_oldmem_pfn_range(vma, vma_addr,
+							   pfn, size,
+							   vma->vm_page_prot))
+					return len;
+				len += size;
+				page_count -= (pos - pfn);
+			}
+			if (page_count > 0) {
+				/* we hit a page which is not ram, replacing
+				   with an empty one */

I suggest

				/*
				 * We hit a page which is not ram.  Replace it
				 * with the zero page.
				 */
Quoted 4 lines
fs/proc/vmcore.c +4 -0
+				vma_addr = vma->vm_start + len;
+				if (remap_oldmem_pfn_range(vma, vma_addr,
+							   emptypage_pfn,
+							   PAGE_SIZE,

fs/proc/vmcore.c static inline char *alloc_elfnotes_buf(size_t notes_sz) · line 369

Quoted 10 lines
fs/proc/vmcore.c +10 -0
+							   vma->vm_page_prot))
+					return len;
+				len += PAGE_SIZE;
+				pfn = pos + 1;
+				page_count--;
+			}
+		}
+	}
+	return len;
+}

Also, this loop seems unnecessarily hard to follow. It *look* like the `for' statement has an off-by-one because of the "<=", but page_count is mofidied inside the loop! Despite it being an incoming formal argument.

None of this is made any easier by the function's lack of documentation. Some description of the incoming args would help, along with an overall description of the function's responsibilities.

That being said, can't we just do something nice and simple like

	pos = pfn;
	while (pos < pfn + page_count) {
		stuff which advances `pos'
	}

?

Quoted 10 lines
fs/proc/vmcore.c +2 -1
 static int mmap_vmcore(struct file *file, struct vm_area_struct *vma)
 {
 	size_t size = vma->vm_end - vma->vm_start;
@@ -383,17 +423,33 @@ static int mmap_vmcore(struct file *file, struct vm_area_struct *vma)
 
 	list_for_each_entry(m, &vmcore_list, list) {
 		if (start < m->offset + m->size) {
-			u64 paddr = 0;
+			u64 paddr = 0, original_len;
+			unsigned long pfn, page_count;

fs/proc/vmcore.c static int mmap_vmcore(struct file *file, struct vm_area_struct *vma) · line 433

Quoted 10 lines
fs/proc/vmcore.c +3 -4
 
 			tsz = min_t(size_t, m->offset + m->size - start, size);
 			paddr = m->paddr + start - m->offset;
-			if (remap_oldmem_pfn_range(vma, vma->vm_start + len,
-						   paddr >> PAGE_SHIFT, tsz,
-						   vma->vm_page_prot))
-				goto fail;
+
+			/* check if oldmem_pfn_is_ram was registered to avoid
+			   looping over all pages without a reason */

Please lay out the comments in the usual fashion:

	/*
	 * ...
	 * ..
	 */

And sentences start whith upper-case letters!

Quoted 23 lines
fs/proc/vmcore.c +17 -1
+			if (oldmem_pfn_is_ram) {
+				pfn = paddr >> PAGE_SHIFT;
+				page_count = tsz >> PAGE_SHIFT;
+				original_len = len;
+				len = remap_oldmem_pfn_checked(vma, len, pfn,
+							       page_count);
+				if (len != original_len + tsz)
+					goto fail;
+			} else {
+				if (remap_oldmem_pfn_range(vma,
+							   vma->vm_start + len,
+							   paddr >> PAGE_SHIFT,
+							   tsz,
+							   vma->vm_page_prot))
+					goto fail;
+				len += tsz;
+			}
 			size -= tsz;
 			start += tsz;
-			len += tsz;
 
 			if (size == 0)
 				return 0;
#11 lore raw
In reply to Vitaly Kuznetsov
Quoted 11 lines · Vitaly Kuznetsov

we have a special check in read_vmcore() handler to check if the page was reported as ram or not by the hypervisor (pfn_is_ram()). However, when vmcore is read with mmap() no such check is performed. That can lead to unpredictable results, e.g. when running Xen PVHVM guest memcpy() after mmap() on /proc/vmcore will hang processing HVMMEM_mmio_dm pages creating enormous load in both DomU and Dom0.

Fix the issue by mapping each non-ram page to the zero page. Keep direct path with remap_oldmem_pfn_range() to avoid looping through all pages on bare metal.

Quoted 5 lines

The issue can also be solved by overriding remap_oldmem_pfn_range() in xen-specific code, as remap_oldmem_pfn_range() was been designed for. That, however, would involve non-obvious xen code path for all x86 builds with CONFIG_XEN_PVHVM=y and would prevent all other hypervisor-specific code on x86 arch from doing the same override.

Could the 'remap_oldmem_pfn_range' become an function ops? I see there is an 'register_oldmem_pfn_is_ram' - so could there be similar one for 'pfn_range'?

Quoted 105 lines
---
 fs/proc/vmcore.c | 68 +++++++++++++++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 62 insertions(+), 6 deletions(-)
fs/proc/vmcore.c +62 -6
index 382aa89..2716e19 100644
@@ -328,6 +328,46 @@ static inline char *alloc_elfnotes_buf(size_t notes_sz)
  * virtually contiguous user-space in ELF layout.
  */
 #ifdef CONFIG_MMU
+static u64 remap_oldmem_pfn_checked(struct vm_area_struct *vma, u64 len,
+				    unsigned long pfn, unsigned long page_count)
+{
+	unsigned long pos;
+	size_t size;
+	unsigned long vma_addr;
+	unsigned long emptypage_pfn = __pa(empty_zero_page) >> PAGE_SHIFT;
+
+	for (pos = pfn; (pos - pfn) <= page_count; pos++) {
+		if (!pfn_is_ram(pos) || (pos - pfn) == page_count) {
+			/* we hit a page which is not ram or reached the end */
+			if (pos - pfn > 0) {
+				/* remapping continuous region */
+				size = (pos - pfn) << PAGE_SHIFT;
+				vma_addr = vma->vm_start + len;
+				if (remap_oldmem_pfn_range(vma, vma_addr,
+							   pfn, size,
+							   vma->vm_page_prot))
+					return len;
+				len += size;
+				page_count -= (pos - pfn);
+			}
+			if (page_count > 0) {
+				/* we hit a page which is not ram, replacing
+				   with an empty one */
+				vma_addr = vma->vm_start + len;
+				if (remap_oldmem_pfn_range(vma, vma_addr,
+							   emptypage_pfn,
+							   PAGE_SIZE,
+							   vma->vm_page_prot))
+					return len;
+				len += PAGE_SIZE;
+				pfn = pos + 1;
+				page_count--;
+			}
+		}
+	}
+	return len;
+}
+
 static int mmap_vmcore(struct file *file, struct vm_area_struct *vma)
 {
 	size_t size = vma->vm_end - vma->vm_start;
@@ -383,17 +423,33 @@ static int mmap_vmcore(struct file *file, struct vm_area_struct *vma)
 
 	list_for_each_entry(m, &vmcore_list, list) {
 		if (start < m->offset + m->size) {
-			u64 paddr = 0;
+			u64 paddr = 0, original_len;
+			unsigned long pfn, page_count;
 
 			tsz = min_t(size_t, m->offset + m->size - start, size);
 			paddr = m->paddr + start - m->offset;
-			if (remap_oldmem_pfn_range(vma, vma->vm_start + len,
-						   paddr >> PAGE_SHIFT, tsz,
-						   vma->vm_page_prot))
-				goto fail;
+
+			/* check if oldmem_pfn_is_ram was registered to avoid
+			   looping over all pages without a reason */
+			if (oldmem_pfn_is_ram) {
+				pfn = paddr >> PAGE_SHIFT;
+				page_count = tsz >> PAGE_SHIFT;
+				original_len = len;
+				len = remap_oldmem_pfn_checked(vma, len, pfn,
+							       page_count);
+				if (len != original_len + tsz)
+					goto fail;
+			} else {
+				if (remap_oldmem_pfn_range(vma,
+							   vma->vm_start + len,
+							   paddr >> PAGE_SHIFT,
+							   tsz,
+							   vma->vm_page_prot))
+					goto fail;
+				len += tsz;
+			}
 			size -= tsz;
 			start += tsz;
-			len += tsz;
 
 			if (size == 0)
 				return 0;
Signature · 7 lines
1.9.3


_______________________________________________
Xen-devel mailing list
[email protected]
http://lists.xen.org/xen-devel
#12 lore raw
In reply to Vitaly Kuznetsov
Quoted 11 lines · Vitaly Kuznetsov

we have a special check in read_vmcore() handler to check if the page was reported as ram or not by the hypervisor (pfn_is_ram()). However, when vmcore is read with mmap() no such check is performed. That can lead to unpredictable results, e.g. when running Xen PVHVM guest memcpy() after mmap() on /proc/vmcore will hang processing HVMMEM_mmio_dm pages creating enormous load in both DomU and Dom0.

Fix the issue by mapping each non-ram page to the zero page. Keep direct path with remap_oldmem_pfn_range() to avoid looping through all pages on bare metal.

Quoted 5 lines

The issue can also be solved by overriding remap_oldmem_pfn_range() in xen-specific code, as remap_oldmem_pfn_range() was been designed for. That, however, would involve non-obvious xen code path for all x86 builds with CONFIG_XEN_PVHVM=y and would prevent all other hypervisor-specific code on x86 arch from doing the same override.

Could the 'remap_oldmem_pfn_range' become an function ops? I see there is an 'register_oldmem_pfn_is_ram' - so could there be similar one for 'pfn_range'?

Quoted 105 lines
---
 fs/proc/vmcore.c | 68 +++++++++++++++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 62 insertions(+), 6 deletions(-)
fs/proc/vmcore.c +62 -6
index 382aa89..2716e19 100644
@@ -328,6 +328,46 @@ static inline char *alloc_elfnotes_buf(size_t notes_sz)
  * virtually contiguous user-space in ELF layout.
  */
 #ifdef CONFIG_MMU
+static u64 remap_oldmem_pfn_checked(struct vm_area_struct *vma, u64 len,
+				    unsigned long pfn, unsigned long page_count)
+{
+	unsigned long pos;
+	size_t size;
+	unsigned long vma_addr;
+	unsigned long emptypage_pfn = __pa(empty_zero_page) >> PAGE_SHIFT;
+
+	for (pos = pfn; (pos - pfn) <= page_count; pos++) {
+		if (!pfn_is_ram(pos) || (pos - pfn) == page_count) {
+			/* we hit a page which is not ram or reached the end */
+			if (pos - pfn > 0) {
+				/* remapping continuous region */
+				size = (pos - pfn) << PAGE_SHIFT;
+				vma_addr = vma->vm_start + len;
+				if (remap_oldmem_pfn_range(vma, vma_addr,
+							   pfn, size,
+							   vma->vm_page_prot))
+					return len;
+				len += size;
+				page_count -= (pos - pfn);
+			}
+			if (page_count > 0) {
+				/* we hit a page which is not ram, replacing
+				   with an empty one */
+				vma_addr = vma->vm_start + len;
+				if (remap_oldmem_pfn_range(vma, vma_addr,
+							   emptypage_pfn,
+							   PAGE_SIZE,
+							   vma->vm_page_prot))
+					return len;
+				len += PAGE_SIZE;
+				pfn = pos + 1;
+				page_count--;
+			}
+		}
+	}
+	return len;
+}
+
 static int mmap_vmcore(struct file *file, struct vm_area_struct *vma)
 {
 	size_t size = vma->vm_end - vma->vm_start;
@@ -383,17 +423,33 @@ static int mmap_vmcore(struct file *file, struct vm_area_struct *vma)
 
 	list_for_each_entry(m, &vmcore_list, list) {
 		if (start < m->offset + m->size) {
-			u64 paddr = 0;
+			u64 paddr = 0, original_len;
+			unsigned long pfn, page_count;
 
 			tsz = min_t(size_t, m->offset + m->size - start, size);
 			paddr = m->paddr + start - m->offset;
-			if (remap_oldmem_pfn_range(vma, vma->vm_start + len,
-						   paddr >> PAGE_SHIFT, tsz,
-						   vma->vm_page_prot))
-				goto fail;
+
+			/* check if oldmem_pfn_is_ram was registered to avoid
+			   looping over all pages without a reason */
+			if (oldmem_pfn_is_ram) {
+				pfn = paddr >> PAGE_SHIFT;
+				page_count = tsz >> PAGE_SHIFT;
+				original_len = len;
+				len = remap_oldmem_pfn_checked(vma, len, pfn,
+							       page_count);
+				if (len != original_len + tsz)
+					goto fail;
+			} else {
+				if (remap_oldmem_pfn_range(vma,
+							   vma->vm_start + len,
+							   paddr >> PAGE_SHIFT,
+							   tsz,
+							   vma->vm_page_prot))
+					goto fail;
+				len += tsz;
+			}
 			size -= tsz;
 			start += tsz;
-			len += tsz;
 
 			if (size == 0)
 				return 0;
Signature · 7 lines
1.9.3


_______________________________________________
Xen-devel mailing list
[email protected]
http://lists.xen.org/xen-devel
#13 lore raw
Quoted 18 lines · Konrad Rzeszutek Wilk
Quoted 11 lines · Vitaly Kuznetsov

we have a special check in read_vmcore() handler to check if the page was reported as ram or not by the hypervisor (pfn_is_ram()). However, when vmcore is read with mmap() no such check is performed. That can lead to unpredictable results, e.g. when running Xen PVHVM guest memcpy() after mmap() on /proc/vmcore will hang processing HVMMEM_mmio_dm pages creating enormous load in both DomU and Dom0.

Fix the issue by mapping each non-ram page to the zero page. Keep direct path with remap_oldmem_pfn_range() to avoid looping through all pages on bare metal.

Quoted 5 lines

The issue can also be solved by overriding remap_oldmem_pfn_range() in xen-specific code, as remap_oldmem_pfn_range() was been designed for. That, however, would involve non-obvious xen code path for all x86 builds with CONFIG_XEN_PVHVM=y and would prevent all other hypervisor-specific code on x86 arch from doing the same override.

Quoted 3 lines

Could the 'remap_oldmem_pfn_range' become an function ops? I see there is an 'register_oldmem_pfn_is_ram' - so could there be similar one for 'pfn_range'?

yes, it is possible to replace '__weak remap_oldmem_pfn_range' with 'register_oldmem_pfn_is_ram'. However s390 arch overrides this function in arch/s390/kernel/crash_dump.c so we'll have to make some changes there as well.

Quoted 106 lines
Quoted 106 lines
---
 fs/proc/vmcore.c | 68 +++++++++++++++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 62 insertions(+), 6 deletions(-)
fs/proc/vmcore.c +62 -6
index 382aa89..2716e19 100644
@@ -328,6 +328,46 @@ static inline char *alloc_elfnotes_buf(size_t notes_sz)
  * virtually contiguous user-space in ELF layout.
  */
 #ifdef CONFIG_MMU
+static u64 remap_oldmem_pfn_checked(struct vm_area_struct *vma, u64 len,
+				    unsigned long pfn, unsigned long page_count)
+{
+	unsigned long pos;
+	size_t size;
+	unsigned long vma_addr;
+	unsigned long emptypage_pfn = __pa(empty_zero_page) >> PAGE_SHIFT;
+
+	for (pos = pfn; (pos - pfn) <= page_count; pos++) {
+		if (!pfn_is_ram(pos) || (pos - pfn) == page_count) {
+			/* we hit a page which is not ram or reached the end */
+			if (pos - pfn > 0) {
+				/* remapping continuous region */
+				size = (pos - pfn) << PAGE_SHIFT;
+				vma_addr = vma->vm_start + len;
+				if (remap_oldmem_pfn_range(vma, vma_addr,
+							   pfn, size,
+							   vma->vm_page_prot))
+					return len;
+				len += size;
+				page_count -= (pos - pfn);
+			}
+			if (page_count > 0) {
+				/* we hit a page which is not ram, replacing
+				   with an empty one */
+				vma_addr = vma->vm_start + len;
+				if (remap_oldmem_pfn_range(vma, vma_addr,
+							   emptypage_pfn,
+							   PAGE_SIZE,
+							   vma->vm_page_prot))
+					return len;
+				len += PAGE_SIZE;
+				pfn = pos + 1;
+				page_count--;
+			}
+		}
+	}
+	return len;
+}
+
 static int mmap_vmcore(struct file *file, struct vm_area_struct *vma)
 {
 	size_t size = vma->vm_end - vma->vm_start;
@@ -383,17 +423,33 @@ static int mmap_vmcore(struct file *file, struct vm_area_struct *vma)
 
 	list_for_each_entry(m, &vmcore_list, list) {
 		if (start < m->offset + m->size) {
-			u64 paddr = 0;
+			u64 paddr = 0, original_len;
+			unsigned long pfn, page_count;
 
 			tsz = min_t(size_t, m->offset + m->size - start, size);
 			paddr = m->paddr + start - m->offset;
-			if (remap_oldmem_pfn_range(vma, vma->vm_start + len,
-						   paddr >> PAGE_SHIFT, tsz,
-						   vma->vm_page_prot))
-				goto fail;
+
+			/* check if oldmem_pfn_is_ram was registered to avoid
+			   looping over all pages without a reason */
+			if (oldmem_pfn_is_ram) {
+				pfn = paddr >> PAGE_SHIFT;
+				page_count = tsz >> PAGE_SHIFT;
+				original_len = len;
+				len = remap_oldmem_pfn_checked(vma, len, pfn,
+							       page_count);
+				if (len != original_len + tsz)
+					goto fail;
+			} else {
+				if (remap_oldmem_pfn_range(vma,
+							   vma->vm_start + len,
+							   paddr >> PAGE_SHIFT,
+							   tsz,
+							   vma->vm_page_prot))
+					goto fail;
+				len += tsz;
+			}
 			size -= tsz;
 			start += tsz;
-			len += tsz;
 
 			if (size == 0)
 				return 0;
Signature · 7 lines
1.9.3


_______________________________________________
Xen-devel mailing list
[email protected]
http://lists.xen.org/xen-devel
Signature · 1 line
  Vitaly
#14 lore raw
In reply to Konrad Rzeszutek Wilk
Quoted 18 lines · Konrad Rzeszutek Wilk
Quoted 11 lines · Vitaly Kuznetsov

we have a special check in read_vmcore() handler to check if the page was reported as ram or not by the hypervisor (pfn_is_ram()). However, when vmcore is read with mmap() no such check is performed. That can lead to unpredictable results, e.g. when running Xen PVHVM guest memcpy() after mmap() on /proc/vmcore will hang processing HVMMEM_mmio_dm pages creating enormous load in both DomU and Dom0.

Fix the issue by mapping each non-ram page to the zero page. Keep direct path with remap_oldmem_pfn_range() to avoid looping through all pages on bare metal.

Quoted 5 lines

The issue can also be solved by overriding remap_oldmem_pfn_range() in xen-specific code, as remap_oldmem_pfn_range() was been designed for. That, however, would involve non-obvious xen code path for all x86 builds with CONFIG_XEN_PVHVM=y and would prevent all other hypervisor-specific code on x86 arch from doing the same override.

Quoted 3 lines

Could the 'remap_oldmem_pfn_range' become an function ops? I see there is an 'register_oldmem_pfn_is_ram' - so could there be similar one for 'pfn_range'?

yes, it is possible to replace '__weak remap_oldmem_pfn_range' with 'register_oldmem_pfn_is_ram'. However s390 arch overrides this function in arch/s390/kernel/crash_dump.c so we'll have to make some changes there as well.

Quoted 106 lines
Quoted 106 lines
---
 fs/proc/vmcore.c | 68 +++++++++++++++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 62 insertions(+), 6 deletions(-)
fs/proc/vmcore.c +62 -6
index 382aa89..2716e19 100644
@@ -328,6 +328,46 @@ static inline char *alloc_elfnotes_buf(size_t notes_sz)
  * virtually contiguous user-space in ELF layout.
  */
 #ifdef CONFIG_MMU
+static u64 remap_oldmem_pfn_checked(struct vm_area_struct *vma, u64 len,
+				    unsigned long pfn, unsigned long page_count)
+{
+	unsigned long pos;
+	size_t size;
+	unsigned long vma_addr;
+	unsigned long emptypage_pfn = __pa(empty_zero_page) >> PAGE_SHIFT;
+
+	for (pos = pfn; (pos - pfn) <= page_count; pos++) {
+		if (!pfn_is_ram(pos) || (pos - pfn) == page_count) {
+			/* we hit a page which is not ram or reached the end */
+			if (pos - pfn > 0) {
+				/* remapping continuous region */
+				size = (pos - pfn) << PAGE_SHIFT;
+				vma_addr = vma->vm_start + len;
+				if (remap_oldmem_pfn_range(vma, vma_addr,
+							   pfn, size,
+							   vma->vm_page_prot))
+					return len;
+				len += size;
+				page_count -= (pos - pfn);
+			}
+			if (page_count > 0) {
+				/* we hit a page which is not ram, replacing
+				   with an empty one */
+				vma_addr = vma->vm_start + len;
+				if (remap_oldmem_pfn_range(vma, vma_addr,
+							   emptypage_pfn,
+							   PAGE_SIZE,
+							   vma->vm_page_prot))
+					return len;
+				len += PAGE_SIZE;
+				pfn = pos + 1;
+				page_count--;
+			}
+		}
+	}
+	return len;
+}
+
 static int mmap_vmcore(struct file *file, struct vm_area_struct *vma)
 {
 	size_t size = vma->vm_end - vma->vm_start;
@@ -383,17 +423,33 @@ static int mmap_vmcore(struct file *file, struct vm_area_struct *vma)
 
 	list_for_each_entry(m, &vmcore_list, list) {
 		if (start < m->offset + m->size) {
-			u64 paddr = 0;
+			u64 paddr = 0, original_len;
+			unsigned long pfn, page_count;
 
 			tsz = min_t(size_t, m->offset + m->size - start, size);
 			paddr = m->paddr + start - m->offset;
-			if (remap_oldmem_pfn_range(vma, vma->vm_start + len,
-						   paddr >> PAGE_SHIFT, tsz,
-						   vma->vm_page_prot))
-				goto fail;
+
+			/* check if oldmem_pfn_is_ram was registered to avoid
+			   looping over all pages without a reason */
+			if (oldmem_pfn_is_ram) {
+				pfn = paddr >> PAGE_SHIFT;
+				page_count = tsz >> PAGE_SHIFT;
+				original_len = len;
+				len = remap_oldmem_pfn_checked(vma, len, pfn,
+							       page_count);
+				if (len != original_len + tsz)
+					goto fail;
+			} else {
+				if (remap_oldmem_pfn_range(vma,
+							   vma->vm_start + len,
+							   paddr >> PAGE_SHIFT,
+							   tsz,
+							   vma->vm_page_prot))
+					goto fail;
+				len += tsz;
+			}
 			size -= tsz;
 			start += tsz;
-			len += tsz;
 
 			if (size == 0)
 				return 0;
Signature · 7 lines
1.9.3


_______________________________________________
Xen-devel mailing list
[email protected]
http://lists.xen.org/xen-devel
Signature · 1 line
  Vitaly
#15 lore raw
In reply to Vitaly Kuznetsov
Quoted 2 lines · Vitaly Kuznetsov

we have a special check in read_vmcore() handler to check if the page was reported as ram or not by the hypervisor (pfn_is_ram()).

I am wondering if this name pfn_is_ram() appropriate for what we are doing. So IIUC, a balooned memory is also RAM just that it has not been allocated yet. That means we can safely assume that there is no data and can safely fill it with zeros?

If yes, then page_is_zero_filled() might be a more approprate name.

Also I am wondering why it was not done as part of copy_oldmem_page() so that respective arch could hide all the details.

Quoted 10 lines

However, when
vmcore is read with mmap() no such check is performed. That can lead to unpredictable results, e.g. when running Xen PVHVM guest memcpy() after mmap() on /proc/vmcore will hang processing HVMMEM_mmio_dm pages creating enormous load in both DomU and Dom0.

Fix the issue by mapping each non-ram page to the zero page. Keep direct path with remap_oldmem_pfn_range() to avoid looping through all pages on bare metal.

Quoted 5 lines

The issue can also be solved by overriding remap_oldmem_pfn_range() in xen-specific code, as remap_oldmem_pfn_range() was been designed for. That, however, would involve non-obvious xen code path for all x86 builds with CONFIG_XEN_PVHVM=y and would prevent all other hypervisor-specific code on x86 arch from doing the same override.

I am not sure I understand this part. So what is "all other hypervisor specic" code which will like to do this. And will that code is compiled at the same time as CONFIG_XEN_PVHVM?

Quoted 79 lines
---
 fs/proc/vmcore.c | 68 +++++++++++++++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 62 insertions(+), 6 deletions(-)
fs/proc/vmcore.c +50 -5
index 382aa89..2716e19 100644
@@ -328,6 +328,46 @@ static inline char *alloc_elfnotes_buf(size_t notes_sz)
  * virtually contiguous user-space in ELF layout.
  */
 #ifdef CONFIG_MMU
+static u64 remap_oldmem_pfn_checked(struct vm_area_struct *vma, u64 len,
+				    unsigned long pfn, unsigned long page_count)
+{
+	unsigned long pos;
+	size_t size;
+	unsigned long vma_addr;
+	unsigned long emptypage_pfn = __pa(empty_zero_page) >> PAGE_SHIFT;
+
+	for (pos = pfn; (pos - pfn) <= page_count; pos++) {
+		if (!pfn_is_ram(pos) || (pos - pfn) == page_count) {
+			/* we hit a page which is not ram or reached the end */
+			if (pos - pfn > 0) {
+				/* remapping continuous region */
+				size = (pos - pfn) << PAGE_SHIFT;
+				vma_addr = vma->vm_start + len;
+				if (remap_oldmem_pfn_range(vma, vma_addr,
+							   pfn, size,
+							   vma->vm_page_prot))
+					return len;
+				len += size;
+				page_count -= (pos - pfn);
+			}
+			if (page_count > 0) {
+				/* we hit a page which is not ram, replacing
+				   with an empty one */
+				vma_addr = vma->vm_start + len;
+				if (remap_oldmem_pfn_range(vma, vma_addr,
+							   emptypage_pfn,
+							   PAGE_SIZE,
+							   vma->vm_page_prot))
+					return len;
+				len += PAGE_SIZE;
+				pfn = pos + 1;
+				page_count--;
+			}
+		}
+	}
+	return len;
+}
+
 static int mmap_vmcore(struct file *file, struct vm_area_struct *vma)
 {
 	size_t size = vma->vm_end - vma->vm_start;
@@ -383,17 +423,33 @@ static int mmap_vmcore(struct file *file, struct vm_area_struct *vma)
 
 	list_for_each_entry(m, &vmcore_list, list) {
 		if (start < m->offset + m->size) {
-			u64 paddr = 0;
+			u64 paddr = 0, original_len;
+			unsigned long pfn, page_count;
 
 			tsz = min_t(size_t, m->offset + m->size - start, size);
 			paddr = m->paddr + start - m->offset;
-			if (remap_oldmem_pfn_range(vma, vma->vm_start + len,
-						   paddr >> PAGE_SHIFT, tsz,
-						   vma->vm_page_prot))
-				goto fail;
+
+			/* check if oldmem_pfn_is_ram was registered to avoid
+			   looping over all pages without a reason */
+			if (oldmem_pfn_is_ram) {
+				pfn = paddr >> PAGE_SHIFT;
+				page_count = tsz >> PAGE_SHIFT;
+				original_len = len;
+				len = remap_oldmem_pfn_checked(vma, len, pfn,

fs/proc/vmcore.c static int mmap_vmcore(struct file *file, struct vm_area_struct *vma) · line 448

Quoted 10 lines
fs/proc/vmcore.c +10 -0
+							       page_count);
+				if (len != original_len + tsz)
+					goto fail;
+			} else {
+				if (remap_oldmem_pfn_range(vma,
+							   vma->vm_start + len,
+							   paddr >> PAGE_SHIFT,
+							   tsz,
+							   vma->vm_page_prot))
+					goto fail;

Why are we defining both remap_oldmem_pfn_checked()? Can't we just modify remap_oldmem_pfn_range() to *always* check for if pfn_is_zero_filled() and map accordingly.

Thanks
Vivek

#16 lore raw
In reply to Vitaly Kuznetsov
Quoted 2 lines · Vitaly Kuznetsov

we have a special check in read_vmcore() handler to check if the page was reported as ram or not by the hypervisor (pfn_is_ram()).

I am wondering if this name pfn_is_ram() appropriate for what we are doing. So IIUC, a balooned memory is also RAM just that it has not been allocated yet. That means we can safely assume that there is no data and can safely fill it with zeros?

If yes, then page_is_zero_filled() might be a more approprate name.

Also I am wondering why it was not done as part of copy_oldmem_page() so that respective arch could hide all the details.

Quoted 10 lines

However, when
vmcore is read with mmap() no such check is performed. That can lead to unpredictable results, e.g. when running Xen PVHVM guest memcpy() after mmap() on /proc/vmcore will hang processing HVMMEM_mmio_dm pages creating enormous load in both DomU and Dom0.

Fix the issue by mapping each non-ram page to the zero page. Keep direct path with remap_oldmem_pfn_range() to avoid looping through all pages on bare metal.

Quoted 5 lines

The issue can also be solved by overriding remap_oldmem_pfn_range() in xen-specific code, as remap_oldmem_pfn_range() was been designed for. That, however, would involve non-obvious xen code path for all x86 builds with CONFIG_XEN_PVHVM=y and would prevent all other hypervisor-specific code on x86 arch from doing the same override.

I am not sure I understand this part. So what is "all other hypervisor specic" code which will like to do this. And will that code is compiled at the same time as CONFIG_XEN_PVHVM?

Quoted 79 lines
---
 fs/proc/vmcore.c | 68 +++++++++++++++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 62 insertions(+), 6 deletions(-)
fs/proc/vmcore.c +50 -5
index 382aa89..2716e19 100644
@@ -328,6 +328,46 @@ static inline char *alloc_elfnotes_buf(size_t notes_sz)
  * virtually contiguous user-space in ELF layout.
  */
 #ifdef CONFIG_MMU
+static u64 remap_oldmem_pfn_checked(struct vm_area_struct *vma, u64 len,
+				    unsigned long pfn, unsigned long page_count)
+{
+	unsigned long pos;
+	size_t size;
+	unsigned long vma_addr;
+	unsigned long emptypage_pfn = __pa(empty_zero_page) >> PAGE_SHIFT;
+
+	for (pos = pfn; (pos - pfn) <= page_count; pos++) {
+		if (!pfn_is_ram(pos) || (pos - pfn) == page_count) {
+			/* we hit a page which is not ram or reached the end */
+			if (pos - pfn > 0) {
+				/* remapping continuous region */
+				size = (pos - pfn) << PAGE_SHIFT;
+				vma_addr = vma->vm_start + len;
+				if (remap_oldmem_pfn_range(vma, vma_addr,
+							   pfn, size,
+							   vma->vm_page_prot))
+					return len;
+				len += size;
+				page_count -= (pos - pfn);
+			}
+			if (page_count > 0) {
+				/* we hit a page which is not ram, replacing
+				   with an empty one */
+				vma_addr = vma->vm_start + len;
+				if (remap_oldmem_pfn_range(vma, vma_addr,
+							   emptypage_pfn,
+							   PAGE_SIZE,
+							   vma->vm_page_prot))
+					return len;
+				len += PAGE_SIZE;
+				pfn = pos + 1;
+				page_count--;
+			}
+		}
+	}
+	return len;
+}
+
 static int mmap_vmcore(struct file *file, struct vm_area_struct *vma)
 {
 	size_t size = vma->vm_end - vma->vm_start;
@@ -383,17 +423,33 @@ static int mmap_vmcore(struct file *file, struct vm_area_struct *vma)
 
 	list_for_each_entry(m, &vmcore_list, list) {
 		if (start < m->offset + m->size) {
-			u64 paddr = 0;
+			u64 paddr = 0, original_len;
+			unsigned long pfn, page_count;
 
 			tsz = min_t(size_t, m->offset + m->size - start, size);
 			paddr = m->paddr + start - m->offset;
-			if (remap_oldmem_pfn_range(vma, vma->vm_start + len,
-						   paddr >> PAGE_SHIFT, tsz,
-						   vma->vm_page_prot))
-				goto fail;
+
+			/* check if oldmem_pfn_is_ram was registered to avoid
+			   looping over all pages without a reason */
+			if (oldmem_pfn_is_ram) {
+				pfn = paddr >> PAGE_SHIFT;
+				page_count = tsz >> PAGE_SHIFT;
+				original_len = len;
+				len = remap_oldmem_pfn_checked(vma, len, pfn,

fs/proc/vmcore.c static int mmap_vmcore(struct file *file, struct vm_area_struct *vma) · line 448

Quoted 10 lines
fs/proc/vmcore.c +10 -0
+							       page_count);
+				if (len != original_len + tsz)
+					goto fail;
+			} else {
+				if (remap_oldmem_pfn_range(vma,
+							   vma->vm_start + len,
+							   paddr >> PAGE_SHIFT,
+							   tsz,
+							   vma->vm_page_prot))
+					goto fail;

Why are we defining both remap_oldmem_pfn_checked()? Can't we just modify remap_oldmem_pfn_range() to *always* check for if pfn_is_zero_filled() and map accordingly.

Thanks
Vivek

#17 lore raw
Quoted 8 lines · Vivek Goyal
Quoted 2 lines · Vitaly Kuznetsov

we have a special check in read_vmcore() handler to check if the page was reported as ram or not by the hypervisor (pfn_is_ram()).

I am wondering if this name pfn_is_ram() appropriate for what we are doing. So IIUC, a balooned memory is also RAM just that it has not been allocated yet. That means we can safely assume that there is no data and can safely fill it with zeros?

For Xen pfn_is_ram() returns 0 in case the page is an mmio. Ballooned pages are also considered being mmio (HVMOP_get_mem_type returns HVMMEM_mmio_dm).

Quoted 3 lines

If yes, then page_is_zero_filled() might be a more approprate name.

It's not as mmio page is not always zero-filled. We just don't need these pages in vmcore.

Quoted 3 lines

Also I am wondering why it was not done as part of copy_oldmem_page() so that respective arch could hide all the details.

Afaiac that wouldn't solve the mmap issue I'm trying to address but we can ask Olaf why he preferred pfn_is_ram() path.

Quoted 16 lines
Quoted 10 lines

However, when
vmcore is read with mmap() no such check is performed. That can lead to unpredictable results, e.g. when running Xen PVHVM guest memcpy() after mmap() on /proc/vmcore will hang processing HVMMEM_mmio_dm pages creating enormous load in both DomU and Dom0.

Fix the issue by mapping each non-ram page to the zero page. Keep direct path with remap_oldmem_pfn_range() to avoid looping through all pages on bare metal.

Quoted 5 lines

The issue can also be solved by overriding remap_oldmem_pfn_range() in xen-specific code, as remap_oldmem_pfn_range() was been designed for. That, however, would involve non-obvious xen code path for all x86 builds with CONFIG_XEN_PVHVM=y and would prevent all other hypervisor-specific code on x86 arch from doing the same override.

Quoted 4 lines

I am not sure I understand this part. So what is "all other hypervisor specic" code which will like to do this. And will that code is compiled at the same time as CONFIG_XEN_PVHVM?

I meant to say that we have many hypervisors for x86 supported. In case I override __weak remap_oldmem_pfn_range() in xen-specific code it will *always* get executed when this code was compiled. In case we'll have to do similar override in e.g. Hyperv or KVM code in future we'll have a mess (in which order do we need to execute these overrides?).

In few words, Xen-PVHVM is not an architecture so I'm not following "Architectures may override this function to map oldmem" path.

Quoted 85 lines
Quoted 85 lines
---
 fs/proc/vmcore.c | 68 +++++++++++++++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 62 insertions(+), 6 deletions(-)
fs/proc/vmcore.c +56 -5
index 382aa89..2716e19 100644
@@ -328,6 +328,46 @@ static inline char *alloc_elfnotes_buf(size_t notes_sz)
  * virtually contiguous user-space in ELF layout.
  */
 #ifdef CONFIG_MMU
+static u64 remap_oldmem_pfn_checked(struct vm_area_struct *vma, u64 len,
+				    unsigned long pfn, unsigned long page_count)
+{
+	unsigned long pos;
+	size_t size;
+	unsigned long vma_addr;
+	unsigned long emptypage_pfn = __pa(empty_zero_page) >> PAGE_SHIFT;
+
+	for (pos = pfn; (pos - pfn) <= page_count; pos++) {
+		if (!pfn_is_ram(pos) || (pos - pfn) == page_count) {
+			/* we hit a page which is not ram or reached the end */
+			if (pos - pfn > 0) {
+				/* remapping continuous region */
+				size = (pos - pfn) << PAGE_SHIFT;
+				vma_addr = vma->vm_start + len;
+				if (remap_oldmem_pfn_range(vma, vma_addr,
+							   pfn, size,
+							   vma->vm_page_prot))
+					return len;
+				len += size;
+				page_count -= (pos - pfn);
+			}
+			if (page_count > 0) {
+				/* we hit a page which is not ram, replacing
+				   with an empty one */
+				vma_addr = vma->vm_start + len;
+				if (remap_oldmem_pfn_range(vma, vma_addr,
+							   emptypage_pfn,
+							   PAGE_SIZE,
+							   vma->vm_page_prot))
+					return len;
+				len += PAGE_SIZE;
+				pfn = pos + 1;
+				page_count--;
+			}
+		}
+	}
+	return len;
+}
+
 static int mmap_vmcore(struct file *file, struct vm_area_struct *vma)
 {
 	size_t size = vma->vm_end - vma->vm_start;
@@ -383,17 +423,33 @@ static int mmap_vmcore(struct file *file, struct vm_area_struct *vma)
 
 	list_for_each_entry(m, &vmcore_list, list) {
 		if (start < m->offset + m->size) {
-			u64 paddr = 0;
+			u64 paddr = 0, original_len;
+			unsigned long pfn, page_count;
 
 			tsz = min_t(size_t, m->offset + m->size - start, size);
 			paddr = m->paddr + start - m->offset;
-			if (remap_oldmem_pfn_range(vma, vma->vm_start + len,
-						   paddr >> PAGE_SHIFT, tsz,
-						   vma->vm_page_prot))
-				goto fail;
+
+			/* check if oldmem_pfn_is_ram was registered to avoid
+			   looping over all pages without a reason */
+			if (oldmem_pfn_is_ram) {
+				pfn = paddr >> PAGE_SHIFT;
+				page_count = tsz >> PAGE_SHIFT;
+				original_len = len;
+				len = remap_oldmem_pfn_checked(vma, len, pfn,
+							       page_count);
+				if (len != original_len + tsz)
+					goto fail;
+			} else {
+				if (remap_oldmem_pfn_range(vma,
+							   vma->vm_start + len,
Quoted 8 lines

fs/proc/vmcore.c static int mmap_vmcore(struct file *file, struct vm_area_struct *vma) · line 448

Quoted 4 lines
fs/proc/vmcore.c +4 -0
+							   paddr >> PAGE_SHIFT,
+							   tsz,
+							   vma->vm_page_prot))
+					goto fail;

Why are we defining both remap_oldmem_pfn_checked()? Can't we just modify remap_oldmem_pfn_range() to *always* check for if pfn_is_zero_filled() and map accordingly.

I wanted to preserve the direct path without the check to make things faster when the pfn_is_ram() handler was not registered. oldmem is huge sometimes and issuing a single call per pfn can cost us something.

Quoted 3 lines

Thanks
Vivek

Signature · 1 line
  Vitaly
#18 lore raw
In reply to Vivek Goyal
Quoted 8 lines · Vivek Goyal
Quoted 2 lines · Vitaly Kuznetsov

we have a special check in read_vmcore() handler to check if the page was reported as ram or not by the hypervisor (pfn_is_ram()).

I am wondering if this name pfn_is_ram() appropriate for what we are doing. So IIUC, a balooned memory is also RAM just that it has not been allocated yet. That means we can safely assume that there is no data and can safely fill it with zeros?

For Xen pfn_is_ram() returns 0 in case the page is an mmio. Ballooned pages are also considered being mmio (HVMOP_get_mem_type returns HVMMEM_mmio_dm).

Quoted 3 lines

If yes, then page_is_zero_filled() might be a more approprate name.

It's not as mmio page is not always zero-filled. We just don't need these pages in vmcore.

Quoted 3 lines

Also I am wondering why it was not done as part of copy_oldmem_page() so that respective arch could hide all the details.

Afaiac that wouldn't solve the mmap issue I'm trying to address but we can ask Olaf why he preferred pfn_is_ram() path.

Quoted 16 lines
Quoted 10 lines

However, when
vmcore is read with mmap() no such check is performed. That can lead to unpredictable results, e.g. when running Xen PVHVM guest memcpy() after mmap() on /proc/vmcore will hang processing HVMMEM_mmio_dm pages creating enormous load in both DomU and Dom0.

Fix the issue by mapping each non-ram page to the zero page. Keep direct path with remap_oldmem_pfn_range() to avoid looping through all pages on bare metal.

Quoted 5 lines

The issue can also be solved by overriding remap_oldmem_pfn_range() in xen-specific code, as remap_oldmem_pfn_range() was been designed for. That, however, would involve non-obvious xen code path for all x86 builds with CONFIG_XEN_PVHVM=y and would prevent all other hypervisor-specific code on x86 arch from doing the same override.

Quoted 4 lines

I am not sure I understand this part. So what is "all other hypervisor specic" code which will like to do this. And will that code is compiled at the same time as CONFIG_XEN_PVHVM?

I meant to say that we have many hypervisors for x86 supported. In case I override __weak remap_oldmem_pfn_range() in xen-specific code it will *always* get executed when this code was compiled. In case we'll have to do similar override in e.g. Hyperv or KVM code in future we'll have a mess (in which order do we need to execute these overrides?).

In few words, Xen-PVHVM is not an architecture so I'm not following "Architectures may override this function to map oldmem" path.

Quoted 85 lines
Quoted 85 lines
---
 fs/proc/vmcore.c | 68 +++++++++++++++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 62 insertions(+), 6 deletions(-)
fs/proc/vmcore.c +56 -5
index 382aa89..2716e19 100644
@@ -328,6 +328,46 @@ static inline char *alloc_elfnotes_buf(size_t notes_sz)
  * virtually contiguous user-space in ELF layout.
  */
 #ifdef CONFIG_MMU
+static u64 remap_oldmem_pfn_checked(struct vm_area_struct *vma, u64 len,
+				    unsigned long pfn, unsigned long page_count)
+{
+	unsigned long pos;
+	size_t size;
+	unsigned long vma_addr;
+	unsigned long emptypage_pfn = __pa(empty_zero_page) >> PAGE_SHIFT;
+
+	for (pos = pfn; (pos - pfn) <= page_count; pos++) {
+		if (!pfn_is_ram(pos) || (pos - pfn) == page_count) {
+			/* we hit a page which is not ram or reached the end */
+			if (pos - pfn > 0) {
+				/* remapping continuous region */
+				size = (pos - pfn) << PAGE_SHIFT;
+				vma_addr = vma->vm_start + len;
+				if (remap_oldmem_pfn_range(vma, vma_addr,
+							   pfn, size,
+							   vma->vm_page_prot))
+					return len;
+				len += size;
+				page_count -= (pos - pfn);
+			}
+			if (page_count > 0) {
+				/* we hit a page which is not ram, replacing
+				   with an empty one */
+				vma_addr = vma->vm_start + len;
+				if (remap_oldmem_pfn_range(vma, vma_addr,
+							   emptypage_pfn,
+							   PAGE_SIZE,
+							   vma->vm_page_prot))
+					return len;
+				len += PAGE_SIZE;
+				pfn = pos + 1;
+				page_count--;
+			}
+		}
+	}
+	return len;
+}
+
 static int mmap_vmcore(struct file *file, struct vm_area_struct *vma)
 {
 	size_t size = vma->vm_end - vma->vm_start;
@@ -383,17 +423,33 @@ static int mmap_vmcore(struct file *file, struct vm_area_struct *vma)
 
 	list_for_each_entry(m, &vmcore_list, list) {
 		if (start < m->offset + m->size) {
-			u64 paddr = 0;
+			u64 paddr = 0, original_len;
+			unsigned long pfn, page_count;
 
 			tsz = min_t(size_t, m->offset + m->size - start, size);
 			paddr = m->paddr + start - m->offset;
-			if (remap_oldmem_pfn_range(vma, vma->vm_start + len,
-						   paddr >> PAGE_SHIFT, tsz,
-						   vma->vm_page_prot))
-				goto fail;
+
+			/* check if oldmem_pfn_is_ram was registered to avoid
+			   looping over all pages without a reason */
+			if (oldmem_pfn_is_ram) {
+				pfn = paddr >> PAGE_SHIFT;
+				page_count = tsz >> PAGE_SHIFT;
+				original_len = len;
+				len = remap_oldmem_pfn_checked(vma, len, pfn,
+							       page_count);
+				if (len != original_len + tsz)
+					goto fail;
+			} else {
+				if (remap_oldmem_pfn_range(vma,
+							   vma->vm_start + len,
Quoted 8 lines

fs/proc/vmcore.c static int mmap_vmcore(struct file *file, struct vm_area_struct *vma) · line 448

Quoted 4 lines
fs/proc/vmcore.c +4 -0
+							   paddr >> PAGE_SHIFT,
+							   tsz,
+							   vma->vm_page_prot))
+					goto fail;

Why are we defining both remap_oldmem_pfn_checked()? Can't we just modify remap_oldmem_pfn_range() to *always* check for if pfn_is_zero_filled() and map accordingly.

I wanted to preserve the direct path without the check to make things faster when the pfn_is_ram() handler was not registered. oldmem is huge sometimes and issuing a single call per pfn can cost us something.

Quoted 3 lines

Thanks
Vivek

Signature · 1 line
  Vitaly
#19 lore raw
Quoted 4 lines · Vitaly Kuznetsov
Quoted 2 lines

Also I am wondering why it was not done as part of copy_oldmem_page() so that respective arch could hide all the details.

Afaiac that wouldn't solve the mmap issue I'm trying to address but we can ask Olaf why he preferred pfn_is_ram() path.

Every copy_oldmem_page would need to know about the pfn_is_ram function, so I think its better to keep that part of the code private to fs/proc/vmcore.c

Perhaps pfn_is_ram could be named pfn_is_backed_by_ram, but the comments make it clear what the function does.

Olaf

#20 lore raw
In reply to Vitaly Kuznetsov
Quoted 4 lines · Vitaly Kuznetsov
Quoted 2 lines

Also I am wondering why it was not done as part of copy_oldmem_page() so that respective arch could hide all the details.

Afaiac that wouldn't solve the mmap issue I'm trying to address but we can ask Olaf why he preferred pfn_is_ram() path.

Every copy_oldmem_page would need to know about the pfn_is_ram function, so I think its better to keep that part of the code private to fs/proc/vmcore.c

Perhaps pfn_is_ram could be named pfn_is_backed_by_ram, but the comments make it clear what the function does.

Olaf