Cross Memory Attach v3

Hi Andrew,

Resending with CC's as you requested. Have added information about a man page and what is required for arches other than x86 and powerpc which have already been done.

Just as a reminder of what has happened so far, repeating some content from previous emails about it:

The basic idea behind cross memory attach is to allow MPI programs doing intra-node communication to do a single copy of the message rather than a double copy of the message via shared memory.

The following patch attempts to achieve this by allowing a destination process, given an address and size from a source process, to copy memory directly from the source process into its own address space via a system call. There is also a symmetrical ability to copy from the current process's address space into a destination process's address space.

...

 arch/powerpc/include/asm/systbl.h  |    2 
 arch/powerpc/include/asm/unistd.h  |    4 
 arch/x86/include/asm/unistd_32.h   |    4 
 arch/x86/kernel/syscall_table_32.S |    2 
 fs/aio.c                           |    4 
 fs/compat.c                        |    7 
 fs/read_write.c                    |    8 
 include/linux/compat.h             |    3 
 include/linux/fs.h                 |    7 
 include/linux/syscalls.h           |   13 +
 mm/Makefile                        |    3 
 mm/process_vm_access.c             |  446 +++++++++++++++++++++++++++++++++++++
 security/keys/compat.c             |    2 
 security/keys/keyctl.c             |    2 
 14 files changed, 490 insertions(+), 17 deletions(-)

Quoted 25 lines

The following patch attempts to achieve this by allowing a destination process, given an address and size from a source process, to copy memory directly from the source process into its own address space via a system call. There is also a symmetrical ability to copy from the current process's address space into a destination process's address space.

...

 arch/powerpc/include/asm/systbl.h  |    2 
 arch/powerpc/include/asm/unistd.h  |    4 
 arch/x86/include/asm/unistd_32.h   |    4 
 arch/x86/kernel/syscall_table_32.S |    2 
 fs/aio.c                           |    4 
 fs/compat.c                        |    7 
 fs/read_write.c                    |    8 
 include/linux/compat.h             |    3 
 include/linux/fs.h                 |    7 
 include/linux/syscalls.h           |   13 +
 mm/Makefile                        |    3 
 mm/process_vm_access.c             |  446
+++++++++++++++++++++++++++++++++++++
security/keys/compat.c             |    2
security/keys/keyctl.c             |    2 14 files changed, 490

Quoted 1 line

insertions(+), 17 deletions(-)

Confused. Why no arch/x86/include/asm/unistd_64.h wire-up?

...

mm/process_vm_access.c new file +75 -0

+/*
+ * process_vm_rw_pages - read/write pages from task specified
+ * @task: task to read/write from
+ * @mm: mm for task
+ * @process_pages: struct pages area that can store at least
+ *  nr_pages_to_copy struct page pointers
+ * @pa: address of page in task to start copying from/to
+ * @start_offset: offset in page to start copying from/to
+ * @len: number of bytes to copy
+ * @lvec: iovec array specifying where to copy to/from
+ * @lvec_cnt: number of elements in iovec array
+ * @lvec_current: index in iovec array we are up to
+ * @lvec_offset: offset in bytes from current iovec iov_base we are up to
+ * @vm_write: 0 means copy from, 1 means copy to
+ * @nr_pages_to_copy: number of pages to copy
+ */
+static ssize_t process_vm_rw_pages(struct task_struct *task,
+				   struct mm_struct *mm,
+				   struct page **process_pages,
+				   unsigned long pa,
+				   unsigned long start_offset,
+				   unsigned long len,
+				   const struct iovec *lvec,
+				   unsigned long lvec_cnt,
+				   unsigned long *lvec_current,
+				   size_t *lvec_offset,
+				   int vm_write,
+				   unsigned int nr_pages_to_copy)
+{
+	int pages_pinned;
+	void *target_kaddr;
+	int pgs_copied = 0;
+	int j;
+	int ret;
+	ssize_t bytes_to_copy;
+	ssize_t bytes_copied = 0;
+	ssize_t rc = -EFAULT;
+
+	/* Get the pages we're interested in */
+	down_read(&mm->mmap_sem);
+	pages_pinned = get_user_pages(task, mm, pa,
+				      nr_pages_to_copy,
+				      vm_write, 0, process_pages, NULL);
+	up_read(&mm->mmap_sem);
+
+	if (pages_pinned != nr_pages_to_copy)
+		goto end;
+
+	/* Do the copy for each page */
+	for (pgs_copied = 0;
+	     (pgs_copied < nr_pages_to_copy) && (*lvec_current < lvec_cnt);
+	     pgs_copied++) {
+		/* Make sure we have a non zero length iovec */
+		while (*lvec_current < lvec_cnt
+		       && lvec[*lvec_current].iov_len == 0)
+			(*lvec_current)++;
+		if (*lvec_current == lvec_cnt)
+			break;
+
+		/*
+		 * Will copy smallest of:
+		 * - bytes remaining in page
+		 * - bytes remaining in destination iovec
+		 */
+		bytes_to_copy = min_t(ssize_t, PAGE_SIZE - start_offset,
+				      len - bytes_copied);
+		bytes_to_copy = min_t(ssize_t, bytes_to_copy,
+				      lvec[*lvec_current].iov_len
+				      - *lvec_offset);
+
+		target_kaddr = kmap(process_pages[pgs_copied]) + start_offset;
+
+		if (vm_write)
+			ret = copy_from_user(target_kaddr,
+					     lvec[*lvec_current].iov_base

mm/process_vm_access.c new file +67 -0

+		}
+		bytes_copied += bytes_to_copy;
+		*lvec_offset += bytes_to_copy;
+		if (*lvec_offset == lvec[*lvec_current].iov_len) {
+			/*
+			 * Need to copy remaining part of page into the
+			 * next iovec if there are any bytes left in page
+			 */
+			(*lvec_current)++;
+			*lvec_offset = 0;
+			start_offset = (start_offset + bytes_to_copy)
+				% PAGE_SIZE;
+			if (start_offset)
+				pgs_copied--;
+		} else {
+			start_offset = 0;
+		}
+	}
+
+	rc = bytes_copied;
+
+end:
+	if (vm_write) {
+		for (j = 0; j < pages_pinned; j++) {
+			if (j < pgs_copied)
+				set_page_dirty_lock(process_pages[j]);
+			put_page(process_pages[j]);
+		}
+	} else {
+		for (j = 0; j < pages_pinned; j++)
+			put_page(process_pages[j]);
+	}
+
+	return rc;
+}
+
 
...
 
+static ssize_t process_vm_rw_single_vec(unsigned long addr,
+					unsigned long len,
+					const struct iovec *lvec,
+					unsigned long lvec_cnt,
+					unsigned long *lvec_current,
+					size_t *lvec_offset,
+					struct page **process_pages,
+					struct mm_struct *mm,
+					struct task_struct *task,
+					int vm_write)
+{
+	unsigned long pa = addr & PAGE_MASK;
+	unsigned long start_offset = addr - pa;
+	unsigned long nr_pages;
+	ssize_t bytes_copied = 0;
+	ssize_t rc;
+	unsigned long nr_pages_copied = 0;
+	unsigned long nr_pages_to_copy;
+	unsigned long max_pages_per_loop = PVM_MAX_KMALLOC_PAGES
+		/ sizeof(struct pages *);
+
+
+	/* Work out address and page range required */
+	if (len == 0)
+		return 0;
+	nr_pages = (addr + len - 1) / PAGE_SIZE - addr / PAGE_SIZE + 1;
+
+
+	while ((nr_pages_copied < nr_pages) && (*lvec_current < lvec_cnt)) {
+		nr_pages_to_copy = min(nr_pages - nr_pages_copied,
+				       max_pages_per_loop);

mm/process_vm_access.c new file +36 -0

+	}
+
+	rc = bytes_copied;
+	return rc;
+}
+
+static ssize_t process_vm_rw(pid_t pid, const struct iovec *lvec,
+			     unsigned long liovcnt,
+			     const struct iovec *rvec,
+			     unsigned long riovcnt,
+			     unsigned long flags, int vm_write)
+{
+	struct task_struct *task;
+	struct page **process_pages = NULL;
+	struct mm_struct *mm;
+	unsigned long i;
+	ssize_t rc;
+	ssize_t bytes_copied;
+	unsigned long nr_pages = 0;
+	unsigned long nr_pages_iov;
+	unsigned long iov_l_curr_idx = 0;
+	size_t iov_l_curr_offset = 0;
+	ssize_t iov_len;
+
+	/*
+	 * Work out how many pages of struct pages we're going to need
+	 * when eventually calling get_user_pages
+	 */
+	for (i = 0; i < riovcnt; i++) {
+		iov_len = rvec[i].iov_len;
+		if (iov_len > 0) {
+			nr_pages_iov = ((unsigned long)rvec[i].iov_base
+					+ iov_len)
+				/ PAGE_SIZE - (unsigned long)rvec[i].iov_base
+				/ PAGE_SIZE + 1;
+			nr_pages = max(nr_pages, nr_pages_iov);

mm/process_vm_access.c new file +53 -0

+	if (!process_pages)
+		return -ENOMEM;
+
+	/* Get process information */
+	rcu_read_lock();
+	task = find_task_by_vpid(pid);
+	if (task)
+		get_task_struct(task);
+	rcu_read_unlock();
+	if (!task) {
+		rc = -ESRCH;
+		goto free_proc_pages;
+	}
+
+	task_lock(task);
+	if (__ptrace_may_access(task, PTRACE_MODE_ATTACH)) {
+		task_unlock(task);
+		rc = -EPERM;
+		goto put_task_struct;
+	}
+	mm = task->mm;
+
+	if (!mm || (task->flags & PF_KTHREAD)) {
+		task_unlock(task);
+		rc = -EINVAL;
+		goto put_task_struct;
+	}
+
+	atomic_inc(&mm->mm_users);
+	task_unlock(task);
+
+	rc = 0;
+	for (i = 0; i < riovcnt && iov_l_curr_idx < liovcnt; i++) {
+		bytes_copied = process_vm_rw_single_vec(
+			(unsigned long)rvec[i].iov_base, rvec[i].iov_len,
+			lvec, liovcnt, &iov_l_curr_idx, &iov_l_curr_offset,
+			process_pages, mm, task, vm_write);
+		if (bytes_copied < 0) {
+			rc = bytes_copied;
+			goto put_mm;
+		} else {
+			rc += bytes_copied;
+		}
+	}
+
+put_mm:
+	mmput(mm);
+
+put_task_struct:
+	put_task_struct(task);
+
+
+free_proc_pages:

mm/process_vm_access.c new file +28 -0

+{
+	struct iovec iovstack_l[UIO_FASTIOV];
+	struct iovec iovstack_r[UIO_FASTIOV];
+	struct iovec *iov_l = iovstack_l;
+	struct iovec *iov_r = iovstack_r;
+	ssize_t rc;
+
+	if (flags != 0)
+		return -EINVAL;
+
+	/* Check iovecs */
+	if (vm_write)
+		rc = rw_copy_check_uvector(WRITE, lvec, liovcnt, UIO_FASTIOV,
+					   iovstack_l, &iov_l, 1);
+	else
+		rc = rw_copy_check_uvector(READ, lvec, liovcnt, UIO_FASTIOV,
+					   iovstack_l, &iov_l, 1);
+	if (rc <= 0)
+		goto free_iovecs;
+
+	rc = rw_copy_check_uvector(READ, rvec, riovcnt, UIO_FASTIOV,
+				   iovstack_r, &iov_r, 0);
+	if (rc <= 0)
+		goto free_iovecs;
+
+	rc = process_vm_rw(pid, iov_l, liovcnt, iov_r, riovcnt, flags,
+			    vm_write);
+

Quoted 37 lines · On Tue, 19 Jul 2011 00:35:37 +0930 Christopher Yeoh <[email protected]> wrote:

+/*
+ * process_vm_rw_pages - read/write pages from task specified
+ * @task: task to read/write from
+ * @mm: mm for task
+ * @process_pages: struct pages area that can store at least
+ * nr_pages_to_copy struct page pointers
+ * @pa: address of page in task to start copying from/to
+ * @start_offset: offset in page to start copying from/to
+ * @len: number of bytes to copy
+ * @lvec: iovec array specifying where to copy to/from
+ * @lvec_cnt: number of elements in iovec array
+ * @lvec_current: index in iovec array we are up to
+ * @lvec_offset: offset in bytes from current iovec iov_base we are up to
+ * @vm_write: 0 means copy from, 1 means copy to
+ * @nr_pages_to_copy: number of pages to copy
+ */

mm/process_vm_access.c new file +5 -0

+static ssize_t process_vm_rw_pages(struct task_struct *task,
+				   struct mm_struct *mm,
+				      - *lvec_offset);
.....
 
+
+		target_kaddr = kmap(process_pages[pgs_copied]) +

start_offset; +

mm/process_vm_access.c new file +3 -0

+		if (vm_write)
+			ret = copy_from_user(target_kaddr,
+

lvec[*lvec_current].iov_base

mm/process_vm_access.c new file +4 -0

+					     + *lvec_offset,
+					     bytes_to_copy);
+		else
+			ret =

copy_to_user(lvec[*lvec_current].iov_base

(quoted diff) +2 -0

+					   + *lvec_offset,
+					   target_kaddr,

bytes_to_copy);

mm/process_vm_access.c line 103

Quoted 4 lines

mm/process_vm_access.c new file +4 -0

+		kunmap(process_pages[pgs_copied]);
+		if (ret) {
+			pgs_copied++;
+			goto end;

afacit this will always return -EFAULT, even after copying some memory.

Is this a misdesign? Would it not be better to return the number of bytes actually copied, or -EFAULT is we weren't able to copy any? Like read().

That way, userspace can at least process the data which _was_ transferred, before retrying and then handling the fault. With the proposed interface this is not possible, and the data is lost.

And note that the function's kerneldoc doesn't document the return value at all! kerneldoc sucks that way - there's no formal place in the template, so people often ignore this important part of the function interface. Similarly, there's no kerneldoc template for preconditions such as irq on/off, locks which must be held, etc. So they don't get documented. But they're part of the interface.

mm/process_vm_access.c line 197

Quoted 5 lines

nr_pages_to_copy);

mm/process_vm_access.c new file +4 -0

+		start_offset = 0;
+
+		if (rc < 0)
+			return rc;

It's propagated here.

(CodingStyleNit: it's conventional to put {} around the single-line block in this case, btw).

Quoted 9 lines

mm/process_vm_access.c new file +5 -0

+
+	if (nr_pages == 0)
+		return 0;
+
+	/* For reliability don't try to kmalloc more than 2 pages

worth */

(quoted diff) +1 -0

+	process_pages = kmalloc(min_t(size_t,

PVM_MAX_KMALLOC_PAGES,

(quoted diff) +1 -0

+				      sizeof(struct pages

mm/process_vm_access.c line 249

Quoted 2 lines

*)*nr_pages),

mm/process_vm_access.c new file +1 -0

+				GFP_KERNEL);

You might get some speed benefit by optimising for the small copies here. Define a local on-stack array of N page*'s and point process_pages at that if the number of pages is <= N. Saves a malloc/free and is more cache-friendly. But only if the result is measurable!

Quoted 10 lines

mm/process_vm_access.c new file +3 -0

+
+static ssize_t process_vm_rw_check_iovecs(pid_t pid,
+					  const struct iovec

__user *lvec,

(quoted diff) +2 -0

+					  unsigned long liovcnt,
+					  const struct iovec

__user *rvec,

(quoted diff) +2 -0

+					  unsigned long riovcnt,
+					  unsigned long flags, int

vm_write)

I'm allergic to functions with "check" in their name. Check for what?

And one would expect a check_foo() to return a bool or an errno. This one returns a ssize_t! Weird! Interface documentation, please. Including return value semantics ;)

Quoted 45 lines · On Tue, 19 Jul 2011 00:35:37 +0930 Christopher Yeoh <[email protected]> wrote:

(quoted diff) +21 -0

+
+static ssize_t process_vm_rw(pid_t pid, const struct iovec *lvec,
+			     unsigned long liovcnt,
+			     const struct iovec *rvec,
+			     unsigned long riovcnt,
+			     unsigned long flags, int vm_write)
+{
+	struct task_struct *task;
+	struct page **process_pages = NULL;
+	struct mm_struct *mm;
+	unsigned long i;
+	ssize_t rc;
+	ssize_t bytes_copied;
+	unsigned long nr_pages = 0;
+	unsigned long nr_pages_iov;
+	unsigned long iov_l_curr_idx = 0;
+	size_t iov_l_curr_offset = 0;
+	ssize_t iov_len;
+
+	/*
+	 * Work out how many pages of struct pages we're going to

need

(quoted diff) +6 -0

+	 * when eventually calling get_user_pages
+	 */
+	for (i = 0; i < riovcnt; i++) {
+		iov_len = rvec[i].iov_len;
+		if (iov_len > 0) {
+			nr_pages_iov = ((unsigned

long)rvec[i].iov_base

(quoted diff) +2 -0

+					+ iov_len)
+				/ PAGE_SIZE - (unsigned

long)rvec[i].iov_base

(quoted diff) +9 -0

+				/ PAGE_SIZE + 1;
+			nr_pages = max(nr_pages, nr_pages_iov);
+		}
+	}
+
+	if (nr_pages == 0)
+		return 0;
+
+	/* For reliability don't try to kmalloc more than 2 pages

worth */

(quoted diff) +1 -0

+	process_pages = kmalloc(min_t(size_t,

PVM_MAX_KMALLOC_PAGES,

(quoted diff) +1 -0

+				      sizeof(struct pages

Review

Quoted 2 lines

*)*nr_pages),

(quoted diff) +1 -0

+				GFP_KERNEL);

You might get some speed benefit by optimising for the small copies here. Define a local on-stack array of N page*'s and point process_pages at that if the number of pages is <= N. Saves a malloc/free and is more cache-friendly. But only if the result is measurable!

For arch maintainers there are some simple tests to be able to quickly verify that the syscalls are working correctly here:

http://ozlabs.org/~cyeoh/cma/cma-test-20110718.tgz

Quoted 2 lines · Christopher Yeoh

For arch maintainers there are some simple tests to be able to quickly verify that the syscalls are working correctly here:

I'm wiring up these new syscalls on m68k.

Quoted 1 line

http://ozlabs.org/~cyeoh/cma/cma-test-20110718.tgz

The included README talks about:

setup_process_readv_simple
setup_process_readv_iovec
setup_process_writev

while the actual test executables are called:

setup_process_vm_readv_simple
setup_process_vm_readv_iovec
setup_process_vm_writev

On m68k (ARAnyM), the first and third test succeed. The second one fails, though:

# Setting up target with num iovecs 10, test buffer size 100000 Target process is setup
Run the following to test:
./t_process_vm_readv_iovec 1574 10 0x800030b0 89 0x80003110 38302 0x8000c6b8 22423 0x80011e58 18864 0x80016810 583 0x80016a60 8054 0x800189e0 3417 0x80019740 368 0x800198b8 897 0x80019c40 7003

and in the other window:

# ./t_process_vm_readv_iovec 1574 10 0x800030b0 89 0x80003110 38302
0x8000c6b8 22423 0x80011e58 18864 0x80016810 583 0x80016a60 8054
0x800189e0 3417 0x80019740 368 0x800198b8 897 0x80019c40 7003
copy_from_process failed: Invalid argument

error code: 29
#

Any suggestions?

Quoted 17 lines · On Sun, 20 Nov 2011 11:16:17 +0100 Geert Uytterhoeven <[email protected]>…

Quoted 2 lines · Christopher Yeoh

For arch maintainers there are some simple tests to be able to quickly verify that the syscalls are working correctly here:

I'm wiring up these new syscalls on m68k.

On m68k (ARAnyM), the first and third test succeed. The second one fails, though:

# Setting up target with num iovecs 10, test buffer size 100000 Target process is setup
Run the following to test:
./t_process_vm_readv_iovec 1574 10 0x800030b0 89 0x80003110 38302 0x8000c6b8 22423 0x80011e58 18864 0x80016810 583 0x80016a60 8054 0x800189e0 3417 0x80019740 368 0x800198b8 897 0x80019c40 7003

Quoted 6 lines

and in the other window:

# ./t_process_vm_readv_iovec 1574 10 0x800030b0 89 0x80003110 38302
0x8000c6b8 22423 0x80011e58 18864 0x80016810 583 0x80016a60 8054
0x800189e0 3417 0x80019740 368 0x800198b8 897 0x80019c40 7003
copy_from_process failed: Invalid argument

That should say process_vm_readv instead of copy_from_process. The error message is fixed in the just updated test.

Quoted 4 lines

error code: 29
#

Any suggestions?

Given that the first and third tests succeed, I think the problem is with the iovec parameters. The -EINVAL is most likely coming from rw_copy_check_uvector. Any chance that something bad is happening to lvec/liovcnt or rvec/riovcnt in the wireup?

The iovecs are checked in process_vm_rw before the core of the process_vm_readv/writev code is called so should be easy to confirm if this is the problem.

The other couple of places where it could possibly come from is that for some reason the flags parameter ends up being non zero or when looking up the task the mm is NULL. But given that the first and second tests succeed I think its unlikely that either of these is the cause.

It turned out the flags parameter was non-zero, due to syscall() only supporting up to 5 parameters in the glibc I was using for testing.

I checked the eglibc sources (2.11.1-0ubuntu7.8), and it's still not fixed there,
although I could find a fix for a similar issue in klibc
(http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=334917).

Geert Uytterhoeven dixit:

Quoted 7 lines

It turned out the flags parameter was non-zero, due to syscall() only supporting up to 5 parameters in the glibc I was using for testing.

I checked the eglibc sources (2.11.1-0ubuntu7.8), and it's still not fixed there,
although I could find a fix for a similar issue in klibc
(http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=334917).

Does this work for you?

Index: eglibc-2.13/ports/sysdeps/unix/sysv/linux/m68k/syscall.S
===================================================================

ports/sysdeps/unix/sysv/linux/m68k/syscall.S    2011-12-04 14:36:26.000000000 +0000 renamed from ports/sysdeps/unix/sysv/linux/m68k/syscall.S       2011-12-04 14:36:16.000000000 +0000 +0 -0

@@ -24,9 +24,9 @@

       .text
 ENTRY (syscall)
       move.l 4(%sp), %d0      /* Load syscall number.  */

-       _DOARGS_5 (24)          /* Frob arguments.  */
+       _DOARGS_6 (28)          /* Frob arguments.  */
       trap &0                 /* Do the system call.  */
-       UNDOARGS_5              /* Unfrob arguments.  */
+       UNDOARGS_6              /* Unfrob arguments.  */ cmp.l &-4095, %d0       /* Check %d0 for error.  */ jcc SYSCALL_ERROR_LABEL /* Jump to error handler if negative.  */ rts                     /* Return to caller.  */

Index: eglibc-2.13/ports/sysdeps/unix/sysv/linux/m68k/syscall.S
===================================================================

ports/sysdeps/unix/sysv/linux/m68k/syscall.S +0 -0

@@ -24,9 +24,9 @@
 	.text

Quoted 10 lines · Thorsten Glaser

Index: eglibc-2.13/ports/sysdeps/unix/sysv/linux/m68k/syscall.S
===================================================================

ports/sysdeps/unix/sysv/linux/m68k/syscall.S +1 -1

@@ -24,9 +24,9 @@
 	.text
 ENTRY (syscall)
 	move.l 4(%sp), %d0	/* Load syscall number.  */
-	_DOARGS_5 (24)		/* Frob arguments.  */
+	_DOARGS_6 (28)		/* Frob arguments.  */

ports/sysdeps/unix/sysv/linux/m68k/syscall.S line 32

Quoted 6 lines

ports/sysdeps/unix/sysv/linux/m68k/syscall.S +1 -1

 	trap &0			/* Do the system call.  */
-	UNDOARGS_5		/* Unfrob arguments.  */
+	UNDOARGS_6		/* Unfrob arguments.  */
 	cmp.l &-4095, %d0	/* Check %d0 for error.  */
 	jcc SYSCALL_ERROR_LABEL	/* Jump to error handler if negative.  */
 	rts			/* Return to caller.  */

Thanks, installed.

Andreas Schwab dixit:

Quoted 12 lines

Quoted 10 lines · Thorsten Glaser

Index: eglibc-2.13/ports/sysdeps/unix/sysv/linux/m68k/syscall.S
===================================================================

ports/sysdeps/unix/sysv/linux/m68k/syscall.S +1 -1

@@ -24,9 +24,9 @@
 	.text
 ENTRY (syscall)
 	move.l 4(%sp), %d0	/* Load syscall number.  */
-	_DOARGS_5 (24)		/* Frob arguments.  */
+	_DOARGS_6 (28)		/* Frob arguments.  */

Quoted 8 lines

ports/sysdeps/unix/sysv/linux/m68k/syscall.S line 32

Quoted 6 lines

ports/sysdeps/unix/sysv/linux/m68k/syscall.S +1 -1

 	trap &0			/* Do the system call.  */
-	UNDOARGS_5		/* Unfrob arguments.  */
+	UNDOARGS_6		/* Unfrob arguments.  */
 	cmp.l &-4095, %d0	/* Check %d0 for error.  */
 	jcc SYSCALL_ERROR_LABEL	/* Jump to error handler if negative.  */
 	rts			/* Return to caller.  */

Thanks, installed.

(Where?) So, should $someone submit that to eglibc-ports and Debisn src:eglibc? Did it indeed do the trick?

Quoted 23 lines

Andreas Schwab dixit:

Quoted 20 lines

Quoted 6 lines · Thorsten Glaser

Index: eglibc-2.13/ports/sysdeps/unix/sysv/linux/m68k/syscall.S
===================================================================

ports/sysdeps/unix/sysv/linux/m68k/syscall.S +0 -0

@@ -24,9 +24,9 @@
 	.text

ports/sysdeps/unix/sysv/linux/m68k/syscall.S line 32

Quoted 10 lines

ports/sysdeps/unix/sysv/linux/m68k/syscall.S +2 -2

 ENTRY (syscall)
 	move.l 4(%sp), %d0	/* Load syscall number.  */
-	_DOARGS_5 (24)		/* Frob arguments.  */
+	_DOARGS_6 (28)		/* Frob arguments.  */
 	trap &0			/* Do the system call.  */
-	UNDOARGS_5		/* Unfrob arguments.  */
+	UNDOARGS_6		/* Unfrob arguments.  */
 	cmp.l &-4095, %d0	/* Check %d0 for error.  */
 	jcc SYSCALL_ERROR_LABEL	/* Jump to error handler if negative.  */
 	rts			/* Return to caller.  */

Thanks, installed.

Quoted 2 lines

(Where?) So, should $someone submit that to eglibc-ports and Debisn src:eglibc? Did it indeed do the trick?

This patch should be reported to [email protected]. If it also

needs to be applied to the Debian package quickly, please open a bug report in the Debian BTS.