ocfs2: use kmemdup rather than duplicating its implementation

kmemdup is introduced to duplicate a region of memory in a neat way.

Rather than kmalloc/kzalloc + memcpy, which the programmer needs to
write the size twice (sometimes lead to mistakes), kmemdup improves
readability, leads to smaller code and also reduce the chances of
mistakes.

Suggestion to use kmemdup rather than using kmalloc/kzalloc + memcpy.

[akpm@linux-foundation.org: coding style fixes]
Link: http://lkml.kernel.org/r/20190703163147.881-1-huangfq.daxian@gmail.com
Signed-off-by: Fuqian Huang <huangfq.daxian@gmail.com>
Reviewed-by: Joseph Qi <joseph.qi@linux.alibaba.com>
Cc: Mark Fasheh <mark@fasheh.com>
Cc: Joel Becker <jlbec@evilplan.org>
Cc: Junxiao Bi <junxiao.bi@oracle.com>
Cc: Changwei Ge <gechangwei@live.cn>
Cc: Gang He <ghe@suse.com>
Cc: Jun Piao <piaojun@huawei.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

2 files changed, 7 insertions, 9 deletions

diff --git a/fs/ocfs2/alloc.c b/fs/ocfs2/alloc.c
index d1348fc4ca6d..0c335b51043d 100644
--- a/fs/ocfs2/alloc.c
+++ b/fs/ocfs2/alloc.c
@@ -6191,17 +6191,17 @@ int ocfs2_begin_truncate_log_recovery(struct ocfs2_super *osb,
         if (le16_to_cpu(tl->tl_used)) {
                 trace_ocfs2_truncate_log_recovery_num(le16_to_cpu(tl->tl_used));
 
-                *tl_copy = kmalloc(tl_bh->b_size, GFP_KERNEL);
+                /*
+                 * Assuming the write-out below goes well, this copy will be
+                 * passed back to recovery for processing.
+                 */
+                *tl_copy = kmemdup(tl_bh->b_data, tl_bh->b_size, GFP_KERNEL);
                 if (!(*tl_copy)) {
                         status = -ENOMEM;
                         mlog_errno(status);
                         goto bail;
                 }
 
-                /* Assuming the write-out below goes well, this copy
-                 * will be passed back to recovery for processing. */
-                memcpy(*tl_copy, tl_bh->b_data, tl_bh->b_size);
-
                 /* All we need to do to clear the truncate log is set
                  * tl_used. */
                 tl->tl_used = 0;
diff --git a/fs/ocfs2/localalloc.c b/fs/ocfs2/localalloc.c
index f03674afbd30..158e5af767fd 100644
--- a/fs/ocfs2/localalloc.c
+++ b/fs/ocfs2/localalloc.c
@@ -424,12 +424,11 @@ void ocfs2_shutdown_local_alloc(struct ocfs2_super *osb)
         bh = osb->local_alloc_bh;
         alloc = (struct ocfs2_dinode *) bh->b_data;
 
-        alloc_copy = kmalloc(bh->b_size, GFP_NOFS);
+        alloc_copy = kmemdup(alloc, bh->b_size, GFP_NOFS);
         if (!alloc_copy) {
                 status = -ENOMEM;
                 goto out_commit;
         }
-        memcpy(alloc_copy, alloc, bh->b_size);
 
         status = ocfs2_journal_access_di(handle, INODE_CACHE(local_alloc_inode),
                                          bh, OCFS2_JOURNAL_ACCESS_WRITE);
@@ -1272,13 +1271,12 @@ static int ocfs2_local_alloc_slide_window(struct ocfs2_super *osb,
          * local alloc shutdown won't try to double free main bitmap
          * bits. Make a copy so the sync function knows which bits to
          * free. */
-        alloc_copy = kmalloc(osb->local_alloc_bh->b_size, GFP_NOFS);
+        alloc_copy = kmemdup(alloc, osb->local_alloc_bh->b_size, GFP_NOFS);
         if (!alloc_copy) {
                 status = -ENOMEM;
                 mlog_errno(status);
                 goto bail;
         }
-        memcpy(alloc_copy, alloc, osb->local_alloc_bh->b_size);
 
         status = ocfs2_journal_access_di(handle,
                                          INODE_CACHE(local_alloc_inode),