Re: [PATCH] btrfs: print message when tree-log replay starts

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



Hi David,

I love your patch! Yet something to improve:

[auto build test ERROR on kdave/for-next]
[also build test ERROR on v5.5 next-20200205]
[if your patch is applied to the wrong git tree, please drop us a note to help
improve the system. BTW, we also suggest to use '--base' option to specify the
base tree in git format-patch, please see https://stackoverflow.com/a/37406982]

url:    https://github.com/0day-ci/linux/commits/David-Sterba/btrfs-print-message-when-tree-log-replay-starts/20200206-122055
base:   https://git.kernel.org/pub/scm/linux/kernel/git/kdave/linux.git for-next
config: s390-randconfig-a001-20200206 (attached as .config)
compiler: s390-linux-gcc (GCC) 7.5.0
reproduce:
        wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
        chmod +x ~/bin/make.cross
        # save the attached .config to linux build tree
        GCC_VERSION=7.5.0 make.cross ARCH=s390 

If you fix the issue, kindly add following tag
Reported-by: kbuild test robot <lkp@xxxxxxxxx>

All errors (new ones prefixed by >>):

   fs/btrfs/disk-io.c: In function 'open_ctree':
>> fs/btrfs/disk-io.c:3167:37: error: macro "btrfs_info" requires 3 arguments, but only 1 given
      btrfs_info("start tree-log replay");
                                        ^
>> fs/btrfs/disk-io.c:3167:3: error: 'btrfs_info' undeclared (first use in this function); did you mean 'btrfs_ino'?
      btrfs_info("start tree-log replay");
      ^~~~~~~~~~
      btrfs_ino
   fs/btrfs/disk-io.c:3167:3: note: each undeclared identifier is reported only once for each function it appears in

vim +/btrfs_info +3167 fs/btrfs/disk-io.c

  2626	
  2627	int __cold open_ctree(struct super_block *sb,
  2628		       struct btrfs_fs_devices *fs_devices,
  2629		       char *options)
  2630	{
  2631		u32 sectorsize;
  2632		u32 nodesize;
  2633		u32 stripesize;
  2634		u64 generation;
  2635		u64 features;
  2636		u16 csum_type;
  2637		struct btrfs_key location;
  2638		struct buffer_head *bh;
  2639		struct btrfs_super_block *disk_super;
  2640		struct btrfs_fs_info *fs_info = btrfs_sb(sb);
  2641		struct btrfs_root *tree_root;
  2642		struct btrfs_root *chunk_root;
  2643		int ret;
  2644		int err = -EINVAL;
  2645		int clear_free_space_tree = 0;
  2646		int level;
  2647	
  2648		tree_root = fs_info->tree_root = btrfs_alloc_root(fs_info, GFP_KERNEL);
  2649		chunk_root = fs_info->chunk_root = btrfs_alloc_root(fs_info, GFP_KERNEL);
  2650		if (!tree_root || !chunk_root) {
  2651			err = -ENOMEM;
  2652			goto fail;
  2653		}
  2654	
  2655		ret = init_srcu_struct(&fs_info->subvol_srcu);
  2656		if (ret) {
  2657			err = ret;
  2658			goto fail;
  2659		}
  2660	
  2661		ret = percpu_counter_init(&fs_info->dio_bytes, 0, GFP_KERNEL);
  2662		if (ret) {
  2663			err = ret;
  2664			goto fail_srcu;
  2665		}
  2666	
  2667		ret = percpu_counter_init(&fs_info->dirty_metadata_bytes, 0, GFP_KERNEL);
  2668		if (ret) {
  2669			err = ret;
  2670			goto fail_dio_bytes;
  2671		}
  2672		fs_info->dirty_metadata_batch = PAGE_SIZE *
  2673						(1 + ilog2(nr_cpu_ids));
  2674	
  2675		ret = percpu_counter_init(&fs_info->delalloc_bytes, 0, GFP_KERNEL);
  2676		if (ret) {
  2677			err = ret;
  2678			goto fail_dirty_metadata_bytes;
  2679		}
  2680	
  2681		ret = percpu_counter_init(&fs_info->dev_replace.bio_counter, 0,
  2682				GFP_KERNEL);
  2683		if (ret) {
  2684			err = ret;
  2685			goto fail_delalloc_bytes;
  2686		}
  2687	
  2688		INIT_RADIX_TREE(&fs_info->fs_roots_radix, GFP_ATOMIC);
  2689		INIT_RADIX_TREE(&fs_info->buffer_radix, GFP_ATOMIC);
  2690		INIT_LIST_HEAD(&fs_info->trans_list);
  2691		INIT_LIST_HEAD(&fs_info->dead_roots);
  2692		INIT_LIST_HEAD(&fs_info->delayed_iputs);
  2693		INIT_LIST_HEAD(&fs_info->delalloc_roots);
  2694		INIT_LIST_HEAD(&fs_info->caching_block_groups);
  2695		spin_lock_init(&fs_info->delalloc_root_lock);
  2696		spin_lock_init(&fs_info->trans_lock);
  2697		spin_lock_init(&fs_info->fs_roots_radix_lock);
  2698		spin_lock_init(&fs_info->delayed_iput_lock);
  2699		spin_lock_init(&fs_info->defrag_inodes_lock);
  2700		spin_lock_init(&fs_info->super_lock);
  2701		spin_lock_init(&fs_info->buffer_lock);
  2702		spin_lock_init(&fs_info->unused_bgs_lock);
  2703		rwlock_init(&fs_info->tree_mod_log_lock);
  2704		mutex_init(&fs_info->unused_bg_unpin_mutex);
  2705		mutex_init(&fs_info->delete_unused_bgs_mutex);
  2706		mutex_init(&fs_info->reloc_mutex);
  2707		mutex_init(&fs_info->delalloc_root_mutex);
  2708		seqlock_init(&fs_info->profiles_lock);
  2709	
  2710		INIT_LIST_HEAD(&fs_info->dirty_cowonly_roots);
  2711		INIT_LIST_HEAD(&fs_info->space_info);
  2712		INIT_LIST_HEAD(&fs_info->tree_mod_seq_list);
  2713		INIT_LIST_HEAD(&fs_info->unused_bgs);
  2714		extent_map_tree_init(&fs_info->mapping_tree);
  2715		btrfs_init_block_rsv(&fs_info->global_block_rsv,
  2716				     BTRFS_BLOCK_RSV_GLOBAL);
  2717		btrfs_init_block_rsv(&fs_info->trans_block_rsv, BTRFS_BLOCK_RSV_TRANS);
  2718		btrfs_init_block_rsv(&fs_info->chunk_block_rsv, BTRFS_BLOCK_RSV_CHUNK);
  2719		btrfs_init_block_rsv(&fs_info->empty_block_rsv, BTRFS_BLOCK_RSV_EMPTY);
  2720		btrfs_init_block_rsv(&fs_info->delayed_block_rsv,
  2721				     BTRFS_BLOCK_RSV_DELOPS);
  2722		btrfs_init_block_rsv(&fs_info->delayed_refs_rsv,
  2723				     BTRFS_BLOCK_RSV_DELREFS);
  2724	
  2725		atomic_set(&fs_info->async_delalloc_pages, 0);
  2726		atomic_set(&fs_info->defrag_running, 0);
  2727		atomic_set(&fs_info->reada_works_cnt, 0);
  2728		atomic_set(&fs_info->nr_delayed_iputs, 0);
  2729		atomic64_set(&fs_info->tree_mod_seq, 0);
  2730		fs_info->sb = sb;
  2731		fs_info->max_inline = BTRFS_DEFAULT_MAX_INLINE;
  2732		fs_info->metadata_ratio = 0;
  2733		fs_info->defrag_inodes = RB_ROOT;
  2734		atomic64_set(&fs_info->free_chunk_space, 0);
  2735		fs_info->tree_mod_log = RB_ROOT;
  2736		fs_info->commit_interval = BTRFS_DEFAULT_COMMIT_INTERVAL;
  2737		fs_info->avg_delayed_ref_runtime = NSEC_PER_SEC >> 6; /* div by 64 */
  2738		/* readahead state */
  2739		INIT_RADIX_TREE(&fs_info->reada_tree, GFP_NOFS & ~__GFP_DIRECT_RECLAIM);
  2740		spin_lock_init(&fs_info->reada_lock);
  2741		btrfs_init_ref_verify(fs_info);
  2742	
  2743		fs_info->thread_pool_size = min_t(unsigned long,
  2744						  num_online_cpus() + 2, 8);
  2745	
  2746		INIT_LIST_HEAD(&fs_info->ordered_roots);
  2747		spin_lock_init(&fs_info->ordered_root_lock);
  2748	
  2749		fs_info->btree_inode = new_inode(sb);
  2750		if (!fs_info->btree_inode) {
  2751			err = -ENOMEM;
  2752			goto fail_bio_counter;
  2753		}
  2754		mapping_set_gfp_mask(fs_info->btree_inode->i_mapping, GFP_NOFS);
  2755	
  2756		fs_info->delayed_root = kmalloc(sizeof(struct btrfs_delayed_root),
  2757						GFP_KERNEL);
  2758		if (!fs_info->delayed_root) {
  2759			err = -ENOMEM;
  2760			goto fail_iput;
  2761		}
  2762		btrfs_init_delayed_root(fs_info->delayed_root);
  2763	
  2764		btrfs_init_scrub(fs_info);
  2765	#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
  2766		fs_info->check_integrity_print_mask = 0;
  2767	#endif
  2768		btrfs_init_balance(fs_info);
  2769		btrfs_init_async_reclaim_work(&fs_info->async_reclaim_work);
  2770	
  2771		sb->s_blocksize = BTRFS_BDEV_BLOCKSIZE;
  2772		sb->s_blocksize_bits = blksize_bits(BTRFS_BDEV_BLOCKSIZE);
  2773	
  2774		btrfs_init_btree_inode(fs_info);
  2775	
  2776		spin_lock_init(&fs_info->block_group_cache_lock);
  2777		fs_info->block_group_cache_tree = RB_ROOT;
  2778		fs_info->first_logical_byte = (u64)-1;
  2779	
  2780		extent_io_tree_init(fs_info, &fs_info->freed_extents[0],
  2781				    IO_TREE_FS_INFO_FREED_EXTENTS0, NULL);
  2782		extent_io_tree_init(fs_info, &fs_info->freed_extents[1],
  2783				    IO_TREE_FS_INFO_FREED_EXTENTS1, NULL);
  2784		fs_info->pinned_extents = &fs_info->freed_extents[0];
  2785		set_bit(BTRFS_FS_BARRIER, &fs_info->flags);
  2786	
  2787		mutex_init(&fs_info->ordered_operations_mutex);
  2788		mutex_init(&fs_info->tree_log_mutex);
  2789		mutex_init(&fs_info->chunk_mutex);
  2790		mutex_init(&fs_info->transaction_kthread_mutex);
  2791		mutex_init(&fs_info->cleaner_mutex);
  2792		mutex_init(&fs_info->ro_block_group_mutex);
  2793		init_rwsem(&fs_info->commit_root_sem);
  2794		init_rwsem(&fs_info->cleanup_work_sem);
  2795		init_rwsem(&fs_info->subvol_sem);
  2796		sema_init(&fs_info->uuid_tree_rescan_sem, 1);
  2797	
  2798		btrfs_init_dev_replace_locks(fs_info);
  2799		btrfs_init_qgroup(fs_info);
  2800		btrfs_discard_init(fs_info);
  2801	
  2802		btrfs_init_free_cluster(&fs_info->meta_alloc_cluster);
  2803		btrfs_init_free_cluster(&fs_info->data_alloc_cluster);
  2804	
  2805		init_waitqueue_head(&fs_info->transaction_throttle);
  2806		init_waitqueue_head(&fs_info->transaction_wait);
  2807		init_waitqueue_head(&fs_info->transaction_blocked_wait);
  2808		init_waitqueue_head(&fs_info->async_submit_wait);
  2809		init_waitqueue_head(&fs_info->delayed_iputs_wait);
  2810	
  2811		/* Usable values until the real ones are cached from the superblock */
  2812		fs_info->nodesize = 4096;
  2813		fs_info->sectorsize = 4096;
  2814		fs_info->stripesize = 4096;
  2815	
  2816		spin_lock_init(&fs_info->swapfile_pins_lock);
  2817		fs_info->swapfile_pins = RB_ROOT;
  2818	
  2819		fs_info->send_in_progress = 0;
  2820	
  2821		ret = btrfs_alloc_stripe_hash_table(fs_info);
  2822		if (ret) {
  2823			err = ret;
  2824			goto fail_alloc;
  2825		}
  2826	
  2827		__setup_root(tree_root, fs_info, BTRFS_ROOT_TREE_OBJECTID);
  2828	
  2829		invalidate_bdev(fs_devices->latest_bdev);
  2830	
  2831		/*
  2832		 * Read super block and check the signature bytes only
  2833		 */
  2834		bh = btrfs_read_dev_super(fs_devices->latest_bdev);
  2835		if (IS_ERR(bh)) {
  2836			err = PTR_ERR(bh);
  2837			goto fail_alloc;
  2838		}
  2839	
  2840		/*
  2841		 * Verify the type first, if that or the the checksum value are
  2842		 * corrupted, we'll find out
  2843		 */
  2844		csum_type = btrfs_super_csum_type((struct btrfs_super_block *)bh->b_data);
  2845		if (!btrfs_supported_super_csum(csum_type)) {
  2846			btrfs_err(fs_info, "unsupported checksum algorithm: %u",
  2847				  csum_type);
  2848			err = -EINVAL;
  2849			brelse(bh);
  2850			goto fail_alloc;
  2851		}
  2852	
  2853		ret = btrfs_init_csum_hash(fs_info, csum_type);
  2854		if (ret) {
  2855			err = ret;
  2856			goto fail_alloc;
  2857		}
  2858	
  2859		/*
  2860		 * We want to check superblock checksum, the type is stored inside.
  2861		 * Pass the whole disk block of size BTRFS_SUPER_INFO_SIZE (4k).
  2862		 */
  2863		if (btrfs_check_super_csum(fs_info, bh->b_data)) {
  2864			btrfs_err(fs_info, "superblock checksum mismatch");
  2865			err = -EINVAL;
  2866			brelse(bh);
  2867			goto fail_csum;
  2868		}
  2869	
  2870		/*
  2871		 * super_copy is zeroed at allocation time and we never touch the
  2872		 * following bytes up to INFO_SIZE, the checksum is calculated from
  2873		 * the whole block of INFO_SIZE
  2874		 */
  2875		memcpy(fs_info->super_copy, bh->b_data, sizeof(*fs_info->super_copy));
  2876		brelse(bh);
  2877	
  2878		disk_super = fs_info->super_copy;
  2879	
  2880		ASSERT(!memcmp(fs_info->fs_devices->fsid, fs_info->super_copy->fsid,
  2881			       BTRFS_FSID_SIZE));
  2882	
  2883		if (btrfs_fs_incompat(fs_info, METADATA_UUID)) {
  2884			ASSERT(!memcmp(fs_info->fs_devices->metadata_uuid,
  2885					fs_info->super_copy->metadata_uuid,
  2886					BTRFS_FSID_SIZE));
  2887		}
  2888	
  2889		features = btrfs_super_flags(disk_super);
  2890		if (features & BTRFS_SUPER_FLAG_CHANGING_FSID_V2) {
  2891			features &= ~BTRFS_SUPER_FLAG_CHANGING_FSID_V2;
  2892			btrfs_set_super_flags(disk_super, features);
  2893			btrfs_info(fs_info,
  2894				"found metadata UUID change in progress flag, clearing");
  2895		}
  2896	
  2897		memcpy(fs_info->super_for_commit, fs_info->super_copy,
  2898		       sizeof(*fs_info->super_for_commit));
  2899	
  2900		ret = btrfs_validate_mount_super(fs_info);
  2901		if (ret) {
  2902			btrfs_err(fs_info, "superblock contains fatal errors");
  2903			err = -EINVAL;
  2904			goto fail_csum;
  2905		}
  2906	
  2907		if (!btrfs_super_root(disk_super))
  2908			goto fail_csum;
  2909	
  2910		/* check FS state, whether FS is broken. */
  2911		if (btrfs_super_flags(disk_super) & BTRFS_SUPER_FLAG_ERROR)
  2912			set_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state);
  2913	
  2914		/*
  2915		 * In the long term, we'll store the compression type in the super
  2916		 * block, and it'll be used for per file compression control.
  2917		 */
  2918		fs_info->compress_type = BTRFS_COMPRESS_ZLIB;
  2919	
  2920		ret = btrfs_parse_options(fs_info, options, sb->s_flags);
  2921		if (ret) {
  2922			err = ret;
  2923			goto fail_csum;
  2924		}
  2925	
  2926		features = btrfs_super_incompat_flags(disk_super) &
  2927			~BTRFS_FEATURE_INCOMPAT_SUPP;
  2928		if (features) {
  2929			btrfs_err(fs_info,
  2930			    "cannot mount because of unsupported optional features (%llx)",
  2931			    features);
  2932			err = -EINVAL;
  2933			goto fail_csum;
  2934		}
  2935	
  2936		features = btrfs_super_incompat_flags(disk_super);
  2937		features |= BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF;
  2938		if (fs_info->compress_type == BTRFS_COMPRESS_LZO)
  2939			features |= BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO;
  2940		else if (fs_info->compress_type == BTRFS_COMPRESS_ZSTD)
  2941			features |= BTRFS_FEATURE_INCOMPAT_COMPRESS_ZSTD;
  2942	
  2943		if (features & BTRFS_FEATURE_INCOMPAT_SKINNY_METADATA)
  2944			btrfs_info(fs_info, "has skinny extents");
  2945	
  2946		/*
  2947		 * flag our filesystem as having big metadata blocks if
  2948		 * they are bigger than the page size
  2949		 */
  2950		if (btrfs_super_nodesize(disk_super) > PAGE_SIZE) {
  2951			if (!(features & BTRFS_FEATURE_INCOMPAT_BIG_METADATA))
  2952				btrfs_info(fs_info,
  2953					"flagging fs with big metadata feature");
  2954			features |= BTRFS_FEATURE_INCOMPAT_BIG_METADATA;
  2955		}
  2956	
  2957		nodesize = btrfs_super_nodesize(disk_super);
  2958		sectorsize = btrfs_super_sectorsize(disk_super);
  2959		stripesize = sectorsize;
  2960		fs_info->dirty_metadata_batch = nodesize * (1 + ilog2(nr_cpu_ids));
  2961		fs_info->delalloc_batch = sectorsize * 512 * (1 + ilog2(nr_cpu_ids));
  2962	
  2963		/* Cache block sizes */
  2964		fs_info->nodesize = nodesize;
  2965		fs_info->sectorsize = sectorsize;
  2966		fs_info->stripesize = stripesize;
  2967	
  2968		/*
  2969		 * mixed block groups end up with duplicate but slightly offset
  2970		 * extent buffers for the same range.  It leads to corruptions
  2971		 */
  2972		if ((features & BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS) &&
  2973		    (sectorsize != nodesize)) {
  2974			btrfs_err(fs_info,
  2975	"unequal nodesize/sectorsize (%u != %u) are not allowed for mixed block groups",
  2976				nodesize, sectorsize);
  2977			goto fail_csum;
  2978		}
  2979	
  2980		/*
  2981		 * Needn't use the lock because there is no other task which will
  2982		 * update the flag.
  2983		 */
  2984		btrfs_set_super_incompat_flags(disk_super, features);
  2985	
  2986		features = btrfs_super_compat_ro_flags(disk_super) &
  2987			~BTRFS_FEATURE_COMPAT_RO_SUPP;
  2988		if (!sb_rdonly(sb) && features) {
  2989			btrfs_err(fs_info,
  2990		"cannot mount read-write because of unsupported optional features (%llx)",
  2991			       features);
  2992			err = -EINVAL;
  2993			goto fail_csum;
  2994		}
  2995	
  2996		ret = btrfs_init_workqueues(fs_info, fs_devices);
  2997		if (ret) {
  2998			err = ret;
  2999			goto fail_sb_buffer;
  3000		}
  3001	
  3002		sb->s_bdi->congested_fn = btrfs_congested_fn;
  3003		sb->s_bdi->congested_data = fs_info;
  3004		sb->s_bdi->capabilities |= BDI_CAP_CGROUP_WRITEBACK;
  3005		sb->s_bdi->ra_pages = VM_READAHEAD_PAGES;
  3006		sb->s_bdi->ra_pages *= btrfs_super_num_devices(disk_super);
  3007		sb->s_bdi->ra_pages = max(sb->s_bdi->ra_pages, SZ_4M / PAGE_SIZE);
  3008	
  3009		sb->s_blocksize = sectorsize;
  3010		sb->s_blocksize_bits = blksize_bits(sectorsize);
  3011		memcpy(&sb->s_uuid, fs_info->fs_devices->fsid, BTRFS_FSID_SIZE);
  3012	
  3013		mutex_lock(&fs_info->chunk_mutex);
  3014		ret = btrfs_read_sys_array(fs_info);
  3015		mutex_unlock(&fs_info->chunk_mutex);
  3016		if (ret) {
  3017			btrfs_err(fs_info, "failed to read the system array: %d", ret);
  3018			goto fail_sb_buffer;
  3019		}
  3020	
  3021		generation = btrfs_super_chunk_root_generation(disk_super);
  3022		level = btrfs_super_chunk_root_level(disk_super);
  3023	
  3024		__setup_root(chunk_root, fs_info, BTRFS_CHUNK_TREE_OBJECTID);
  3025	
  3026		chunk_root->node = read_tree_block(fs_info,
  3027						   btrfs_super_chunk_root(disk_super),
  3028						   generation, level, NULL);
  3029		if (IS_ERR(chunk_root->node) ||
  3030		    !extent_buffer_uptodate(chunk_root->node)) {
  3031			btrfs_err(fs_info, "failed to read chunk root");
  3032			if (!IS_ERR(chunk_root->node))
  3033				free_extent_buffer(chunk_root->node);
  3034			chunk_root->node = NULL;
  3035			goto fail_tree_roots;
  3036		}
  3037		btrfs_set_root_node(&chunk_root->root_item, chunk_root->node);
  3038		chunk_root->commit_root = btrfs_root_node(chunk_root);
  3039	
  3040		read_extent_buffer(chunk_root->node, fs_info->chunk_tree_uuid,
  3041		   btrfs_header_chunk_tree_uuid(chunk_root->node), BTRFS_UUID_SIZE);
  3042	
  3043		ret = btrfs_read_chunk_tree(fs_info);
  3044		if (ret) {
  3045			btrfs_err(fs_info, "failed to read chunk tree: %d", ret);
  3046			goto fail_tree_roots;
  3047		}
  3048	
  3049		/*
  3050		 * Keep the devid that is marked to be the target device for the
  3051		 * device replace procedure
  3052		 */
  3053		btrfs_free_extra_devids(fs_devices, 0);
  3054	
  3055		if (!fs_devices->latest_bdev) {
  3056			btrfs_err(fs_info, "failed to read devices");
  3057			goto fail_tree_roots;
  3058		}
  3059	
  3060		ret = init_tree_roots(fs_info);
  3061		if (ret)
  3062			goto fail_tree_roots;
  3063	
  3064		ret = btrfs_verify_dev_extents(fs_info);
  3065		if (ret) {
  3066			btrfs_err(fs_info,
  3067				  "failed to verify dev extents against chunks: %d",
  3068				  ret);
  3069			goto fail_block_groups;
  3070		}
  3071		ret = btrfs_recover_balance(fs_info);
  3072		if (ret) {
  3073			btrfs_err(fs_info, "failed to recover balance: %d", ret);
  3074			goto fail_block_groups;
  3075		}
  3076	
  3077		ret = btrfs_init_dev_stats(fs_info);
  3078		if (ret) {
  3079			btrfs_err(fs_info, "failed to init dev_stats: %d", ret);
  3080			goto fail_block_groups;
  3081		}
  3082	
  3083		ret = btrfs_init_dev_replace(fs_info);
  3084		if (ret) {
  3085			btrfs_err(fs_info, "failed to init dev_replace: %d", ret);
  3086			goto fail_block_groups;
  3087		}
  3088	
  3089		btrfs_free_extra_devids(fs_devices, 1);
  3090	
  3091		ret = btrfs_sysfs_add_fsid(fs_devices);
  3092		if (ret) {
  3093			btrfs_err(fs_info, "failed to init sysfs fsid interface: %d",
  3094					ret);
  3095			goto fail_block_groups;
  3096		}
  3097	
  3098		ret = btrfs_sysfs_add_mounted(fs_info);
  3099		if (ret) {
  3100			btrfs_err(fs_info, "failed to init sysfs interface: %d", ret);
  3101			goto fail_fsdev_sysfs;
  3102		}
  3103	
  3104		ret = btrfs_init_space_info(fs_info);
  3105		if (ret) {
  3106			btrfs_err(fs_info, "failed to initialize space info: %d", ret);
  3107			goto fail_sysfs;
  3108		}
  3109	
  3110		ret = btrfs_read_block_groups(fs_info);
  3111		if (ret) {
  3112			btrfs_err(fs_info, "failed to read block groups: %d", ret);
  3113			goto fail_sysfs;
  3114		}
  3115	
  3116		if (!sb_rdonly(sb) && !btrfs_check_rw_degradable(fs_info, NULL)) {
  3117			btrfs_warn(fs_info,
  3118			"writable mount is not allowed due to too many missing devices");
  3119			goto fail_sysfs;
  3120		}
  3121	
  3122		fs_info->cleaner_kthread = kthread_run(cleaner_kthread, tree_root,
  3123						       "btrfs-cleaner");
  3124		if (IS_ERR(fs_info->cleaner_kthread))
  3125			goto fail_sysfs;
  3126	
  3127		fs_info->transaction_kthread = kthread_run(transaction_kthread,
  3128							   tree_root,
  3129							   "btrfs-transaction");
  3130		if (IS_ERR(fs_info->transaction_kthread))
  3131			goto fail_cleaner;
  3132	
  3133		if (!btrfs_test_opt(fs_info, NOSSD) &&
  3134		    !fs_info->fs_devices->rotating) {
  3135			btrfs_set_and_info(fs_info, SSD, "enabling ssd optimizations");
  3136		}
  3137	
  3138		/*
  3139		 * Mount does not set all options immediately, we can do it now and do
  3140		 * not have to wait for transaction commit
  3141		 */
  3142		btrfs_apply_pending_changes(fs_info);
  3143	
  3144	#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
  3145		if (btrfs_test_opt(fs_info, CHECK_INTEGRITY)) {
  3146			ret = btrfsic_mount(fs_info, fs_devices,
  3147					    btrfs_test_opt(fs_info,
  3148						CHECK_INTEGRITY_INCLUDING_EXTENT_DATA) ?
  3149					    1 : 0,
  3150					    fs_info->check_integrity_print_mask);
  3151			if (ret)
  3152				btrfs_warn(fs_info,
  3153					"failed to initialize integrity check module: %d",
  3154					ret);
  3155		}
  3156	#endif
  3157		ret = btrfs_read_qgroup_config(fs_info);
  3158		if (ret)
  3159			goto fail_trans_kthread;
  3160	
  3161		if (btrfs_build_ref_tree(fs_info))
  3162			btrfs_err(fs_info, "couldn't build ref tree");
  3163	
  3164		/* do not make disk changes in broken FS or nologreplay is given */
  3165		if (btrfs_super_log_root(disk_super) != 0 &&
  3166		    !btrfs_test_opt(fs_info, NOLOGREPLAY)) {
> 3167			btrfs_info("start tree-log replay");
  3168			ret = btrfs_replay_log(fs_info, fs_devices);
  3169			if (ret) {
  3170				err = ret;
  3171				goto fail_qgroup;
  3172			}
  3173		}
  3174	
  3175		ret = btrfs_find_orphan_roots(fs_info);
  3176		if (ret)
  3177			goto fail_qgroup;
  3178	
  3179		if (!sb_rdonly(sb)) {
  3180			ret = btrfs_cleanup_fs_roots(fs_info);
  3181			if (ret)
  3182				goto fail_qgroup;
  3183	
  3184			mutex_lock(&fs_info->cleaner_mutex);
  3185			ret = btrfs_recover_relocation(tree_root);
  3186			mutex_unlock(&fs_info->cleaner_mutex);
  3187			if (ret < 0) {
  3188				btrfs_warn(fs_info, "failed to recover relocation: %d",
  3189						ret);
  3190				err = -EINVAL;
  3191				goto fail_qgroup;
  3192			}
  3193		}
  3194	
  3195		location.objectid = BTRFS_FS_TREE_OBJECTID;
  3196		location.type = BTRFS_ROOT_ITEM_KEY;
  3197		location.offset = 0;
  3198	
  3199		fs_info->fs_root = btrfs_read_fs_root_no_name(fs_info, &location);
  3200		if (IS_ERR(fs_info->fs_root)) {
  3201			err = PTR_ERR(fs_info->fs_root);
  3202			btrfs_warn(fs_info, "failed to read fs tree: %d", err);
  3203			goto fail_qgroup;
  3204		}
  3205	
  3206		if (sb_rdonly(sb))
  3207			return 0;
  3208	
  3209		if (btrfs_test_opt(fs_info, CLEAR_CACHE) &&
  3210		    btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE)) {
  3211			clear_free_space_tree = 1;
  3212		} else if (btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE) &&
  3213			   !btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE_VALID)) {
  3214			btrfs_warn(fs_info, "free space tree is invalid");
  3215			clear_free_space_tree = 1;
  3216		}
  3217	
  3218		if (clear_free_space_tree) {
  3219			btrfs_info(fs_info, "clearing free space tree");
  3220			ret = btrfs_clear_free_space_tree(fs_info);
  3221			if (ret) {
  3222				btrfs_warn(fs_info,
  3223					   "failed to clear free space tree: %d", ret);
  3224				close_ctree(fs_info);
  3225				return ret;
  3226			}
  3227		}
  3228	
  3229		if (btrfs_test_opt(fs_info, FREE_SPACE_TREE) &&
  3230		    !btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE)) {
  3231			btrfs_info(fs_info, "creating free space tree");
  3232			ret = btrfs_create_free_space_tree(fs_info);
  3233			if (ret) {
  3234				btrfs_warn(fs_info,
  3235					"failed to create free space tree: %d", ret);
  3236				close_ctree(fs_info);
  3237				return ret;
  3238			}
  3239		}
  3240	
  3241		down_read(&fs_info->cleanup_work_sem);
  3242		if ((ret = btrfs_orphan_cleanup(fs_info->fs_root)) ||
  3243		    (ret = btrfs_orphan_cleanup(fs_info->tree_root))) {
  3244			up_read(&fs_info->cleanup_work_sem);
  3245			close_ctree(fs_info);
  3246			return ret;
  3247		}
  3248		up_read(&fs_info->cleanup_work_sem);
  3249	
  3250		ret = btrfs_resume_balance_async(fs_info);
  3251		if (ret) {
  3252			btrfs_warn(fs_info, "failed to resume balance: %d", ret);
  3253			close_ctree(fs_info);
  3254			return ret;
  3255		}
  3256	
  3257		ret = btrfs_resume_dev_replace_async(fs_info);
  3258		if (ret) {
  3259			btrfs_warn(fs_info, "failed to resume device replace: %d", ret);
  3260			close_ctree(fs_info);
  3261			return ret;
  3262		}
  3263	
  3264		btrfs_qgroup_rescan_resume(fs_info);
  3265		btrfs_discard_resume(fs_info);
  3266	
  3267		if (!fs_info->uuid_root) {
  3268			btrfs_info(fs_info, "creating UUID tree");
  3269			ret = btrfs_create_uuid_tree(fs_info);
  3270			if (ret) {
  3271				btrfs_warn(fs_info,
  3272					"failed to create the UUID tree: %d", ret);
  3273				close_ctree(fs_info);
  3274				return ret;
  3275			}
  3276		} else if (btrfs_test_opt(fs_info, RESCAN_UUID_TREE) ||
  3277			   fs_info->generation !=
  3278					btrfs_super_uuid_tree_generation(disk_super)) {
  3279			btrfs_info(fs_info, "checking UUID tree");
  3280			ret = btrfs_check_uuid_tree(fs_info);
  3281			if (ret) {
  3282				btrfs_warn(fs_info,
  3283					"failed to check the UUID tree: %d", ret);
  3284				close_ctree(fs_info);
  3285				return ret;
  3286			}
  3287		} else {
  3288			set_bit(BTRFS_FS_UPDATE_UUID_TREE_GEN, &fs_info->flags);
  3289		}
  3290		set_bit(BTRFS_FS_OPEN, &fs_info->flags);
  3291	
  3292		/*
  3293		 * backuproot only affect mount behavior, and if open_ctree succeeded,
  3294		 * no need to keep the flag
  3295		 */
  3296		btrfs_clear_opt(fs_info->mount_opt, USEBACKUPROOT);
  3297	
  3298		return 0;
  3299	
  3300	fail_qgroup:
  3301		btrfs_free_qgroup_config(fs_info);
  3302	fail_trans_kthread:
  3303		kthread_stop(fs_info->transaction_kthread);
  3304		btrfs_cleanup_transaction(fs_info);
  3305		btrfs_free_fs_roots(fs_info);
  3306	fail_cleaner:
  3307		kthread_stop(fs_info->cleaner_kthread);
  3308	
  3309		/*
  3310		 * make sure we're done with the btree inode before we stop our
  3311		 * kthreads
  3312		 */
  3313		filemap_write_and_wait(fs_info->btree_inode->i_mapping);
  3314	
  3315	fail_sysfs:
  3316		btrfs_sysfs_remove_mounted(fs_info);
  3317	
  3318	fail_fsdev_sysfs:
  3319		btrfs_sysfs_remove_fsid(fs_info->fs_devices);
  3320	
  3321	fail_block_groups:
  3322		btrfs_put_block_group_cache(fs_info);
  3323	
  3324	fail_tree_roots:
  3325		free_root_pointers(fs_info, true);
  3326		invalidate_inode_pages2(fs_info->btree_inode->i_mapping);
  3327	
  3328	fail_sb_buffer:
  3329		btrfs_stop_all_workers(fs_info);
  3330		btrfs_free_block_groups(fs_info);
  3331	fail_csum:
  3332		btrfs_free_csum_hash(fs_info);
  3333	fail_alloc:
  3334	fail_iput:
  3335		btrfs_mapping_tree_free(&fs_info->mapping_tree);
  3336	
  3337		iput(fs_info->btree_inode);
  3338	fail_bio_counter:
  3339		percpu_counter_destroy(&fs_info->dev_replace.bio_counter);
  3340	fail_delalloc_bytes:
  3341		percpu_counter_destroy(&fs_info->delalloc_bytes);
  3342	fail_dirty_metadata_bytes:
  3343		percpu_counter_destroy(&fs_info->dirty_metadata_bytes);
  3344	fail_dio_bytes:
  3345		percpu_counter_destroy(&fs_info->dio_bytes);
  3346	fail_srcu:
  3347		cleanup_srcu_struct(&fs_info->subvol_srcu);
  3348	fail:
  3349		btrfs_free_stripe_hash_table(fs_info);
  3350		btrfs_close_devices(fs_info->fs_devices);
  3351		return err;
  3352	}
  3353	ALLOW_ERROR_INJECTION(open_ctree, ERRNO);
  3354	

---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all@xxxxxxxxxxxx

Attachment: .config.gz
Description: application/gzip


[Index of Archives]     [Linux Kernel]     [Kernel Development Newbies]     [Linux USB Devel]     [Video for Linux]     [Linux Audio Users]     [Yosemite Hiking]     [Linux Kernel]     [Linux SCSI]

  Powered by Linux