[PATCH] kmemdup: some users

Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

7 files changed, 13 insertions, 22 deletions

diff --git a/arch/i386/kernel/process.c b/arch/i386/kernel/process.c
index 8c190ca7ae44..96cd0232e1e0 100644
--- a/arch/i386/kernel/process.c
+++ b/arch/i386/kernel/process.c
@@ -425,13 +425,12 @@ int copy_thread(int nr, unsigned long clone_flags, unsigned long esp,
 
         tsk = current;
         if (unlikely(test_tsk_thread_flag(tsk, TIF_IO_BITMAP))) {
-                p->thread.io_bitmap_ptr = kmalloc(IO_BITMAP_BYTES, GFP_KERNEL);
+                p->thread.io_bitmap_ptr = kmemdup(tsk->thread.io_bitmap_ptr,
+                                                IO_BITMAP_BYTES, GFP_KERNEL);
                 if (!p->thread.io_bitmap_ptr) {
                         p->thread.io_bitmap_max = 0;
                         return -ENOMEM;
                 }
-                memcpy(p->thread.io_bitmap_ptr, tsk->thread.io_bitmap_ptr,
-                        IO_BITMAP_BYTES);
                 set_tsk_thread_flag(p, TIF_IO_BITMAP);
         }
 
diff --git a/fs/posix_acl.c b/fs/posix_acl.c
index 6c8dcf7613fd..aec931e09973 100644
--- a/fs/posix_acl.c
+++ b/fs/posix_acl.c
@@ -58,11 +58,9 @@ posix_acl_clone(const struct posix_acl *acl, gfp_t flags)
         if (acl) {
                 int size = sizeof(struct posix_acl) + acl->a_count *
                            sizeof(struct posix_acl_entry);
-                clone = kmalloc(size, flags);
-                if (clone) {
-                        memcpy(clone, acl, size);
+                clone = kmemdup(acl, size, flags);
+                if (clone)
                         atomic_set(&clone->a_refcount, 1);
-                }
         }
         return clone;
 }
diff --git a/mm/mempolicy.c b/mm/mempolicy.c
index cf18f0942553..25788b1b7fcf 100644
--- a/mm/mempolicy.c
+++ b/mm/mempolicy.c
@@ -1324,12 +1324,11 @@ struct mempolicy *__mpol_copy(struct mempolicy *old)
         atomic_set(&new->refcnt, 1);
         if (new->policy == MPOL_BIND) {
                 int sz = ksize(old->v.zonelist);
-                new->v.zonelist = kmalloc(sz, SLAB_KERNEL);
+                new->v.zonelist = kmemdup(old->v.zonelist, sz, SLAB_KERNEL);
                 if (!new->v.zonelist) {
                         kmem_cache_free(policy_cache, new);
                         return ERR_PTR(-ENOMEM);
                 }
-                memcpy(new->v.zonelist, old->v.zonelist, sz);
         }
         return new;
 }
diff --git a/net/rxrpc/transport.c b/net/rxrpc/transport.c
index 465efc86fccf..94b2e2fe6fdb 100644
--- a/net/rxrpc/transport.c
+++ b/net/rxrpc/transport.c
@@ -381,11 +381,10 @@ static int rxrpc_incoming_msg(struct rxrpc_transport *trans,
 
                 /* allocate a new message record */
                 ret = -ENOMEM;
-                msg = kmalloc(sizeof(struct rxrpc_message), GFP_KERNEL);
+                msg = kmemdup(jumbomsg, sizeof(struct rxrpc_message), GFP_KERNEL);
                 if (!msg)
                         goto error;
 
-                memcpy(msg, jumbomsg, sizeof(*msg));
                 list_add_tail(&msg->link, msgq);
 
                 /* adjust the jumbo packet */
diff --git a/sound/pci/echoaudio/layla24_dsp.c b/sound/pci/echoaudio/layla24_dsp.c
index 7ec5b63d0dce..97e42e115147 100644
--- a/sound/pci/echoaudio/layla24_dsp.c
+++ b/sound/pci/echoaudio/layla24_dsp.c
@@ -302,11 +302,11 @@ static int switch_asic(struct echoaudio *chip, const struct firmware *asic)
 
         /*  Check to see if this is already loaded */
         if (asic != chip->asic_code) {
-                monitors = kmalloc(MONITOR_ARRAY_SIZE, GFP_KERNEL);
+                monitors = kmemdup(chip->comm_page->monitors,
+                                        MONITOR_ARRAY_SIZE, GFP_KERNEL);
                 if (! monitors)
                         return -ENOMEM;
 
-                memcpy(monitors, chip->comm_page->monitors, MONITOR_ARRAY_SIZE);
                 memset(chip->comm_page->monitors, ECHOGAIN_MUTED,
                        MONITOR_ARRAY_SIZE);
 
diff --git a/sound/usb/usbaudio.c b/sound/usb/usbaudio.c
index 49248fa7aef4..a42acf6d7b68 100644
--- a/sound/usb/usbaudio.c
+++ b/sound/usb/usbaudio.c
@@ -2046,10 +2046,9 @@ int snd_usb_ctl_msg(struct usb_device *dev, unsigned int pipe, __u8 request,
         void *buf = NULL;
 
         if (size > 0) {
-                buf = kmalloc(size, GFP_KERNEL);
+                buf = kmemdup(data, size, GFP_KERNEL);
                 if (!buf)
                         return -ENOMEM;
-                memcpy(buf, data, size);
         }
         err = usb_control_msg(dev, pipe, request, requesttype,
                               value, index, buf, size, timeout);
@@ -2846,12 +2845,11 @@ static int create_fixed_stream_quirk(struct snd_usb_audio *chip,
         int stream, err;
         int *rate_table = NULL;
 
-        fp = kmalloc(sizeof(*fp), GFP_KERNEL);
+        fp = kmemdup(quirk->data, sizeof(*fp), GFP_KERNEL);
         if (! fp) {
-                snd_printk(KERN_ERR "cannot malloc\n");
+                snd_printk(KERN_ERR "cannot memdup\n");
                 return -ENOMEM;
         }
-        memcpy(fp, quirk->data, sizeof(*fp));
         if (fp->nr_rates > 0) {
                 rate_table = kmalloc(sizeof(int) * fp->nr_rates, GFP_KERNEL);
                 if (!rate_table) {
@@ -3029,10 +3027,9 @@ static int create_ua1000_quirk(struct snd_usb_audio *chip,
             altsd->bNumEndpoints != 1)
                 return -ENXIO;
 
-        fp = kmalloc(sizeof(*fp), GFP_KERNEL);
+        fp = kmemdup(&ua1000_format, sizeof(*fp), GFP_KERNEL);
         if (!fp)
                 return -ENOMEM;
-        memcpy(fp, &ua1000_format, sizeof(*fp));
 
         fp->channels = alts->extra[4];
         fp->iface = altsd->bInterfaceNumber;
diff --git a/sound/usb/usbmidi.c b/sound/usb/usbmidi.c
index abe29dadd979..0dcf78adb99a 100644
--- a/sound/usb/usbmidi.c
+++ b/sound/usb/usbmidi.c
@@ -323,10 +323,9 @@ static int send_bulk_static_data(struct snd_usb_midi_out_endpoint* ep,
                                  const void *data, int len)
 {
         int err;
-        void *buf = kmalloc(len, GFP_KERNEL);
+        void *buf = kmemdup(data, len, GFP_KERNEL);
         if (!buf)
                 return -ENOMEM;
-        memcpy(buf, data, len);
         dump_urb("sending", buf, len);
         err = usb_bulk_msg(ep->umidi->chip->dev, ep->urb->pipe, buf, len,
                            NULL, 250);