static void btrfsic_bio_end_io(struct bio *bp)
 {
-       struct btrfsic_block *block = (struct btrfsic_block *)bp->bi_private;
+       struct btrfsic_block *block = bp->bi_private;
        int iodone_w_error;
 
        /* mutex is not held! This is not save if IO is not yet completed
 
 
 static int cleaner_kthread(void *arg)
 {
-       struct btrfs_fs_info *fs_info = (struct btrfs_fs_info *)arg;
+       struct btrfs_fs_info *fs_info = arg;
        int again;
 
        while (1) {
 
 static int btrfs_uuid_rescan_kthread(void *data)
 {
-       struct btrfs_fs_info *fs_info = (struct btrfs_fs_info *)data;
+       struct btrfs_fs_info *fs_info = data;
        int ret;
 
        /*
 
 
 static void init_once(void *foo)
 {
-       struct btrfs_inode *ei = (struct btrfs_inode *) foo;
+       struct btrfs_inode *ei = foo;
 
        inode_init_once(&ei->vfs_inode);
 }
 
 static noinline int btrfs_ioctl_tree_search(struct inode *inode,
                                            void __user *argp)
 {
-       struct btrfs_ioctl_search_args __user *uargs;
+       struct btrfs_ioctl_search_args __user *uargs = argp;
        struct btrfs_ioctl_search_key sk;
        int ret;
        size_t buf_size;
        if (!capable(CAP_SYS_ADMIN))
                return -EPERM;
 
-       uargs = (struct btrfs_ioctl_search_args __user *)argp;
-
        if (copy_from_user(&sk, &uargs->key, sizeof(sk)))
                return -EFAULT;
 
 static noinline int btrfs_ioctl_tree_search_v2(struct inode *inode,
                                               void __user *argp)
 {
-       struct btrfs_ioctl_search_args_v2 __user *uarg;
+       struct btrfs_ioctl_search_args_v2 __user *uarg = argp;
        struct btrfs_ioctl_search_args_v2 args;
        int ret;
        size_t buf_size;
                return -EPERM;
 
        /* copy search header and buffer size */
-       uarg = (struct btrfs_ioctl_search_args_v2 __user *)argp;
        if (copy_from_user(&args, uarg, sizeof(args)))
                return -EFAULT;
 
 
        rb_node = rb_simple_search(&rc->reloc_root_tree.rb_root, bytenr);
        if (rb_node) {
                node = rb_entry(rb_node, struct mapping_node, rb_node);
-               root = (struct btrfs_root *)node->data;
+               root = node->data;
        }
        spin_unlock(&rc->reloc_root_tree.lock);
        return btrfs_grab_root(root);
 
 
 static void scrub_parity_bio_endio(struct bio *bio)
 {
-       struct scrub_parity *sparity = (struct scrub_parity *)bio->bi_private;
+       struct scrub_parity *sparity = bio->bi_private;
        struct btrfs_fs_info *fs_info = sparity->sctx->fs_info;
 
        if (bio->bi_status)
 
                items = calc_reclaim_items_nr(fs_info, to_reclaim) * 2;
        }
 
-       trans = (struct btrfs_trans_handle *)current->journal_info;
+       trans = current->journal_info;
 
        /*
         * If we are doing more ordered than delalloc we need to just wait on
 
        if (!btrfs_is_subpage(fs_info, page) || !PagePrivate(page))
                return;
 
-       subpage = (struct btrfs_subpage *)detach_page_private(page);
+       subpage = detach_page_private(page);
        ASSERT(subpage);
        btrfs_free_subpage(subpage);
 }
 
 
 static int relocating_repair_kthread(void *data)
 {
-       struct btrfs_block_group *cache = (struct btrfs_block_group *)data;
+       struct btrfs_block_group *cache = data;
        struct btrfs_fs_info *fs_info = cache->fs_info;
        u64 target;
        int ret = 0;