uml: Eliminate kernel allocator wrappers

UML had two wrapper procedures for kmalloc, um_kmalloc and um_kmalloc_atomic
because the flag constants weren't available in userspace code.
kern_constants.h had made kernel constants available for a long time, so there
is no need for these wrappers any more.  Rather, userspace code calls kmalloc
directly with the userspace versions of the gfp flags.

kmalloc isn't a real procedure, so I had to essentially copy the inline
wrapper around __kmalloc.

vmalloc also had its own wrapper for no good reason.  This is now gone.

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>

diff --git a/arch/um/drivers/cow_sys.h b/arch/um/drivers/cow_sys.h
index 15453845d2bab85eaa1c1a15f59740779eb225f3..ca8c9e11a39b9f94361b10c6739e8712ec3a932c 100644 (file)
--- a/arch/um/drivers/cow_sys.h
+++ b/arch/um/drivers/cow_sys.h
@@ -8,7 +8,7 @@
 
 static inline void *cow_malloc(int size)
 {
-       return um_kmalloc(size);
+       return kmalloc(size, UM_GFP_KERNEL);
 }
 
 static inline void cow_free(void *ptr)

diff --git a/arch/um/drivers/daemon_user.c b/arch/um/drivers/daemon_user.c
index b869e3899683e548d6f98e17ec9959e801ef8a6b..8d2008f0668282e7c9bcc4d61d95ff9e08fbe619 100644 (file)
--- a/arch/um/drivers/daemon_user.c
+++ b/arch/um/drivers/daemon_user.c
@@ -35,7 +35,7 @@ static struct sockaddr_un *new_addr(void *name, int len)
 {
        struct sockaddr_un *sun;
 
-       sun = um_kmalloc(sizeof(struct sockaddr_un));
+       sun = kmalloc(sizeof(struct sockaddr_un), UM_GFP_KERNEL);
        if(sun == NULL){
                printk("new_addr: allocation of sockaddr_un failed\n");
                return NULL;
@@ -83,7 +83,7 @@ static int connect_to_switch(struct daemon_data *pri)
                goto out_close;
        }
 
-       sun = um_kmalloc(sizeof(struct sockaddr_un));
+       sun = kmalloc(sizeof(struct sockaddr_un), UM_GFP_KERNEL);
        if(sun == NULL){
                printk("new_addr: allocation of sockaddr_un failed\n");
                err = -ENOMEM;

diff --git a/arch/um/drivers/fd.c b/arch/um/drivers/fd.c
index 7f083ec47a4f03bec098b528b000c1be0fb327d4..39c01ffd45c92a7cb9d2b9a52fb57a0eb2dea2e7 100644 (file)
--- a/arch/um/drivers/fd.c
+++ b/arch/um/drivers/fd.c
@@ -37,7 +37,7 @@ static void *fd_init(char *str, int device, const struct chan_opts *opts)
                printk("fd_init : couldn't parse file descriptor '%s'\n", str);
                return(NULL);
        }
-       data = um_kmalloc(sizeof(*data));
+       data = kmalloc(sizeof(*data), UM_GFP_KERNEL);
        if(data == NULL) return(NULL);
        *data = ((struct fd_chan) { .fd         = n,
                                    .raw        = opts->raw });

diff --git a/arch/um/drivers/mcast_user.c b/arch/um/drivers/mcast_user.c
index d319db16d4ec30af79eb58f161540d7e68a5d0b2..236a3dfc297d513dbbefbfab729932906455b0df 100644 (file)
--- a/arch/um/drivers/mcast_user.c
+++ b/arch/um/drivers/mcast_user.c
@@ -30,7 +30,7 @@ static struct sockaddr_in *new_addr(char *addr, unsigned short port)
 {
        struct sockaddr_in *sin;
 
-       sin = um_kmalloc(sizeof(struct sockaddr_in));
+       sin = kmalloc(sizeof(struct sockaddr_in), UM_GFP_KERNEL);
        if(sin == NULL){
                printk("new_addr: allocation of sockaddr_in failed\n");
                return NULL;

diff --git a/arch/um/drivers/net_user.c b/arch/um/drivers/net_user.c
index 6fa948ba969d137a16f4513f014f0cb5c0334f80..da946e3e1bf26322a3d7078c53868ca005378ec2 100644 (file)
--- a/arch/um/drivers/net_user.c
+++ b/arch/um/drivers/net_user.c
@@ -217,7 +217,7 @@ static void change(char *dev, char *what, unsigned char *addr,
                netmask[2], netmask[3]);
 
        output_len = UM_KERN_PAGE_SIZE;
-       output = um_kmalloc(output_len);
+       output = kmalloc(output_len, UM_GFP_KERNEL);
        if(output == NULL)
                printk("change : failed to allocate output buffer\n");
 

diff --git a/arch/um/drivers/port_user.c b/arch/um/drivers/port_user.c
index 29250beba4296bc55a41b4167eefeaa3393e528f..c799b00012c7fa898aa4ae8fa4711d36603ad93c 100644 (file)
--- a/arch/um/drivers/port_user.c
+++ b/arch/um/drivers/port_user.c
@@ -50,7 +50,7 @@ static void *port_init(char *str, int device, const struct chan_opts *opts)
        if(kern_data == NULL)
                return NULL;
 
-       data = um_kmalloc(sizeof(*data));
+       data = kmalloc(sizeof(*data), UM_GFP_KERNEL);
        if(data == NULL)
                goto err;
 

diff --git a/arch/um/drivers/pty.c b/arch/um/drivers/pty.c
index 640bcdaad9f4f14e1f6a186257a7ace64f63a463..1e3fd619a83732f53244f1b025661557bc020955 100644 (file)
--- a/arch/um/drivers/pty.c
+++ b/arch/um/drivers/pty.c
@@ -29,7 +29,7 @@ static void *pty_chan_init(char *str, int device, const struct chan_opts *opts)
 {
        struct pty_chan *data;
 
-       data = um_kmalloc(sizeof(*data));
+       data = kmalloc(sizeof(*data), UM_GFP_KERNEL);
        if (data == NULL)
                return NULL;
 

diff --git a/arch/um/drivers/slip_user.c b/arch/um/drivers/slip_user.c
index edc2de3ee2f454b355dcab8883951a66dc45d0ae..c0b73c28cff0f7e5615a27f13a339752287fffad 100644 (file)
--- a/arch/um/drivers/slip_user.c
+++ b/arch/um/drivers/slip_user.c
@@ -91,7 +91,7 @@ static int slip_tramp(char **argv, int fd)
        pid = err;
 
        output_len = UM_KERN_PAGE_SIZE;
-       output = um_kmalloc(output_len);
+       output = kmalloc(output_len, UM_GFP_KERNEL);
        if(output == NULL){
                printk("slip_tramp : failed to allocate output buffer\n");
                os_kill_process(pid, 1);

diff --git a/arch/um/drivers/tty.c b/arch/um/drivers/tty.c
index c07d0d56278029ea8ed040c6cc5b17ce4e520723..a9f87e19c5bf9f283faf134f52ad9f0de4b5fdd1 100644 (file)
--- a/arch/um/drivers/tty.c
+++ b/arch/um/drivers/tty.c
@@ -29,7 +29,7 @@ static void *tty_chan_init(char *str, int device, const struct chan_opts *opts)
        }
        str++;
 
-       data = um_kmalloc(sizeof(*data));
+       data = kmalloc(sizeof(*data), UM_GFP_KERNEL);
        if(data == NULL)
                return NULL;
        *data = ((struct tty_chan) { .dev       = str,

diff --git a/arch/um/include/common-offsets.h b/arch/um/include/common-offsets.h
index 7376ee44e330a878f55737ef7a5ef3529d74ccd1..6eee343e53eb1d446b29f59b4badce413fbc9956 100644 (file)
--- a/arch/um/include/common-offsets.h
+++ b/arch/um/include/common-offsets.h
@@ -27,6 +27,9 @@ DEFINE(UM_ELFCLASS64, ELFCLASS64);
 
 DEFINE(UM_NR_CPUS, NR_CPUS);
 
+DEFINE(UM_GFP_KERNEL, GFP_KERNEL);
+DEFINE(UM_GFP_ATOMIC, GFP_ATOMIC);
+
 /* For crypto assembler code. */
 DEFINE(crypto_tfm_ctx_offset, offsetof(struct crypto_tfm, __crt_ctx));
 

diff --git a/arch/um/include/um_malloc.h b/arch/um/include/um_malloc.h
index e6d7c5aa3f4e26202e70e5fd2b325adcff03dbfa..0ad17cb83d96ef6b0ace0a4ea800113a8cc05040 100644 (file)
--- a/arch/um/include/um_malloc.h
+++ b/arch/um/include/um_malloc.h
@@ -6,11 +6,17 @@
 #ifndef __UM_MALLOC_H__
 #define __UM_MALLOC_H__
 
-extern void *um_kmalloc(int size);
-extern void *um_kmalloc_atomic(int size);
+#include "kern_constants.h"
+
+extern void *__kmalloc(int size, int flags);
+static inline void *kmalloc(int size, int flags)
+{
+       return __kmalloc(size, flags);
+}
+
 extern void kfree(const void *ptr);
 
-extern void *um_vmalloc(int size);
+extern void *vmalloc(unsigned long size);
 extern void vfree(void *ptr);
 
 #endif /* __UM_MALLOC_H__ */

diff --git a/arch/um/kernel/irq.c b/arch/um/kernel/irq.c
index dba04d88b4320bde93b7ce4bee3f728193fd257f..9870febdbead3897b2ed9257ba0548d7e0389159 100644 (file)
--- a/arch/um/kernel/irq.c
+++ b/arch/um/kernel/irq.c
@@ -30,7 +30,6 @@
 #include "irq_kern.h"
 #include "os.h"
 #include "sigio.h"
-#include "um_malloc.h"
 #include "misc_constants.h"
 #include "as-layout.h"
 

diff --git a/arch/um/kernel/process.c b/arch/um/kernel/process.c
index 8d2c5496532b942899ad6201665431f6f5aceccc..bfa52f206bb6438d520316db40c70e9a22ca51bb 100644 (file)
--- a/arch/um/kernel/process.c
+++ b/arch/um/kernel/process.c
@@ -46,7 +46,6 @@
 #include "mode.h"
 #include "mode_kern.h"
 #include "choose-mode.h"
-#include "um_malloc.h"
 
 /* This is a per-cpu array.  A processor only modifies its entry and it only
  * cares about its entry, so it's OK if another processor is modifying its
@@ -262,21 +261,6 @@ void dump_thread(struct pt_regs *regs, struct user *u)
 {
 }
 
-void *um_kmalloc(int size)
-{
-       return kmalloc(size, GFP_KERNEL);
-}
-
-void *um_kmalloc_atomic(int size)
-{
-       return kmalloc(size, GFP_ATOMIC);
-}
-
-void *um_vmalloc(int size)
-{
-       return vmalloc(size);
-}
-
 int __cant_sleep(void) {
        return in_atomic() || irqs_disabled() || in_interrupt();
        /* Is in_interrupt() really needed? */

diff --git a/arch/um/os-Linux/drivers/ethertap_user.c b/arch/um/os-Linux/drivers/ethertap_user.c
index cac01b31ea95864a2d9c6d6cf36108800d230a6b..61d3953c7ac92410aee83a79a6efcd7af50383e1 100644 (file)
--- a/arch/um/os-Linux/drivers/ethertap_user.c
+++ b/arch/um/os-Linux/drivers/ethertap_user.c
@@ -54,7 +54,7 @@ static void etap_change(int op, unsigned char *addr, unsigned char *netmask,
                return;
        }
 
-       output = um_kmalloc(UM_KERN_PAGE_SIZE);
+       output = kmalloc(UM_KERN_PAGE_SIZE, UM_GFP_KERNEL);
        if(output == NULL)
                printk("etap_change : Failed to allocate output buffer\n");
        read_output(fd, output, UM_KERN_PAGE_SIZE);
@@ -166,7 +166,7 @@ static int etap_open(void *data)
        err = etap_tramp(pri->dev_name, pri->gate_addr, control_fds[0], 
                         control_fds[1], data_fds[0], data_fds[1]);
        output_len = UM_KERN_PAGE_SIZE;
-       output = um_kmalloc(output_len);
+       output = kmalloc(output_len, UM_GFP_KERNEL);
        read_output(control_fds[0], output, output_len);
 
        if(output == NULL)

diff --git a/arch/um/os-Linux/helper.c b/arch/um/os-Linux/helper.c
index 9cf48d0577cc4f82d1ef674a287123c28c059f05..d81af7b8587a8331cae925c71802841ad181cb1e 100644 (file)
--- a/arch/um/os-Linux/helper.c
+++ b/arch/um/os-Linux/helper.c
@@ -72,8 +72,8 @@ int run_helper(void (*pre_exec)(void *), void *pre_data, char **argv)
        data.pre_data = pre_data;
        data.argv = argv;
        data.fd = fds[1];
-       data.buf = __cant_sleep() ? um_kmalloc_atomic(PATH_MAX) :
-                                       um_kmalloc(PATH_MAX);
+       data.buf = __cant_sleep() ? kmalloc(PATH_MAX, UM_GFP_ATOMIC) :
+                                       kmalloc(PATH_MAX, UM_GFP_KERNEL);
        pid = clone(helper_child, (void *) sp, CLONE_VM | SIGCHLD, &data);
        if (pid < 0) {
                ret = -errno;

diff --git a/arch/um/os-Linux/main.c b/arch/um/os-Linux/main.c
index fb510d40480cc2dbec1dc6fd0651364de3981808..e85f4995a011a16a226f0963941b2bbf0355dea0 100644 (file)
--- a/arch/um/os-Linux/main.c
+++ b/arch/um/os-Linux/main.c
@@ -235,8 +235,8 @@ void *__wrap_malloc(int size)
                return __real_malloc(size);
        else if(size <= UM_KERN_PAGE_SIZE)
                /* finding contiguous pages can be hard*/
-               ret = um_kmalloc(size);
-       else ret = um_vmalloc(size);
+               ret = kmalloc(size, UM_GFP_KERNEL);
+       else ret = vmalloc(size);
 
        /* glibc people insist that if malloc fails, errno should be
         * set by malloc as well. So we do.

diff --git a/arch/um/os-Linux/sigio.c b/arch/um/os-Linux/sigio.c
index 2c23cb261188f2249995e4fc60ea92c77c40b6f0..dc03e9cccb630146c0d62504d5ff4ea5e2c14b50 100644 (file)
--- a/arch/um/os-Linux/sigio.c
+++ b/arch/um/os-Linux/sigio.c
@@ -105,7 +105,7 @@ static int need_poll(struct pollfds *polls, int n)
        if(n <= polls->size)
                return 0;
 
-       new = um_kmalloc_atomic(n * sizeof(struct pollfd));
+       new = kmalloc(n * sizeof(struct pollfd), UM_GFP_ATOMIC);
        if(new == NULL){
                printk("need_poll : failed to allocate new pollfds\n");
                return -ENOMEM;
@@ -233,7 +233,7 @@ static struct pollfd *setup_initial_poll(int fd)
 {
        struct pollfd *p;
 
-       p = um_kmalloc(sizeof(struct pollfd));
+       p = kmalloc(sizeof(struct pollfd), UM_GFP_KERNEL);
        if (p == NULL) {
                printk("setup_initial_poll : failed to allocate poll\n");
                return NULL;