uml: convert libc layer to call read and write

This patch converts calls in the os layer to os_{read,write}_file to calls
directly to libc read() and write() where it is clear that the I/O buffer is
in the kernel.

We can do that here instead of calling os_{read,write}_file_k since we are in
libc code and can call libc directly.

With the change in the calls, error handling needs to be changed to refer to
errno directly rather than the return value of the call.

CATCH_EINTR wrappers were also added where needed.

Signed-off-by: Jeff Dike <jdike@linux.intel.com>
Cc: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

2 files changed, 18 insertions, 10 deletions

diff --git a/arch/um/os-Linux/skas/mem.c b/arch/um/os-Linux/skas/mem.c
index 470ec531aa5d..6cdfda807b65 100644
--- a/arch/um/os-Linux/skas/mem.c
+++ b/arch/um/os-Linux/skas/mem.c
@@ -6,6 +6,7 @@
 #include <signal.h>
 #include <errno.h>
 #include <string.h>
+#include <unistd.h>
 #include <sys/mman.h>
 #include <sys/wait.h>
 #include <asm/page.h>
@@ -199,9 +200,11 @@ int map(struct mm_id * mm_idp, unsigned long virt, unsigned long len,
                                            .fd  = phys_fd,
                                            .offset= offset
                                          } } } );
-                ret = os_write_file(fd, &map, sizeof(map));
-                if(ret != sizeof(map))
+                CATCH_EINTR(ret = write(fd, &map, sizeof(map)));
+                if(ret != sizeof(map)){
+                        ret = -errno;
                         printk("map : /proc/mm map failed, err = %d\n", -ret);
+                }
                 else ret = 0;
         }
         else {
@@ -231,9 +234,11 @@ int unmap(struct mm_id * mm_idp, void *addr, unsigned long len, int done,
                                            { .addr      =
                                              (unsigned long) addr,
                                              .len               = len } } } );
-                ret = os_write_file(fd, &unmap, sizeof(unmap));
-                if(ret != sizeof(unmap))
+                CATCH_EINTR(ret = write(fd, &unmap, sizeof(unmap)));
+                if(ret != sizeof(unmap)){
+                        ret = -errno;
                         printk("unmap - proc_mm write returned %d\n", ret);
+                }
                 else ret = 0;
         }
         else {
@@ -266,9 +271,11 @@ int protect(struct mm_id * mm_idp, unsigned long addr, unsigned long len,
                                                .len     = len,
                                                .prot    = prot } } } );
 
-                ret = os_write_file(fd, &protect, sizeof(protect));
-                if(ret != sizeof(protect))
+                CATCH_EINTR(ret = write(fd, &protect, sizeof(protect)));
+                if(ret != sizeof(protect)){
+                        ret = -errno;
                         printk("protect failed, err = %d", -ret);
+                }
                 else ret = 0;
         }
         else {
diff --git a/arch/um/os-Linux/skas/process.c b/arch/um/os-Linux/skas/process.c
index 47852698d5e1..5b1943dc15e9 100644
--- a/arch/um/os-Linux/skas/process.c
+++ b/arch/um/os-Linux/skas/process.c
@@ -431,12 +431,13 @@ void map_stub_pages(int fd, unsigned long code,
                                           .fd      = code_fd,
                                           .offset  = code_offset
         } } });
-        n = os_write_file(fd, &mmop, sizeof(mmop));
+        CATCH_EINTR(n = write(fd, &mmop, sizeof(mmop)));
         if(n != sizeof(mmop)){
+                n = errno;
                 printk("mmap args - addr = 0x%lx, fd = %d, offset = %llx\n",
                        code, code_fd, (unsigned long long) code_offset);
                 panic("map_stub_pages : /proc/mm map for code failed, "
-                      "err = %d\n", -n);
+                      "err = %d\n", n);
         }
 
         if ( stack ) {
@@ -453,10 +454,10 @@ void map_stub_pages(int fd, unsigned long code,
                                       .fd      = map_fd,
                                       .offset  = map_offset
                 } } });
-                n = os_write_file(fd, &mmop, sizeof(mmop));
+                CATCH_EINTR(n = write(fd, &mmop, sizeof(mmop)));
                 if(n != sizeof(mmop))
                         panic("map_stub_pages : /proc/mm map for data failed, "
-                              "err = %d\n", -n);
+                              "err = %d\n", errno);
         }
 }