[kbuild-all] [sashal-linux-stable:queue-5.4 116/132] fs/btrfs/inode.c:10982:7: error: implicit declaration of function 'btrfs_drew_try_write_lock'

tree: https://git.kernel.org/pub/scm/linux/kernel/git/sashal/linux-stable.git queue-5.4 head: d2c5af89e80c5b71f1da59879464a930947306a2 commit: 5f6e061c42f11262ce5b8065b50d90aaa970939b [116/132] btrfs: fix race between swap file activation and snapshot creation config: x86_64-randconfig-r033-20210318 (attached as .config) compiler: clang version 13.0.0 (https://github.com/llvm/llvm-project 436c6c9c20cc522c92a923440a5fc509c342a7db) reproduce (this is a W=1 build): wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross # install x86_64 cross compiling tool for clang build # apt-get install binutils-x86-64-linux-gnu # https://git.kernel.org/pub/scm/linux/kernel/git/sashal/linux-stable.git/c... git remote add sashal-linux-stable https://git.kernel.org/pub/scm/linux/kernel/git/sashal/linux-stable.git git fetch --no-tags sashal-linux-stable queue-5.4 git checkout 5f6e061c42f11262ce5b8065b50d90aaa970939b # save the attached .config to linux build tree COMPILER_INSTALL_PATH=$HOME/0day COMPILER=clang make.cross ARCH=x86_64 If you fix the issue, kindly add following tag as appropriate Reported-by: kernel test robot <lkp(a)intel.com&gt; All errors (new ones prefixed by >>): if (!btrfs_drew_try_write_lock(&root->snapshot_lock)) { ^ fs/btrfs/inode.c:10982:7: note: did you mean 'btrfs_try_tree_write_lock'? fs/btrfs/locking.h:24:5: note: 'btrfs_try_tree_write_lock' declared here int btrfs_try_tree_write_lock(struct extent_buffer *eb); ^ if (!btrfs_drew_try_write_lock(&root->snapshot_lock)) { ~~~~ ^ btrfs_drew_write_unlock(&root->snapshot_lock); ^ fs/btrfs/inode.c:11129:33: error: no member named 'snapshot_lock' in 'struct btrfs_root' btrfs_drew_write_unlock(&root->snapshot_lock); ~~~~ ^ 4 errors generated. vim +/btrfs_drew_try_write_lock +10982 fs/btrfs/inode.c 10917 10918 static int btrfs_swap_activate(struct swap_info_struct *sis, struct file *file, 10919 sector_t *span) 10920 { 10921 struct inode *inode = file_inode(file); 10922 struct btrfs_root *root = BTRFS_I(inode)->root; 10923 struct btrfs_fs_info *fs_info = root->fs_info; 10924 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree; 10925 struct extent_state *cached_state = NULL; 10926 struct extent_map *em = NULL; 10927 struct btrfs_device *device = NULL; 10928 struct btrfs_swap_info bsi = { 10929 .lowest_ppage = (sector_t)-1ULL, 10930 }; 10931 int ret = 0; 10932 u64 isize; 10933 u64 start; 10934 10935 /* 10936 * If the swap file was just created, make sure delalloc is done. If the 10937 * file changes again after this, the user is doing something stupid and 10938 * we don't really care. 10939 */ 10940 ret = btrfs_wait_ordered_range(inode, 0, (u64)-1); 10941 if (ret) 10942 return ret; 10943 10944 /* 10945 * The inode is locked, so these flags won't change after we check them. 10946 */ 10947 if (BTRFS_I(inode)->flags & BTRFS_INODE_COMPRESS) { 10948 btrfs_warn(fs_info, "swapfile must not be compressed"); 10949 return -EINVAL; 10950 } 10951 if (!(BTRFS_I(inode)->flags & BTRFS_INODE_NODATACOW)) { 10952 btrfs_warn(fs_info, "swapfile must not be copy-on-write"); 10953 return -EINVAL; 10954 } 10955 if (!(BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM)) { 10956 btrfs_warn(fs_info, "swapfile must not be checksummed"); 10957 return -EINVAL; 10958 } 10959 10960 /* 10961 * Balance or device remove/replace/resize can move stuff around from 10962 * under us. The exclop protection makes sure they aren't running/won't 10963 * run concurrently while we are mapping the swap extents, and 10964 * fs_info->swapfile_pins prevents them from running while the swap 10965 * file is active and moving the extents. Note that this also prevents 10966 * a concurrent device add which isn't actually necessary, but it's not 10967 * really worth the trouble to allow it. 10968 */ 10969 if (!btrfs_exclop_start(fs_info, BTRFS_EXCLOP_SWAP_ACTIVATE)) { 10970 btrfs_warn(fs_info, 10971 "cannot activate swapfile while exclusive operation is running"); 10972 return -EBUSY; 10973 } 10974 10975 /* 10976 * Prevent snapshot creation while we are activating the swap file. 10977 * We do not want to race with snapshot creation. If snapshot creation 10978 * already started before we bumped nr_swapfiles from 0 to 1 and 10979 * completes before the first write into the swap file after it is 10980 * activated, than that write would fallback to COW. 10981 */ 10982 if (!btrfs_drew_try_write_lock(&root->snapshot_lock)) { 10983 btrfs_exclop_finish(fs_info); 10984 btrfs_warn(fs_info, 10985 "cannot activate swapfile because snapshot creation is in progress"); 10986 return -EINVAL; 10987 } 10988 /* 10989 * Snapshots can create extents which require COW even if NODATACOW is 10990 * set. We use this counter to prevent snapshots. We must increment it 10991 * before walking the extents because we don't want a concurrent 10992 * snapshot to run after we've already checked the extents. 10993 */ 10994 atomic_inc(&root->nr_swapfiles); 10995 10996 isize = ALIGN_DOWN(inode->i_size, fs_info->sectorsize); 10997 10998 lock_extent_bits(io_tree, 0, isize - 1, &cached_state); 10999 start = 0; 11000 while (start < isize) { 11001 u64 logical_block_start, physical_block_start; 11002 struct btrfs_block_group_cache *bg; 11003 u64 len = isize - start; 11004 11005 em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, start, len, 0); 11006 if (IS_ERR(em)) { 11007 ret = PTR_ERR(em); 11008 goto out; 11009 } 11010 11011 if (em->block_start == EXTENT_MAP_HOLE) { 11012 btrfs_warn(fs_info, "swapfile must not have holes"); 11013 ret = -EINVAL; 11014 goto out; 11015 } 11016 if (em->block_start == EXTENT_MAP_INLINE) { 11017 /* 11018 * It's unlikely we'll ever actually find ourselves 11019 * here, as a file small enough to fit inline won't be 11020 * big enough to store more than the swap header, but in 11021 * case something changes in the future, let's catch it 11022 * here rather than later. 11023 */ 11024 btrfs_warn(fs_info, "swapfile must not be inline"); 11025 ret = -EINVAL; 11026 goto out; 11027 } 11028 if (test_bit(EXTENT_FLAG_COMPRESSED, &em->flags)) { 11029 btrfs_warn(fs_info, "swapfile must not be compressed"); 11030 ret = -EINVAL; 11031 goto out; 11032 } 11033 11034 logical_block_start = em->block_start + (start - em->start); 11035 len = min(len, em->len - (start - em->start)); 11036 free_extent_map(em); 11037 em = NULL; 11038 11039 ret = can_nocow_extent(inode, start, &len, NULL, NULL, NULL, true); 11040 if (ret < 0) { 11041 goto out; 11042 } else if (ret) { 11043 ret = 0; 11044 } else { 11045 btrfs_warn(fs_info, 11046 "swapfile must not be copy-on-write"); 11047 ret = -EINVAL; 11048 goto out; 11049 } 11050 11051 em = btrfs_get_chunk_map(fs_info, logical_block_start, len); 11052 if (IS_ERR(em)) { 11053 ret = PTR_ERR(em); 11054 goto out; 11055 } 11056 11057 if (em->map_lookup->type & BTRFS_BLOCK_GROUP_PROFILE_MASK) { 11058 btrfs_warn(fs_info, 11059 "swapfile must have single data profile"); 11060 ret = -EINVAL; 11061 goto out; 11062 } 11063 11064 if (device == NULL) { 11065 device = em->map_lookup->stripes[0].dev; 11066 ret = btrfs_add_swapfile_pin(inode, device, false); 11067 if (ret == 1) 11068 ret = 0; 11069 else if (ret) 11070 goto out; 11071 } else if (device != em->map_lookup->stripes[0].dev) { 11072 btrfs_warn(fs_info, "swapfile must be on one device"); 11073 ret = -EINVAL; 11074 goto out; 11075 } 11076 11077 physical_block_start = (em->map_lookup->stripes[0].physical + 11078 (logical_block_start - em->start)); 11079 len = min(len, em->len - (logical_block_start - em->start)); 11080 free_extent_map(em); 11081 em = NULL; 11082 11083 bg = btrfs_lookup_block_group(fs_info, logical_block_start); 11084 if (!bg) { 11085 btrfs_warn(fs_info, 11086 "could not find block group containing swapfile"); 11087 ret = -EINVAL; 11088 goto out; 11089 } 11090 11091 ret = btrfs_add_swapfile_pin(inode, bg, true); 11092 if (ret) { 11093 btrfs_put_block_group(bg); 11094 if (ret == 1) 11095 ret = 0; 11096 else 11097 goto out; 11098 } 11099 11100 if (bsi.block_len && 11101 bsi.block_start + bsi.block_len == physical_block_start) { 11102 bsi.block_len += len; 11103 } else { 11104 if (bsi.block_len) { 11105 ret = btrfs_add_swap_extent(sis, &bsi); 11106 if (ret) 11107 goto out; 11108 } 11109 bsi.start = start; 11110 bsi.block_start = physical_block_start; 11111 bsi.block_len = len; 11112 } 11113 11114 start += len; 11115 } 11116 11117 if (bsi.block_len) 11118 ret = btrfs_add_swap_extent(sis, &bsi); 11119 11120 out: 11121 if (!IS_ERR_OR_NULL(em)) 11122 free_extent_map(em); 11123 11124 unlock_extent_cached(io_tree, 0, isize - 1, &cached_state); 11125 11126 if (ret) 11127 btrfs_swap_deactivate(file); 11128 11129 btrfs_drew_write_unlock(&root->snapshot_lock); 11130 11131 btrfs_exclop_finish(fs_info); 11132 11133 if (ret) 11134 return ret; 11135 11136 if (device) 11137 sis->bdev = device->bdev; 11138 *span = bsi.highest_ppage - bsi.lowest_ppage + 1; 11139 sis->max = bsi.nr_pages; 11140 sis->pages = bsi.nr_pages - 1; 11141 sis->highest_bit = bsi.nr_pages - 1; 11142 return bsi.nr_extents; 11143 } 11144 #else 11145 static void btrfs_swap_deactivate(struct file *file) 11146 { 11147 } 11148 --- 0-DAY CI Kernel Test Service, Intel Corporation https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org