[XFS] Remove unused arg from kmem_free()

kmem_free() function takes (ptr, size) arguments but doesn't actually use
second one.

This patch removes size argument from all callsites.

SGI-PV: 981498
SGI-Modid: xfs-linux-melb:xfs-kern:31050a

Signed-off-by: Denys Vlasenko <vda.linux@googlemail.com>
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Lachlan McIlroy <lachlan@sgi.com>

31 files changed, 122 insertions, 138 deletions

diff --git a/fs/xfs/linux-2.6/kmem.c b/fs/xfs/linux-2.6/kmem.c
index 9b1bb17a0501..69233a52f0a6 100644
--- a/fs/xfs/linux-2.6/kmem.c
+++ b/fs/xfs/linux-2.6/kmem.c
@@ -90,7 +90,7 @@ kmem_zalloc_greedy(size_t *size, size_t minsize, size_t maxsize,
 }
 
 void
-kmem_free(void *ptr, size_t size)
+kmem_free(void *ptr)
 {
         if (!is_vmalloc_addr(ptr)) {
                 kfree(ptr);
@@ -110,7 +110,7 @@ kmem_realloc(void *ptr, size_t newsize, size_t oldsize,
                 if (new)
                         memcpy(new, ptr,
                                 ((oldsize < newsize) ? oldsize : newsize));
-                kmem_free(ptr, oldsize);
+                kmem_free(ptr);
         }
         return new;
 }
diff --git a/fs/xfs/linux-2.6/kmem.h b/fs/xfs/linux-2.6/kmem.h
index a20683cf74dd..a3c96207e60e 100644
--- a/fs/xfs/linux-2.6/kmem.h
+++ b/fs/xfs/linux-2.6/kmem.h
@@ -58,7 +58,7 @@ extern void *kmem_alloc(size_t, unsigned int __nocast);
 extern void *kmem_zalloc(size_t, unsigned int __nocast);
 extern void *kmem_zalloc_greedy(size_t *, size_t, size_t, unsigned int __nocast);
 extern void *kmem_realloc(void *, size_t, size_t, unsigned int __nocast);
-extern void  kmem_free(void *, size_t);
+extern void  kmem_free(void *);
 
 /*
  * Zone interfaces
diff --git a/fs/xfs/linux-2.6/xfs_buf.c b/fs/xfs/linux-2.6/xfs_buf.c
index 98e0e86093b4..ed03c6d3c9c1 100644
--- a/fs/xfs/linux-2.6/xfs_buf.c
+++ b/fs/xfs/linux-2.6/xfs_buf.c
@@ -310,8 +310,7 @@ _xfs_buf_free_pages(
         xfs_buf_t       *bp)
 {
         if (bp->b_pages != bp->b_page_array) {
-                kmem_free(bp->b_pages,
-                          bp->b_page_count * sizeof(struct page *));
+                kmem_free(bp->b_pages);
         }
 }
 
@@ -1398,7 +1397,7 @@ STATIC void
 xfs_free_bufhash(
         xfs_buftarg_t           *btp)
 {
-        kmem_free(btp->bt_hash, (1<<btp->bt_hashshift) * sizeof(xfs_bufhash_t));
+        kmem_free(btp->bt_hash);
         btp->bt_hash = NULL;
 }
 
@@ -1444,7 +1443,7 @@ xfs_free_buftarg(
         xfs_unregister_buftarg(btp);
         kthread_stop(btp->bt_task);
 
-        kmem_free(btp, sizeof(*btp));
+        kmem_free(btp);
 }
 
 STATIC int
@@ -1575,7 +1574,7 @@ xfs_alloc_buftarg(
         return btp;
 
 error:
-        kmem_free(btp, sizeof(*btp));
+        kmem_free(btp);
         return NULL;
 }
 
diff --git a/fs/xfs/linux-2.6/xfs_super.c b/fs/xfs/linux-2.6/xfs_super.c
index 1b60e46f527f..5c7144bc3106 100644
--- a/fs/xfs/linux-2.6/xfs_super.c
+++ b/fs/xfs/linux-2.6/xfs_super.c
@@ -1074,7 +1074,7 @@ xfssyncd(
                         list_del(&work->w_list);
                         if (work == &mp->m_sync_work)
                                 continue;
-                        kmem_free(work, sizeof(struct bhv_vfs_sync_work));
+                        kmem_free(work);
                 }
         }
 
@@ -1222,7 +1222,7 @@ xfs_fs_remount(
         error = xfs_parseargs(mp, options, args, 1);
         if (!error)
                 error = xfs_mntupdate(mp, flags, args);
-        kmem_free(args, sizeof(*args));
+        kmem_free(args);
         return -error;
 }
 
@@ -1369,7 +1369,7 @@ xfs_fs_fill_super(
 
         xfs_itrace_exit(XFS_I(sb->s_root->d_inode));
 
-        kmem_free(args, sizeof(*args));
+        kmem_free(args);
         return 0;
 
 fail_vnrele:
@@ -1384,7 +1384,7 @@ fail_unmount:
         xfs_unmount(mp, 0, NULL);
 
 fail_vfsop:
-        kmem_free(args, sizeof(*args));
+        kmem_free(args);
         return -error;
 }
 
diff --git a/fs/xfs/quota/xfs_dquot_item.c b/fs/xfs/quota/xfs_dquot_item.c
index 36e05ca78412..08d2fc89e6a1 100644
--- a/fs/xfs/quota/xfs_dquot_item.c
+++ b/fs/xfs/quota/xfs_dquot_item.c
@@ -576,8 +576,8 @@ xfs_qm_qoffend_logitem_committed(
          * xfs_trans_delete_ail() drops the AIL lock.
          */
         xfs_trans_delete_ail(qfs->qql_item.li_mountp, (xfs_log_item_t *)qfs);
-        kmem_free(qfs, sizeof(xfs_qoff_logitem_t));
-        kmem_free(qfe, sizeof(xfs_qoff_logitem_t));
+        kmem_free(qfs);
+        kmem_free(qfe);
         return (xfs_lsn_t)-1;
 }
 
diff --git a/fs/xfs/quota/xfs_qm.c b/fs/xfs/quota/xfs_qm.c
index d31cce1165c5..cde5c508f0e0 100644
--- a/fs/xfs/quota/xfs_qm.c
+++ b/fs/xfs/quota/xfs_qm.c
@@ -192,8 +192,8 @@ xfs_qm_destroy(
                 xfs_qm_list_destroy(&(xqm->qm_usr_dqhtable[i]));
                 xfs_qm_list_destroy(&(xqm->qm_grp_dqhtable[i]));
         }
-        kmem_free(xqm->qm_usr_dqhtable, hsize * sizeof(xfs_dqhash_t));
-        kmem_free(xqm->qm_grp_dqhtable, hsize * sizeof(xfs_dqhash_t));
+        kmem_free(xqm->qm_usr_dqhtable);
+        kmem_free(xqm->qm_grp_dqhtable);
         xqm->qm_usr_dqhtable = NULL;
         xqm->qm_grp_dqhtable = NULL;
         xqm->qm_dqhashmask = 0;
@@ -201,7 +201,7 @@ xfs_qm_destroy(
 #ifdef DEBUG
         mutex_destroy(&qcheck_lock);
 #endif
-        kmem_free(xqm, sizeof(xfs_qm_t));
+        kmem_free(xqm);
 }
 
 /*
@@ -1134,7 +1134,7 @@ xfs_qm_init_quotainfo(
          * and change the superblock accordingly.
          */
         if ((error = xfs_qm_init_quotainos(mp))) {
-                kmem_free(qinf, sizeof(xfs_quotainfo_t));
+                kmem_free(qinf);
                 mp->m_quotainfo = NULL;
                 return error;
         }
@@ -1248,7 +1248,7 @@ xfs_qm_destroy_quotainfo(
                 qi->qi_gquotaip = NULL;
         }
         mutex_destroy(&qi->qi_quotaofflock);
-        kmem_free(qi, sizeof(xfs_quotainfo_t));
+        kmem_free(qi);
         mp->m_quotainfo = NULL;
 }
 
@@ -1623,7 +1623,7 @@ xfs_qm_dqiterate(
                         break;
         } while (nmaps > 0);
 
-        kmem_free(map, XFS_DQITER_MAP_SIZE * sizeof(*map));
+        kmem_free(map);
 
         return error;
 }
diff --git a/fs/xfs/quota/xfs_qm_syscalls.c b/fs/xfs/quota/xfs_qm_syscalls.c
index 768a3b27d2b6..413671523cb5 100644
--- a/fs/xfs/quota/xfs_qm_syscalls.c
+++ b/fs/xfs/quota/xfs_qm_syscalls.c
@@ -1449,14 +1449,14 @@ xfs_qm_internalqcheck(
                 for (d = (xfs_dqtest_t *) h1->qh_next; d != NULL; ) {
                         xfs_dqtest_cmp(d);
                         e = (xfs_dqtest_t *) d->HL_NEXT;
-                        kmem_free(d, sizeof(xfs_dqtest_t));
+                        kmem_free(d);
                         d = e;
                 }
                 h1 = &qmtest_gdqtab[i];
                 for (d = (xfs_dqtest_t *) h1->qh_next; d != NULL; ) {
                         xfs_dqtest_cmp(d);
                         e = (xfs_dqtest_t *) d->HL_NEXT;
-                        kmem_free(d, sizeof(xfs_dqtest_t));
+                        kmem_free(d);
                         d = e;
                 }
         }
@@ -1467,8 +1467,8 @@ xfs_qm_internalqcheck(
         } else {
                 cmn_err(CE_DEBUG, "******** quotacheck successful! ********");
         }
-        kmem_free(qmtest_udqtab, qmtest_hashmask * sizeof(xfs_dqhash_t));
-        kmem_free(qmtest_gdqtab, qmtest_hashmask * sizeof(xfs_dqhash_t));
+        kmem_free(qmtest_udqtab);
+        kmem_free(qmtest_gdqtab);
         mutex_unlock(&qcheck_lock);
         return (qmtest_nfails);
 }
diff --git a/fs/xfs/support/ktrace.c b/fs/xfs/support/ktrace.c
index 0b75d302508f..a34ef05489b1 100644
--- a/fs/xfs/support/ktrace.c
+++ b/fs/xfs/support/ktrace.c
@@ -89,7 +89,7 @@ ktrace_alloc(int nentries, unsigned int __nocast sleep)
                 if (sleep & KM_SLEEP)
                         panic("ktrace_alloc: NULL memory on KM_SLEEP request!");
 
-                kmem_free(ktp, sizeof(*ktp));
+                kmem_free(ktp);
 
                 return NULL;
         }
@@ -126,7 +126,7 @@ ktrace_free(ktrace_t *ktp)
         } else {
                 entries_size = (int)(ktp->kt_nentries * sizeof(ktrace_entry_t));
 
-                kmem_free(ktp->kt_entries, entries_size);
+                kmem_free(ktp->kt_entries);
         }
 
         kmem_zone_free(ktrace_hdr_zone, ktp);
diff --git a/fs/xfs/xfs_attr_leaf.c b/fs/xfs/xfs_attr_leaf.c
index 303d41e4217b..a85e9caf0156 100644
--- a/fs/xfs/xfs_attr_leaf.c
+++ b/fs/xfs/xfs_attr_leaf.c
@@ -555,7 +555,7 @@ xfs_attr_shortform_to_leaf(xfs_da_args_t *args)
 out:
         if(bp)
                 xfs_da_buf_done(bp);
-        kmem_free(tmpbuffer, size);
+        kmem_free(tmpbuffer);
         return(error);
 }
 
@@ -676,7 +676,7 @@ xfs_attr_shortform_list(xfs_attr_list_context_t *context)
                                              XFS_ERRLEVEL_LOW,
                                              context->dp->i_mount, sfe);
                         xfs_attr_trace_l_c("sf corrupted", context);
-                        kmem_free(sbuf, sbsize);
+                        kmem_free(sbuf);
                         return XFS_ERROR(EFSCORRUPTED);
                 }
                 if (!xfs_attr_namesp_match_overrides(context->flags, sfe->flags)) {
@@ -717,7 +717,7 @@ xfs_attr_shortform_list(xfs_attr_list_context_t *context)
                 }
         }
         if (i == nsbuf) {
-                kmem_free(sbuf, sbsize);
+                kmem_free(sbuf);
                 xfs_attr_trace_l_c("blk end", context);
                 return(0);
         }
@@ -747,7 +747,7 @@ xfs_attr_shortform_list(xfs_attr_list_context_t *context)
                 cursor->offset++;
         }
 
-        kmem_free(sbuf, sbsize);
+        kmem_free(sbuf);
         xfs_attr_trace_l_c("sf E-O-F", context);
         return(0);
 }
@@ -873,7 +873,7 @@ xfs_attr_leaf_to_shortform(xfs_dabuf_t *bp, xfs_da_args_t *args, int forkoff)
         error = 0;
 
 out:
-        kmem_free(tmpbuffer, XFS_LBSIZE(dp->i_mount));
+        kmem_free(tmpbuffer);
         return(error);
 }
 
@@ -1271,7 +1271,7 @@ xfs_attr_leaf_compact(xfs_trans_t *trans, xfs_dabuf_t *bp)
                                 be16_to_cpu(hdr_s->count), mp);
         xfs_da_log_buf(trans, bp, 0, XFS_LBSIZE(mp) - 1);
 
-        kmem_free(tmpbuffer, XFS_LBSIZE(mp));
+        kmem_free(tmpbuffer);
 }
 
 /*
@@ -1921,7 +1921,7 @@ xfs_attr_leaf_unbalance(xfs_da_state_t *state, xfs_da_state_blk_t *drop_blk,
                                 be16_to_cpu(drop_hdr->count), mp);
                 }
                 memcpy((char *)save_leaf, (char *)tmp_leaf, state->blocksize);
-                kmem_free(tmpbuffer, state->blocksize);
+                kmem_free(tmpbuffer);
         }
 
         xfs_da_log_buf(state->args->trans, save_blk->bp, 0,
@@ -2451,7 +2451,7 @@ xfs_attr_leaf_list_int(xfs_dabuf_t *bp, xfs_attr_list_context_t *context)
                                                 (int)name_rmt->namelen,
                                                 valuelen,
                                                 (char*)args.value);
-                                kmem_free(args.value, valuelen);
+                                kmem_free(args.value);
                         }
                         else {
                                 retval = context->put_listent(context,
@@ -2954,7 +2954,7 @@ xfs_attr_leaf_inactive(xfs_trans_t **trans, xfs_inode_t *dp, xfs_dabuf_t *bp)
                         error = tmp;    /* save only the 1st errno */
         }
 
-        kmem_free((xfs_caddr_t)list, size);
+        kmem_free((xfs_caddr_t)list);
         return(error);
 }
 
diff --git a/fs/xfs/xfs_bmap.c b/fs/xfs/xfs_bmap.c
index 53c259f5a5af..a612a90aae4a 100644
--- a/fs/xfs/xfs_bmap.c
+++ b/fs/xfs/xfs_bmap.c
@@ -5970,7 +5970,7 @@ unlock_and_return:
         xfs_iunlock_map_shared(ip, lock);
         xfs_iunlock(ip, XFS_IOLOCK_SHARED);
 
-        kmem_free(map, subnex * sizeof(*map));
+        kmem_free(map);
 
         return error;
 }
diff --git a/fs/xfs/xfs_buf_item.c b/fs/xfs/xfs_buf_item.c
index 53a71c62025d..d86ca2c03a70 100644
--- a/fs/xfs/xfs_buf_item.c
+++ b/fs/xfs/xfs_buf_item.c
@@ -889,9 +889,9 @@ xfs_buf_item_relse(
         }
 
 #ifdef XFS_TRANS_DEBUG
-        kmem_free(bip->bli_orig, XFS_BUF_COUNT(bp));
+        kmem_free(bip->bli_orig);
         bip->bli_orig = NULL;
-        kmem_free(bip->bli_logged, XFS_BUF_COUNT(bp) / NBBY);
+        kmem_free(bip->bli_logged);
         bip->bli_logged = NULL;
 #endif /* XFS_TRANS_DEBUG */
 
@@ -1138,9 +1138,9 @@ xfs_buf_iodone(
         xfs_trans_delete_ail(mp, (xfs_log_item_t *)bip);
 
 #ifdef XFS_TRANS_DEBUG
-        kmem_free(bip->bli_orig, XFS_BUF_COUNT(bp));
+        kmem_free(bip->bli_orig);
         bip->bli_orig = NULL;
-        kmem_free(bip->bli_logged, XFS_BUF_COUNT(bp) / NBBY);
+        kmem_free(bip->bli_logged);
         bip->bli_logged = NULL;
 #endif /* XFS_TRANS_DEBUG */
 
diff --git a/fs/xfs/xfs_da_btree.c b/fs/xfs/xfs_da_btree.c
index 021a8f7e563f..294780427abb 100644
--- a/fs/xfs/xfs_da_btree.c
+++ b/fs/xfs/xfs_da_btree.c
@@ -1598,7 +1598,7 @@ xfs_da_grow_inode(xfs_da_args_t *args, xfs_dablk_t *new_blkno)
                                         args->firstblock, args->total,
                                         &mapp[mapi], &nmap, args->flist,
                                         NULL))) {
-                                kmem_free(mapp, sizeof(*mapp) * count);
+                                kmem_free(mapp);
                                 return error;
                         }
                         if (nmap < 1)
@@ -1620,11 +1620,11 @@ xfs_da_grow_inode(xfs_da_args_t *args, xfs_dablk_t *new_blkno)
             mapp[mapi - 1].br_startoff + mapp[mapi - 1].br_blockcount !=
             bno + count) {
                 if (mapp != &map)
-                        kmem_free(mapp, sizeof(*mapp) * count);
+                        kmem_free(mapp);
                 return XFS_ERROR(ENOSPC);
         }
         if (mapp != &map)
-                kmem_free(mapp, sizeof(*mapp) * count);
+                kmem_free(mapp);
         *new_blkno = (xfs_dablk_t)bno;
         return 0;
 }
@@ -2090,10 +2090,10 @@ xfs_da_do_buf(
                 }
         }
         if (bplist) {
-                kmem_free(bplist, sizeof(*bplist) * nmap);
+                kmem_free(bplist);
         }
         if (mapp != &map) {
-                kmem_free(mapp, sizeof(*mapp) * nfsb);
+                kmem_free(mapp);
         }
         if (bpp)
                 *bpp = rbp;
@@ -2102,11 +2102,11 @@ exit1:
         if (bplist) {
                 for (i = 0; i < nbplist; i++)
                         xfs_trans_brelse(trans, bplist[i]);
-                kmem_free(bplist, sizeof(*bplist) * nmap);
+                kmem_free(bplist);
         }
 exit0:
         if (mapp != &map)
-                kmem_free(mapp, sizeof(*mapp) * nfsb);
+                kmem_free(mapp);
         if (bpp)
                 *bpp = NULL;
         return error;
@@ -2315,7 +2315,7 @@ xfs_da_buf_done(xfs_dabuf_t *dabuf)
         if (dabuf->dirty)
                 xfs_da_buf_clean(dabuf);
         if (dabuf->nbuf > 1)
-                kmem_free(dabuf->data, BBTOB(dabuf->bbcount));
+                kmem_free(dabuf->data);
 #ifdef XFS_DABUF_DEBUG
         {
                 spin_lock(&xfs_dabuf_global_lock);
@@ -2332,7 +2332,7 @@ xfs_da_buf_done(xfs_dabuf_t *dabuf)
         if (dabuf->nbuf == 1)
                 kmem_zone_free(xfs_dabuf_zone, dabuf);
         else
-                kmem_free(dabuf, XFS_DA_BUF_SIZE(dabuf->nbuf));
+                kmem_free(dabuf);
 }
 
 /*
@@ -2403,7 +2403,7 @@ xfs_da_brelse(xfs_trans_t *tp, xfs_dabuf_t *dabuf)
         for (i = 0; i < nbuf; i++)
                 xfs_trans_brelse(tp, bplist[i]);
         if (bplist != &bp)
-                kmem_free(bplist, nbuf * sizeof(*bplist));
+                kmem_free(bplist);
 }
 
 /*
@@ -2429,7 +2429,7 @@ xfs_da_binval(xfs_trans_t *tp, xfs_dabuf_t *dabuf)
         for (i = 0; i < nbuf; i++)
                 xfs_trans_binval(tp, bplist[i]);
         if (bplist != &bp)
-                kmem_free(bplist, nbuf * sizeof(*bplist));
+                kmem_free(bplist);
 }
 
 /*
diff --git a/fs/xfs/xfs_dfrag.c b/fs/xfs/xfs_dfrag.c
index 5f3647cb9885..2211e885ef24 100644
--- a/fs/xfs/xfs_dfrag.c
+++ b/fs/xfs/xfs_dfrag.c
@@ -116,7 +116,7 @@ xfs_swapext(
  out_put_file:
         fput(file);
  out_free_sxp:
-        kmem_free(sxp, sizeof(xfs_swapext_t));
+        kmem_free(sxp);
  out:
         return error;
 }
@@ -381,6 +381,6 @@ xfs_swap_extents(
                 xfs_iunlock(tip, lock_flags);
         }
         if (tempifp != NULL)
-                kmem_free(tempifp, sizeof(xfs_ifork_t));
+                kmem_free(tempifp);
         return error;
 }
diff --git a/fs/xfs/xfs_dir2.c b/fs/xfs/xfs_dir2.c
index 7cb26529766b..0284af1734bd 100644
--- a/fs/xfs/xfs_dir2.c
+++ b/fs/xfs/xfs_dir2.c
@@ -493,7 +493,7 @@ xfs_dir2_grow_inode(
                                         args->firstblock, args->total,
                                         &mapp[mapi], &nmap, args->flist,
                                         NULL))) {
-                                kmem_free(mapp, sizeof(*mapp) * count);
+                                kmem_free(mapp);
                                 return error;
                         }
                         if (nmap < 1)
@@ -525,14 +525,14 @@ xfs_dir2_grow_inode(
             mapp[mapi - 1].br_startoff + mapp[mapi - 1].br_blockcount !=
             bno + count) {
                 if (mapp != &map)
-                        kmem_free(mapp, sizeof(*mapp) * count);
+                        kmem_free(mapp);
                 return XFS_ERROR(ENOSPC);
         }
         /*
          * Done with the temporary mapping table.
          */
         if (mapp != &map)
-                kmem_free(mapp, sizeof(*mapp) * count);
+                kmem_free(mapp);
         *dbp = xfs_dir2_da_to_db(mp, (xfs_dablk_t)bno);
         /*
          * Update file's size if this is the data space and it grew.
diff --git a/fs/xfs/xfs_dir2_block.c b/fs/xfs/xfs_dir2_block.c
index fb5a556725b3..e8a7aca5fe23 100644
--- a/fs/xfs/xfs_dir2_block.c
+++ b/fs/xfs/xfs_dir2_block.c
@@ -1071,7 +1071,7 @@ xfs_dir2_sf_to_block(
          */
         error = xfs_dir2_grow_inode(args, XFS_DIR2_DATA_SPACE, &blkno);
         if (error) {
-                kmem_free(buf, buf_len);
+                kmem_free(buf);
                 return error;
         }
         /*
@@ -1079,7 +1079,7 @@ xfs_dir2_sf_to_block(
          */
         error = xfs_dir2_data_init(args, blkno, &bp);
         if (error) {
-                kmem_free(buf, buf_len);
+                kmem_free(buf);
                 return error;
         }
         block = bp->data;
@@ -1198,7 +1198,7 @@ xfs_dir2_sf_to_block(
                         sfep = xfs_dir2_sf_nextentry(sfp, sfep);
         }
         /* Done with the temporary buffer */
-        kmem_free(buf, buf_len);
+        kmem_free(buf);
         /*
          * Sort the leaf entries by hash value.
          */
diff --git a/fs/xfs/xfs_dir2_leaf.c b/fs/xfs/xfs_dir2_leaf.c
index bc52b803d79b..e33433408e4a 100644
--- a/fs/xfs/xfs_dir2_leaf.c
+++ b/fs/xfs/xfs_dir2_leaf.c
@@ -1110,7 +1110,7 @@ xfs_dir2_leaf_getdents(
                 *offset = XFS_DIR2_MAX_DATAPTR;
         else
                 *offset = xfs_dir2_byte_to_dataptr(mp, curoff);
-        kmem_free(map, map_size * sizeof(*map));
+        kmem_free(map);
         if (bp)
                 xfs_da_brelse(NULL, bp);
         return error;
diff --git a/fs/xfs/xfs_dir2_sf.c b/fs/xfs/xfs_dir2_sf.c
index 919d275a1cef..ca33bc62edc2 100644
--- a/fs/xfs/xfs_dir2_sf.c
+++ b/fs/xfs/xfs_dir2_sf.c
@@ -255,7 +255,7 @@ xfs_dir2_block_to_sf(
         xfs_dir2_sf_check(args);
 out:
         xfs_trans_log_inode(args->trans, dp, logflags);
-        kmem_free(block, mp->m_dirblksize);
+        kmem_free(block);
         return error;
 }
 
@@ -512,7 +512,7 @@ xfs_dir2_sf_addname_hard(
                 sfep = xfs_dir2_sf_nextentry(sfp, sfep);
                 memcpy(sfep, oldsfep, old_isize - nbytes);
         }
-        kmem_free(buf, old_isize);
+        kmem_free(buf);
         dp->i_d.di_size = new_isize;
         xfs_dir2_sf_check(args);
 }
@@ -1174,7 +1174,7 @@ xfs_dir2_sf_toino4(
         /*
          * Clean up the inode.
          */
-        kmem_free(buf, oldsize);
+        kmem_free(buf);
         dp->i_d.di_size = newsize;
         xfs_trans_log_inode(args->trans, dp, XFS_ILOG_CORE | XFS_ILOG_DDATA);
 }
@@ -1251,7 +1251,7 @@ xfs_dir2_sf_toino8(
         /*
          * Clean up the inode.
          */
-        kmem_free(buf, oldsize);
+        kmem_free(buf);
         dp->i_d.di_size = newsize;
         xfs_trans_log_inode(args->trans, dp, XFS_ILOG_CORE | XFS_ILOG_DDATA);
 }
diff --git a/fs/xfs/xfs_error.c b/fs/xfs/xfs_error.c
index 05e5365d3c31..7380a00644c8 100644
--- a/fs/xfs/xfs_error.c
+++ b/fs/xfs/xfs_error.c
@@ -150,8 +150,7 @@ xfs_errortag_clearall(xfs_mount_t *mp, int loud)
                                 xfs_etest[i]);
                         xfs_etest[i] = 0;
                         xfs_etest_fsid[i] = 0LL;
-                        kmem_free(xfs_etest_fsname[i],
-                                  strlen(xfs_etest_fsname[i]) + 1);
+                        kmem_free(xfs_etest_fsname[i]);
                         xfs_etest_fsname[i] = NULL;
                 }
         }
@@ -175,7 +174,7 @@ xfs_fs_vcmn_err(int level, xfs_mount_t *mp, char *fmt, va_list ap)
                 newfmt = kmem_alloc(len, KM_SLEEP);
                 sprintf(newfmt, "Filesystem \"%s\": %s", mp->m_fsname, fmt);
                 icmn_err(level, newfmt, ap);
-                kmem_free(newfmt, len);
+                kmem_free(newfmt);
         } else {
                 icmn_err(level, fmt, ap);
         }
diff --git a/fs/xfs/xfs_extfree_item.c b/fs/xfs/xfs_extfree_item.c
index 132bd07b9bb8..8aa28f751b2a 100644
--- a/fs/xfs/xfs_extfree_item.c
+++ b/fs/xfs/xfs_extfree_item.c
@@ -41,8 +41,7 @@ xfs_efi_item_free(xfs_efi_log_item_t *efip)
         int nexts = efip->efi_format.efi_nextents;
 
         if (nexts > XFS_EFI_MAX_FAST_EXTENTS) {
-                kmem_free(efip, sizeof(xfs_efi_log_item_t) +
-                                (nexts - 1) * sizeof(xfs_extent_t));
+                kmem_free(efip);
         } else {
                 kmem_zone_free(xfs_efi_zone, efip);
         }
@@ -374,8 +373,7 @@ xfs_efd_item_free(xfs_efd_log_item_t *efdp)
         int nexts = efdp->efd_format.efd_nextents;
 
         if (nexts > XFS_EFD_MAX_FAST_EXTENTS) {
-                kmem_free(efdp, sizeof(xfs_efd_log_item_t) +
-                                (nexts - 1) * sizeof(xfs_extent_t));
+                kmem_free(efdp);
         } else {
                 kmem_zone_free(xfs_efd_zone, efdp);
         }
diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index e569bf5d6cf0..4b21490334b1 100644
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -2258,7 +2258,7 @@ xfs_ifree_cluster(
                 xfs_trans_binval(tp, bp);
         }
 
-        kmem_free(ip_found, ninodes * sizeof(xfs_inode_t *));
+        kmem_free(ip_found);
         xfs_put_perag(mp, pag);
 }
 
@@ -2470,7 +2470,7 @@ xfs_iroot_realloc(
                                                      (int)new_size);
                 memcpy(np, op, new_max * (uint)sizeof(xfs_dfsbno_t));
         }
-        kmem_free(ifp->if_broot, ifp->if_broot_bytes);
+        kmem_free(ifp->if_broot);
         ifp->if_broot = new_broot;
         ifp->if_broot_bytes = (int)new_size;
         ASSERT(ifp->if_broot_bytes <=
@@ -2514,7 +2514,7 @@ xfs_idata_realloc(
 
         if (new_size == 0) {
                 if (ifp->if_u1.if_data != ifp->if_u2.if_inline_data) {
-                        kmem_free(ifp->if_u1.if_data, ifp->if_real_bytes);
+                        kmem_free(ifp->if_u1.if_data);
                 }
                 ifp->if_u1.if_data = NULL;
                 real_size = 0;
@@ -2529,7 +2529,7 @@ xfs_idata_realloc(
                         ASSERT(ifp->if_real_bytes != 0);
                         memcpy(ifp->if_u2.if_inline_data, ifp->if_u1.if_data,
                               new_size);
-                        kmem_free(ifp->if_u1.if_data, ifp->if_real_bytes);
+                        kmem_free(ifp->if_u1.if_data);
                         ifp->if_u1.if_data = ifp->if_u2.if_inline_data;
                 }
                 real_size = 0;
@@ -2636,7 +2636,7 @@ xfs_idestroy_fork(
 
         ifp = XFS_IFORK_PTR(ip, whichfork);
         if (ifp->if_broot != NULL) {
-                kmem_free(ifp->if_broot, ifp->if_broot_bytes);
+                kmem_free(ifp->if_broot);
                 ifp->if_broot = NULL;
         }
 
@@ -2650,7 +2650,7 @@ xfs_idestroy_fork(
                 if ((ifp->if_u1.if_data != ifp->if_u2.if_inline_data) &&
                     (ifp->if_u1.if_data != NULL)) {
                         ASSERT(ifp->if_real_bytes != 0);
-                        kmem_free(ifp->if_u1.if_data, ifp->if_real_bytes);
+                        kmem_free(ifp->if_u1.if_data);
                         ifp->if_u1.if_data = NULL;
                         ifp->if_real_bytes = 0;
                 }
@@ -3058,7 +3058,7 @@ xfs_iflush_cluster(
 
 out_free:
         read_unlock(&pag->pag_ici_lock);
-        kmem_free(ilist, ilist_size);
+        kmem_free(ilist);
         return 0;
 
 
@@ -3102,7 +3102,7 @@ cluster_corrupt_out:
          * Unlocks the flush lock
          */
         xfs_iflush_abort(iq);
-        kmem_free(ilist, ilist_size);
+        kmem_free(ilist);
         return XFS_ERROR(EFSCORRUPTED);
 }
 
@@ -3836,7 +3836,7 @@ xfs_iext_add_indirect_multi(
                         erp = xfs_iext_irec_new(ifp, erp_idx);
                 }
                 memmove(&erp->er_extbuf[i], nex2_ep, byte_diff);
-                kmem_free(nex2_ep, byte_diff);
+                kmem_free(nex2_ep);
                 erp->er_extcount += nex2;
                 xfs_iext_irec_update_extoffs(ifp, erp_idx + 1, nex2);
         }
@@ -4112,7 +4112,7 @@ xfs_iext_direct_to_inline(
          */
         memcpy(ifp->if_u2.if_inline_ext, ifp->if_u1.if_extents,
                 nextents * sizeof(xfs_bmbt_rec_t));
-        kmem_free(ifp->if_u1.if_extents, ifp->if_real_bytes);
+        kmem_free(ifp->if_u1.if_extents);
         ifp->if_u1.if_extents = ifp->if_u2.if_inline_ext;
         ifp->if_real_bytes = 0;
 }
@@ -4186,7 +4186,7 @@ xfs_iext_indirect_to_direct(
         ASSERT(ifp->if_real_bytes == XFS_IEXT_BUFSZ);
 
         ep = ifp->if_u1.if_ext_irec->er_extbuf;
-        kmem_free(ifp->if_u1.if_ext_irec, sizeof(xfs_ext_irec_t));
+        kmem_free(ifp->if_u1.if_ext_irec);
         ifp->if_flags &= ~XFS_IFEXTIREC;
         ifp->if_u1.if_extents = ep;
         ifp->if_bytes = size;
@@ -4212,7 +4212,7 @@ xfs_iext_destroy(
                 }
                 ifp->if_flags &= ~XFS_IFEXTIREC;
         } else if (ifp->if_real_bytes) {
-                kmem_free(ifp->if_u1.if_extents, ifp->if_real_bytes);
+                kmem_free(ifp->if_u1.if_extents);
         } else if (ifp->if_bytes) {
                 memset(ifp->if_u2.if_inline_ext, 0, XFS_INLINE_EXTS *
                         sizeof(xfs_bmbt_rec_t));
@@ -4483,7 +4483,7 @@ xfs_iext_irec_remove(
         if (erp->er_extbuf) {
                 xfs_iext_irec_update_extoffs(ifp, erp_idx + 1,
                         -erp->er_extcount);
-                kmem_free(erp->er_extbuf, XFS_IEXT_BUFSZ);
+                kmem_free(erp->er_extbuf);
         }
         /* Compact extent records */
         erp = ifp->if_u1.if_ext_irec;
@@ -4501,8 +4501,7 @@ xfs_iext_irec_remove(
                 xfs_iext_realloc_indirect(ifp,
                         nlists * sizeof(xfs_ext_irec_t));
         } else {
-                kmem_free(ifp->if_u1.if_ext_irec,
-                        sizeof(xfs_ext_irec_t));
+                kmem_free(ifp->if_u1.if_ext_irec);
         }
         ifp->if_real_bytes = nlists * XFS_IEXT_BUFSZ;
 }
@@ -4571,7 +4570,7 @@ xfs_iext_irec_compact_pages(
                          * so er_extoffs don't get modified in
                          * xfs_iext_irec_remove.
                          */
-                        kmem_free(erp_next->er_extbuf, XFS_IEXT_BUFSZ);
+                        kmem_free(erp_next->er_extbuf);
                         erp_next->er_extbuf = NULL;
                         xfs_iext_irec_remove(ifp, erp_idx + 1);
                         nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ;
@@ -4614,8 +4613,7 @@ xfs_iext_irec_compact_full(
                          * so er_extoffs don't get modified in
                          * xfs_iext_irec_remove.
                          */
-                        kmem_free(erp_next->er_extbuf,
-                                erp_next->er_extcount * sizeof(xfs_bmbt_rec_t));
+                        kmem_free(erp_next->er_extbuf);
                         erp_next->er_extbuf = NULL;
                         xfs_iext_irec_remove(ifp, erp_idx + 1);
                         erp = &ifp->if_u1.if_ext_irec[erp_idx];
diff --git a/fs/xfs/xfs_inode_item.c b/fs/xfs/xfs_inode_item.c
index 167b33f15772..0eee08a32c26 100644
--- a/fs/xfs/xfs_inode_item.c
+++ b/fs/xfs/xfs_inode_item.c
@@ -686,7 +686,7 @@ xfs_inode_item_unlock(
                 ASSERT(ip->i_d.di_nextents > 0);
                 ASSERT(iip->ili_format.ilf_fields & XFS_ILOG_DEXT);
                 ASSERT(ip->i_df.if_bytes > 0);
-                kmem_free(iip->ili_extents_buf, ip->i_df.if_bytes);
+                kmem_free(iip->ili_extents_buf);
                 iip->ili_extents_buf = NULL;
         }
         if (iip->ili_aextents_buf != NULL) {
@@ -694,7 +694,7 @@ xfs_inode_item_unlock(
                 ASSERT(ip->i_d.di_anextents > 0);
                 ASSERT(iip->ili_format.ilf_fields & XFS_ILOG_AEXT);
                 ASSERT(ip->i_afp->if_bytes > 0);
-                kmem_free(iip->ili_aextents_buf, ip->i_afp->if_bytes);
+                kmem_free(iip->ili_aextents_buf);
                 iip->ili_aextents_buf = NULL;
         }
 
@@ -957,8 +957,7 @@ xfs_inode_item_destroy(
 {
 #ifdef XFS_TRANS_DEBUG
         if (ip->i_itemp->ili_root_size != 0) {
-                kmem_free(ip->i_itemp->ili_orig_root,
-                          ip->i_itemp->ili_root_size);
+                kmem_free(ip->i_itemp->ili_orig_root);
         }
 #endif
         kmem_zone_free(xfs_ili_zone, ip->i_itemp);
diff --git a/fs/xfs/xfs_itable.c b/fs/xfs/xfs_itable.c
index 419de15aeb43..9a3ef9dcaeb9 100644
--- a/fs/xfs/xfs_itable.c
+++ b/fs/xfs/xfs_itable.c
@@ -257,7 +257,7 @@ xfs_bulkstat_one(
                 *ubused = error;
 
  out_free:
-        kmem_free(buf, sizeof(*buf));
+        kmem_free(buf);
         return error;
 }
 
@@ -708,7 +708,7 @@ xfs_bulkstat(
         /*
          * Done, we're either out of filesystem or space to put the data.
          */
-        kmem_free(irbuf, irbsize);
+        kmem_free(irbuf);
         *ubcountp = ubelem;
         /*
          * Found some inodes, return them now and return the error next time.
@@ -914,7 +914,7 @@ xfs_inumbers(
                 }
                 *lastino = XFS_AGINO_TO_INO(mp, agno, agino);
         }
-        kmem_free(buffer, bcount * sizeof(*buffer));
+        kmem_free(buffer);
         if (cur)
                 xfs_btree_del_cursor(cur, (error ? XFS_BTREE_ERROR :
                                            XFS_BTREE_NOERROR));
diff --git a/fs/xfs/xfs_log.c b/fs/xfs/xfs_log.c
index ad3d26ddfe31..16a01abe2490 100644
--- a/fs/xfs/xfs_log.c
+++ b/fs/xfs/xfs_log.c
@@ -1570,7 +1570,7 @@ xlog_dealloc_log(xlog_t *log)
                 }
 #endif
                 next_iclog = iclog->ic_next;
-                kmem_free(iclog, sizeof(xlog_in_core_t));
+                kmem_free(iclog);
                 iclog = next_iclog;
         }
         freesema(&log->l_flushsema);
@@ -1587,7 +1587,7 @@ xlog_dealloc_log(xlog_t *log)
         }
 #endif
         log->l_mp->m_log = NULL;
-        kmem_free(log, sizeof(xlog_t));
+        kmem_free(log);
 }       /* xlog_dealloc_log */
 
 /*
diff --git a/fs/xfs/xfs_log_recover.c b/fs/xfs/xfs_log_recover.c
index e65ab4af0955..9eb722ec744e 100644
--- a/fs/xfs/xfs_log_recover.c
+++ b/fs/xfs/xfs_log_recover.c
@@ -1715,8 +1715,7 @@ xlog_check_buffer_cancelled(
                                         } else {
                                                 prevp->bc_next = bcp->bc_next;
                                         }
-                                        kmem_free(bcp,
-                                                  sizeof(xfs_buf_cancel_t));
+                                        kmem_free(bcp);
                                 }
                         }
                         return 1;
@@ -2519,7 +2518,7 @@ write_inode_buffer:
 
 error:
         if (need_free)
-                kmem_free(in_f, sizeof(*in_f));
+                kmem_free(in_f);
         return XFS_ERROR(error);
 }
 
@@ -2830,16 +2829,14 @@ xlog_recover_free_trans(
                 item = item->ri_next;
                  /* Free the regions in the item. */
                 for (i = 0; i < free_item->ri_cnt; i++) {
-                        kmem_free(free_item->ri_buf[i].i_addr,
-                                  free_item->ri_buf[i].i_len);
+                        kmem_free(free_item->ri_buf[i].i_addr);
                 }
                 /* Free the item itself */
-                kmem_free(free_item->ri_buf,
-                          (free_item->ri_total * sizeof(xfs_log_iovec_t)));
-                kmem_free(free_item, sizeof(xlog_recover_item_t));
+                kmem_free(free_item->ri_buf);
+                kmem_free(free_item);
         } while (first_item != item);
         /* Free the transaction recover structure */
-        kmem_free(trans, sizeof(xlog_recover_t));
+        kmem_free(trans);
 }
 
 STATIC int
@@ -3786,8 +3783,7 @@ xlog_do_log_recovery(
         error = xlog_do_recovery_pass(log, head_blk, tail_blk,
                                       XLOG_RECOVER_PASS1);
         if (error != 0) {
-                kmem_free(log->l_buf_cancel_table,
-                          XLOG_BC_TABLE_SIZE * sizeof(xfs_buf_cancel_t*));
+                kmem_free(log->l_buf_cancel_table);
                 log->l_buf_cancel_table = NULL;
                 return error;
         }
@@ -3806,8 +3802,7 @@ xlog_do_log_recovery(
         }
 #endif  /* DEBUG */
 
-        kmem_free(log->l_buf_cancel_table,
-                  XLOG_BC_TABLE_SIZE * sizeof(xfs_buf_cancel_t*));
+        kmem_free(log->l_buf_cancel_table);
         log->l_buf_cancel_table = NULL;
 
         return error;
diff --git a/fs/xfs/xfs_mount.c b/fs/xfs/xfs_mount.c
index 361c7a755a07..c63f410ccfaa 100644
--- a/fs/xfs/xfs_mount.c
+++ b/fs/xfs/xfs_mount.c
@@ -161,11 +161,8 @@ xfs_mount_free(
 
                 for (agno = 0; agno < mp->m_maxagi; agno++)
                         if (mp->m_perag[agno].pagb_list)
-                                kmem_free(mp->m_perag[agno].pagb_list,
-                                                sizeof(xfs_perag_busy_t) *
-                                                        XFS_PAGB_NUM_SLOTS);
-                kmem_free(mp->m_perag,
-                          sizeof(xfs_perag_t) * mp->m_sb.sb_agcount);
+                                kmem_free(mp->m_perag[agno].pagb_list);
+                kmem_free(mp->m_perag);
         }
 
         spinlock_destroy(&mp->m_ail_lock);
@@ -176,11 +173,11 @@ xfs_mount_free(
                 XFS_QM_DONE(mp);
 
         if (mp->m_fsname != NULL)
-                kmem_free(mp->m_fsname, mp->m_fsname_len);
+                kmem_free(mp->m_fsname);
         if (mp->m_rtname != NULL)
-                kmem_free(mp->m_rtname, strlen(mp->m_rtname) + 1);
+                kmem_free(mp->m_rtname);
         if (mp->m_logname != NULL)
-                kmem_free(mp->m_logname, strlen(mp->m_logname) + 1);
+                kmem_free(mp->m_logname);
 
         xfs_icsb_destroy_counters(mp);
 }
@@ -1265,9 +1262,8 @@ xfs_mountfs(
  error2:
         for (agno = 0; agno < sbp->sb_agcount; agno++)
                 if (mp->m_perag[agno].pagb_list)
-                        kmem_free(mp->m_perag[agno].pagb_list,
-                          sizeof(xfs_perag_busy_t) * XFS_PAGB_NUM_SLOTS);
-        kmem_free(mp->m_perag, sbp->sb_agcount * sizeof(xfs_perag_t));
+                        kmem_free(mp->m_perag[agno].pagb_list);
+        kmem_free(mp->m_perag);
         mp->m_perag = NULL;
         /* FALLTHROUGH */
  error1:
diff --git a/fs/xfs/xfs_mru_cache.c b/fs/xfs/xfs_mru_cache.c
index a0b2c0a2589a..26d14a1e0e14 100644
--- a/fs/xfs/xfs_mru_cache.c
+++ b/fs/xfs/xfs_mru_cache.c
@@ -382,9 +382,9 @@ xfs_mru_cache_create(
 
 exit:
         if (err && mru && mru->lists)
-                kmem_free(mru->lists, mru->grp_count * sizeof(*mru->lists));
+                kmem_free(mru->lists);
         if (err && mru)
-                kmem_free(mru, sizeof(*mru));
+                kmem_free(mru);
 
         return err;
 }
@@ -424,8 +424,8 @@ xfs_mru_cache_destroy(
 
         xfs_mru_cache_flush(mru);
 
-        kmem_free(mru->lists, mru->grp_count * sizeof(*mru->lists));
-        kmem_free(mru, sizeof(*mru));
+        kmem_free(mru->lists);
+        kmem_free(mru);
 }
 
 /*
diff --git a/fs/xfs/xfs_rtalloc.c b/fs/xfs/xfs_rtalloc.c
index a0dc6e5bc5b9..bf87a5913504 100644
--- a/fs/xfs/xfs_rtalloc.c
+++ b/fs/xfs/xfs_rtalloc.c
@@ -2062,7 +2062,7 @@ xfs_growfs_rt(
         /*
          * Free the fake mp structure.
          */
-        kmem_free(nmp, sizeof(*nmp));
+        kmem_free(nmp);
 
         return error;
 }
diff --git a/fs/xfs/xfs_trans.c b/fs/xfs/xfs_trans.c
index 140386434aa3..e4ebddd3c500 100644
--- a/fs/xfs/xfs_trans.c
+++ b/fs/xfs/xfs_trans.c
@@ -889,7 +889,7 @@ shut_us_down:
 
         tp->t_commit_lsn = commit_lsn;
         if (nvec > XFS_TRANS_LOGVEC_COUNT) {
-                kmem_free(log_vector, nvec * sizeof(xfs_log_iovec_t));
+                kmem_free(log_vector);
         }
 
         /*
@@ -1265,7 +1265,7 @@ xfs_trans_committed(
                 ASSERT(!XFS_LIC_ARE_ALL_FREE(licp));
                 xfs_trans_chunk_committed(licp, tp->t_lsn, abortflag);
                 next_licp = licp->lic_next;
-                kmem_free(licp, sizeof(xfs_log_item_chunk_t));
+                kmem_free(licp);
                 licp = next_licp;
         }
 
diff --git a/fs/xfs/xfs_trans_inode.c b/fs/xfs/xfs_trans_inode.c
index 4c70bf5e9985..2a1c0f071f91 100644
--- a/fs/xfs/xfs_trans_inode.c
+++ b/fs/xfs/xfs_trans_inode.c
@@ -291,7 +291,7 @@ xfs_trans_inode_broot_debug(
         iip = ip->i_itemp;
         if (iip->ili_root_size != 0) {
                 ASSERT(iip->ili_orig_root != NULL);
-                kmem_free(iip->ili_orig_root, iip->ili_root_size);
+                kmem_free(iip->ili_orig_root);
                 iip->ili_root_size = 0;
                 iip->ili_orig_root = NULL;
         }
diff --git a/fs/xfs/xfs_trans_item.c b/fs/xfs/xfs_trans_item.c
index 66a09f0d894b..db5c83595526 100644
--- a/fs/xfs/xfs_trans_item.c
+++ b/fs/xfs/xfs_trans_item.c
@@ -161,7 +161,7 @@ xfs_trans_free_item(xfs_trans_t	*tp, xfs_log_item_desc_t *lidp)
                         licpp = &((*licpp)->lic_next);
                 }
                 *licpp = licp->lic_next;
-                kmem_free(licp, sizeof(xfs_log_item_chunk_t));
+                kmem_free(licp);
                 tp->t_items_free -= XFS_LIC_NUM_SLOTS;
         }
 }
@@ -314,7 +314,7 @@ xfs_trans_free_items(
                 ASSERT(!XFS_LIC_ARE_ALL_FREE(licp));
                 (void) xfs_trans_unlock_chunk(licp, 1, abort, NULLCOMMITLSN);
                 next_licp = licp->lic_next;
-                kmem_free(licp, sizeof(xfs_log_item_chunk_t));
+                kmem_free(licp);
                 licp = next_licp;
         }
 
@@ -363,7 +363,7 @@ xfs_trans_unlock_items(xfs_trans_t *tp, xfs_lsn_t commit_lsn)
                 next_licp = licp->lic_next;
                 if (XFS_LIC_ARE_ALL_FREE(licp)) {
                         *licpp = next_licp;
-                        kmem_free(licp, sizeof(xfs_log_item_chunk_t));
+                        kmem_free(licp);
                         freed -= XFS_LIC_NUM_SLOTS;
                 } else {
                         licpp = &(licp->lic_next);
@@ -530,7 +530,7 @@ xfs_trans_free_busy(xfs_trans_t *tp)
         lbcp = tp->t_busy.lbc_next;
         while (lbcp != NULL) {
                 lbcq = lbcp->lbc_next;
-                kmem_free(lbcp, sizeof(xfs_log_busy_chunk_t));
+                kmem_free(lbcp);
                 lbcp = lbcq;
         }
 
diff --git a/fs/xfs/xfs_vfsops.c b/fs/xfs/xfs_vfsops.c
index bbc911720d81..a005cebf5041 100644
--- a/fs/xfs/xfs_vfsops.c
+++ b/fs/xfs/xfs_vfsops.c
@@ -639,7 +639,7 @@ out:
                 xfs_unmountfs(mp, credp);
                 xfs_qmops_put(mp);
                 xfs_dmops_put(mp);
-                kmem_free(mp, sizeof(xfs_mount_t));
+                kmem_free(mp);
         }
 
         return XFS_ERROR(error);
@@ -1055,7 +1055,7 @@ xfs_sync_inodes(
 
                 if (XFS_FORCED_SHUTDOWN(mp) && !(flags & SYNC_CLOSE)) {
                         XFS_MOUNT_IUNLOCK(mp);
-                        kmem_free(ipointer, sizeof(xfs_iptr_t));
+                        kmem_free(ipointer);
                         return 0;
                 }
 
@@ -1201,7 +1201,7 @@ xfs_sync_inodes(
                         }
                         XFS_MOUNT_IUNLOCK(mp);
                         ASSERT(ipointer_in == B_FALSE);
-                        kmem_free(ipointer, sizeof(xfs_iptr_t));
+                        kmem_free(ipointer);
                         return XFS_ERROR(error);
                 }
 
@@ -1231,7 +1231,7 @@ xfs_sync_inodes(
 
         ASSERT(ipointer_in == B_FALSE);
 
-        kmem_free(ipointer, sizeof(xfs_iptr_t));
+        kmem_free(ipointer);
         return XFS_ERROR(last_error);
 }