tree: https://git.kernel.org/pub/scm/linux/kernel/git/arnd/playground.git randconfig-5.16-next head: 3d47ac9fbe4f4f2a5e5dac13912612003c155e6a commit: ef8d4c368e89cc49296569a9e337a50e0cd9e038 [18/158] [SUBMITTED 20210927] [RFC] ntfs: disable for 64KB because of stack overflow risk config: hexagon-randconfig-r041-20211015 (attached as .config) compiler: clang version 14.0.0 (https://github.com/llvm/llvm-project 6069a6a5049497a32a50a49661c2f4169078bdba) 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 # https://git.kernel.org/pub/scm/linux/kernel/git/arnd/playground.git/commi... git remote add arnd-playground https://git.kernel.org/pub/scm/linux/kernel/git/arnd/playground.git git fetch --no-tags arnd-playground randconfig-5.16-next git checkout ef8d4c368e89cc49296569a9e337a50e0cd9e038 # save the attached .config to linux build tree mkdir build_dir COMPILER_INSTALL_PATH=$HOME/0day COMPILER=clang make.cross W=1 O=build_dir ARCH=hexagon SHELL=/bin/bash fs/ 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 >>): fs/ntfs/aops.c:378:12: warning: stack frame size (2224) exceeds limit (1024) in 'ntfs_readpage' [-Wframe-larger-than] static int ntfs_readpage(struct file *file, struct page *page) ^ BUILD_BUG_ON(PAGE_SIZE >= 65536); ^ include/linux/build_bug.h:50:2: note: expanded from macro 'BUILD_BUG_ON' BUILD_BUG_ON_MSG(condition, "BUILD_BUG_ON failed: " #condition) ^ include/linux/build_bug.h:39:37: note: expanded from macro 'BUILD_BUG_ON_MSG' #define BUILD_BUG_ON_MSG(cond, msg) compiletime_assert(!(cond), msg) ^ include/linux/compiler_types.h:329:2: note: expanded from macro 'compiletime_assert' _compiletime_assert(condition, msg, __compiletime_assert_, __COUNTER__) ^ include/linux/compiler_types.h:317:2: note: expanded from macro '_compiletime_assert' __compiletime_assert(condition, msg, prefix, suffix) ^ include/linux/compiler_types.h:310:4: note: expanded from macro '__compiletime_assert' prefix ## suffix(); \ ^ <scratch space>:126:1: note: expanded from here __compiletime_assert_276 ^ fs/ntfs/aops.c:899:12: warning: stack frame size (4296) exceeds limit (1024) in 'ntfs_write_mst_block' [-Wframe-larger-than] static int ntfs_write_mst_block(struct page *page, ^ 2 warnings and 1 error generated. vim +/error +918 fs/ntfs/aops.c 874 875 /** 876 * ntfs_write_mst_block - write a @page to the backing store 877 * @page: page cache page to write out 878 * @wbc: writeback control structure 879 * 880 * This function is for writing pages belonging to non-resident, mst protected 881 * attributes to their backing store. The only supported attributes are index 882 * allocation and $MFT/$DATA. Both directory inodes and index inodes are 883 * supported for the index allocation case. 884 * 885 * The page must remain locked for the duration of the write because we apply 886 * the mst fixups, write, and then undo the fixups, so if we were to unlock the 887 * page before undoing the fixups, any other user of the page will see the 888 * page contents as corrupt. 889 * 890 * We clear the page uptodate flag for the duration of the function to ensure 891 * exclusion for the $MFT/$DATA case against someone mapping an mft record we 892 * are about to apply the mst fixups to. 893 * 894 * Return 0 on success and -errno on error. 895 * 896 * Based on ntfs_write_block(), ntfs_mft_writepage(), and 897 * write_mft_record_nolock(). 898 */ 899 static int ntfs_write_mst_block(struct page *page, 900 struct writeback_control *wbc) 901 { 902 sector_t block, dblock, rec_block; 903 struct inode *vi = page->mapping->host; 904 ntfs_inode *ni = NTFS_I(vi); 905 ntfs_volume *vol = ni->vol; 906 u8 *kaddr; 907 unsigned int rec_size = ni->itype.index.block_size; 908 ntfs_inode *locked_nis[PAGE_SIZE / NTFS_BLOCK_SIZE]; 909 struct buffer_head *bh, *head, *tbh, *rec_start_bh; 910 struct buffer_head *bhs[MAX_BUF_PER_PAGE]; 911 runlist_element *rl; 912 int i, nr_locked_nis, nr_recs, nr_bhs, max_bhs, bhs_per_rec, err, err2; 913 unsigned bh_size, rec_size_bits; 914 bool sync, is_mft, page_is_dirty, rec_is_dirty; 915 unsigned char bh_size_bits; 916 917 /* Two arrays of MAX_BUF_PER_PAGE on the stack risks an overrun with 64K pages */ 919 920 if (WARN_ON(rec_size < NTFS_BLOCK_SIZE)) 921 return -EINVAL; 922 923 ntfs_debug("Entering for inode 0x%lx, attribute type 0x%x, page index " 924 "0x%lx.", vi->i_ino, ni->type, page->index); 925 BUG_ON(!NInoNonResident(ni)); 926 BUG_ON(!NInoMstProtected(ni)); 927 is_mft = (S_ISREG(vi->i_mode) && !vi->i_ino); 928 /* 929 * NOTE: ntfs_write_mst_block() would be called for $MFTMirr if a page 930 * in its page cache were to be marked dirty. However this should 931 * never happen with the current driver and considering we do not 932 * handle this case here we do want to BUG(), at least for now. 933 */ 934 BUG_ON(!(is_mft || S_ISDIR(vi->i_mode) || 935 (NInoAttr(ni) && ni->type == AT_INDEX_ALLOCATION))); 936 bh_size = vol->sb->s_blocksize; 937 bh_size_bits = vol->sb->s_blocksize_bits; 938 max_bhs = PAGE_SIZE / bh_size; 939 BUG_ON(!max_bhs); 940 BUG_ON(max_bhs > MAX_BUF_PER_PAGE); 941 942 /* Were we called for sync purposes? */ 943 sync = (wbc->sync_mode == WB_SYNC_ALL); 944 945 /* Make sure we have mapped buffers. */ 946 bh = head = page_buffers(page); 947 BUG_ON(!bh); 948 949 rec_size_bits = ni->itype.index.block_size_bits; 950 BUG_ON(!(PAGE_SIZE >> rec_size_bits)); 951 bhs_per_rec = rec_size >> bh_size_bits; 952 BUG_ON(!bhs_per_rec); 953 954 /* The first block in the page. */ 955 rec_block = block = (sector_t)page->index << 956 (PAGE_SHIFT - bh_size_bits); 957 958 /* The first out of bounds block for the data size. */ 959 dblock = (i_size_read(vi) + bh_size - 1) >> bh_size_bits; 960 961 rl = NULL; 962 err = err2 = nr_bhs = nr_recs = nr_locked_nis = 0; 963 page_is_dirty = rec_is_dirty = false; 964 rec_start_bh = NULL; 965 do { 966 bool is_retry = false; 967 968 if (likely(block < rec_block)) { 969 if (unlikely(block >= dblock)) { 970 clear_buffer_dirty(bh); 971 set_buffer_uptodate(bh); 972 continue; 973 } 974 /* 975 * This block is not the first one in the record. We 976 * ignore the buffer's dirty state because we could 977 * have raced with a parallel mark_ntfs_record_dirty(). 978 */ 979 if (!rec_is_dirty) 980 continue; 981 if (unlikely(err2)) { 982 if (err2 != -ENOMEM) 983 clear_buffer_dirty(bh); 984 continue; 985 } 986 } else /* if (block == rec_block) */ { 987 BUG_ON(block > rec_block); 988 /* This block is the first one in the record. */ 989 rec_block += bhs_per_rec; 990 err2 = 0; 991 if (unlikely(block >= dblock)) { 992 clear_buffer_dirty(bh); 993 continue; 994 } 995 if (!buffer_dirty(bh)) { 996 /* Clean records are not written out. */ 997 rec_is_dirty = false; 998 continue; 999 } 1000 rec_is_dirty = true; 1001 rec_start_bh = bh; 1002 } 1003 /* Need to map the buffer if it is not mapped already. */ 1004 if (unlikely(!buffer_mapped(bh))) { 1005 VCN vcn; 1006 LCN lcn; 1007 unsigned int vcn_ofs; 1008 1009 bh->b_bdev = vol->sb->s_bdev; 1010 /* Obtain the vcn and offset of the current block. */ 1011 vcn = (VCN)block << bh_size_bits; 1012 vcn_ofs = vcn & vol->cluster_size_mask; 1013 vcn >>= vol->cluster_size_bits; 1014 if (!rl) { 1015 lock_retry_remap: 1016 down_read(&ni->runlist.lock); 1017 rl = ni->runlist.rl; 1018 } 1019 if (likely(rl != NULL)) { 1020 /* Seek to element containing target vcn. */ 1021 while (rl->length && rl[1].vcn <= vcn) 1022 rl++; 1023 lcn = ntfs_rl_vcn_to_lcn(rl, vcn); 1024 } else 1025 lcn = LCN_RL_NOT_MAPPED; 1026 /* Successful remap. */ 1027 if (likely(lcn >= 0)) { 1028 /* Setup buffer head to correct block. */ 1029 bh->b_blocknr = ((lcn << 1030 vol->cluster_size_bits) + 1031 vcn_ofs) >> bh_size_bits; 1032 set_buffer_mapped(bh); 1033 } else { 1034 /* 1035 * Remap failed. Retry to map the runlist once 1036 * unless we are working on $MFT which always 1037 * has the whole of its runlist in memory. 1038 */ 1039 if (!is_mft && !is_retry && 1040 lcn == LCN_RL_NOT_MAPPED) { 1041 is_retry = true; 1042 /* 1043 * Attempt to map runlist, dropping 1044 * lock for the duration. 1045 */ 1046 up_read(&ni->runlist.lock); 1047 err2 = ntfs_map_runlist(ni, vcn); 1048 if (likely(!err2)) 1049 goto lock_retry_remap; 1050 if (err2 == -ENOMEM) 1051 page_is_dirty = true; 1052 lcn = err2; 1053 } else { 1054 err2 = -EIO; 1055 if (!rl) 1056 up_read(&ni->runlist.lock); 1057 } 1058 /* Hard error. Abort writing this record. */ 1059 if (!err || err == -ENOMEM) 1060 err = err2; 1061 bh->b_blocknr = -1; 1062 ntfs_error(vol->sb, "Cannot write ntfs record " 1063 "0x%llx (inode 0x%lx, " 1064 "attribute type 0x%x) because " 1065 "its location on disk could " 1066 "not be determined (error " 1067 "code %lli).", 1068 (long long)block << 1069 bh_size_bits >> 1070 vol->mft_record_size_bits, 1071 ni->mft_no, ni->type, 1072 (long long)lcn); 1073 /* 1074 * If this is not the first buffer, remove the 1075 * buffers in this record from the list of 1076 * buffers to write and clear their dirty bit 1077 * if not error -ENOMEM. 1078 */ 1079 if (rec_start_bh != bh) { 1080 while (bhs[--nr_bhs] != rec_start_bh) 1081 ; 1082 if (err2 != -ENOMEM) { 1083 do { 1084 clear_buffer_dirty( 1085 rec_start_bh); 1086 } while ((rec_start_bh = 1087 rec_start_bh-> 1088 b_this_page) != 1089 bh); 1090 } 1091 } 1092 continue; 1093 } 1094 } 1095 BUG_ON(!buffer_uptodate(bh)); 1096 BUG_ON(nr_bhs >= max_bhs); 1097 bhs[nr_bhs++] = bh; 1098 } while (block++, (bh = bh->b_this_page) != head); 1099 if (unlikely(rl)) 1100 up_read(&ni->runlist.lock); 1101 /* If there were no dirty buffers, we are done. */ 1102 if (!nr_bhs) 1103 goto done; 1104 /* Map the page so we can access its contents. */ 1105 kaddr = kmap(page); 1106 /* Clear the page uptodate flag whilst the mst fixups are applied. */ 1107 BUG_ON(!PageUptodate(page)); 1108 ClearPageUptodate(page); 1109 for (i = 0; i < nr_bhs; i++) { 1110 unsigned int ofs; 1111 1112 /* Skip buffers which are not at the beginning of records. */ 1113 if (i % bhs_per_rec) 1114 continue; 1115 tbh = bhs[i]; 1116 ofs = bh_offset(tbh); 1117 if (is_mft) { 1118 ntfs_inode *tni; 1119 unsigned long mft_no; 1120 1121 /* Get the mft record number. */ 1122 mft_no = (((s64)page->index << PAGE_SHIFT) + ofs) 1123 >> rec_size_bits; 1124 /* Check whether to write this mft record. */ 1125 tni = NULL; 1126 if (!ntfs_may_write_mft_record(vol, mft_no, 1127 (MFT_RECORD*)(kaddr + ofs), &tni)) { 1128 /* 1129 * The record should not be written. This 1130 * means we need to redirty the page before 1131 * returning. 1132 */ 1133 page_is_dirty = true; 1134 /* 1135 * Remove the buffers in this mft record from 1136 * the list of buffers to write. 1137 */ 1138 do { 1139 bhs[i] = NULL; 1140 } while (++i % bhs_per_rec); 1141 continue; 1142 } 1143 /* 1144 * The record should be written. If a locked ntfs 1145 * inode was returned, add it to the array of locked 1146 * ntfs inodes. 1147 */ 1148 if (tni) 1149 locked_nis[nr_locked_nis++] = tni; 1150 } 1151 /* Apply the mst protection fixups. */ 1152 err2 = pre_write_mst_fixup((NTFS_RECORD*)(kaddr + ofs), 1153 rec_size); 1154 if (unlikely(err2)) { 1155 if (!err || err == -ENOMEM) 1156 err = -EIO; 1157 ntfs_error(vol->sb, "Failed to apply mst fixups " 1158 "(inode 0x%lx, attribute type 0x%x, " 1159 "page index 0x%lx, page offset 0x%x)!" 1160 " Unmount and run chkdsk.", vi->i_ino, 1161 ni->type, page->index, ofs); 1162 /* 1163 * Mark all the buffers in this record clean as we do 1164 * not want to write corrupt data to disk. 1165 */ 1166 do { 1167 clear_buffer_dirty(bhs[i]); 1168 bhs[i] = NULL; 1169 } while (++i % bhs_per_rec); 1170 continue; 1171 } 1172 nr_recs++; 1173 } 1174 /* If no records are to be written out, we are done. */ 1175 if (!nr_recs) 1176 goto unm_done; 1177 flush_dcache_page(page); 1178 /* Lock buffers and start synchronous write i/o on them. */ 1179 for (i = 0; i < nr_bhs; i++) { 1180 tbh = bhs[i]; 1181 if (!tbh) 1182 continue; 1183 if (!trylock_buffer(tbh)) 1184 BUG(); 1185 /* The buffer dirty state is now irrelevant, just clean it. */ 1186 clear_buffer_dirty(tbh); 1187 BUG_ON(!buffer_uptodate(tbh)); 1188 BUG_ON(!buffer_mapped(tbh)); 1189 get_bh(tbh); 1190 tbh->b_end_io = end_buffer_write_sync; 1191 submit_bh(REQ_OP_WRITE, 0, tbh); 1192 } 1193 /* Synchronize the mft mirror now if not @sync. */ 1194 if (is_mft && !sync) 1195 goto do_mirror; 1196 do_wait: 1197 /* Wait on i/o completion of buffers. */ 1198 for (i = 0; i < nr_bhs; i++) { 1199 tbh = bhs[i]; 1200 if (!tbh) 1201 continue; 1202 wait_on_buffer(tbh); 1203 if (unlikely(!buffer_uptodate(tbh))) { 1204 ntfs_error(vol->sb, "I/O error while writing ntfs " 1205 "record buffer (inode 0x%lx, " 1206 "attribute type 0x%x, page index " 1207 "0x%lx, page offset 0x%lx)! Unmount " 1208 "and run chkdsk.", vi->i_ino, ni->type, 1209 page->index, bh_offset(tbh)); 1210 if (!err || err == -ENOMEM) 1211 err = -EIO; 1212 /* 1213 * Set the buffer uptodate so the page and buffer 1214 * states do not become out of sync. 1215 */ 1216 set_buffer_uptodate(tbh); 1217 } 1218 } 1219 /* If @sync, now synchronize the mft mirror. */ 1220 if (is_mft && sync) { 1221 do_mirror: 1222 for (i = 0; i < nr_bhs; i++) { 1223 unsigned long mft_no; 1224 unsigned int ofs; 1225 1226 /* 1227 * Skip buffers which are not at the beginning of 1228 * records. 1229 */ 1230 if (i % bhs_per_rec) 1231 continue; 1232 tbh = bhs[i]; 1233 /* Skip removed buffers (and hence records). */ 1234 if (!tbh) 1235 continue; 1236 ofs = bh_offset(tbh); 1237 /* Get the mft record number. */ 1238 mft_no = (((s64)page->index << PAGE_SHIFT) + ofs) 1239 >> rec_size_bits; 1240 if (mft_no < vol->mftmirr_size) 1241 ntfs_sync_mft_mirror(vol, mft_no, 1242 (MFT_RECORD*)(kaddr + ofs), 1243 sync); 1244 } 1245 if (!sync) 1246 goto do_wait; 1247 } 1248 /* Remove the mst protection fixups again. */ 1249 for (i = 0; i < nr_bhs; i++) { 1250 if (!(i % bhs_per_rec)) { 1251 tbh = bhs[i]; 1252 if (!tbh) 1253 continue; 1254 post_write_mst_fixup((NTFS_RECORD*)(kaddr + 1255 bh_offset(tbh))); 1256 } 1257 } 1258 flush_dcache_page(page); 1259 unm_done: 1260 /* Unlock any locked inodes. */ 1261 while (nr_locked_nis-- > 0) { 1262 ntfs_inode *tni, *base_tni; 1263 1264 tni = locked_nis[nr_locked_nis]; 1265 /* Get the base inode. */ 1266 mutex_lock(&tni->extent_lock); 1267 if (tni->nr_extents >= 0) 1268 base_tni = tni; 1269 else { 1270 base_tni = tni->ext.base_ntfs_ino; 1271 BUG_ON(!base_tni); 1272 } 1273 mutex_unlock(&tni->extent_lock); 1274 ntfs_debug("Unlocking %s inode 0x%lx.", 1275 tni == base_tni ? "base" : "extent", 1276 tni->mft_no); 1277 mutex_unlock(&tni->mrec_lock); 1278 atomic_dec(&tni->count); 1279 iput(VFS_I(base_tni)); 1280 } 1281 SetPageUptodate(page); 1282 kunmap(page); 1283 done: 1284 if (unlikely(err && err != -ENOMEM)) { 1285 /* 1286 * Set page error if there is only one ntfs record in the page. 1287 * Otherwise we would loose per-record granularity. 1288 */ 1289 if (ni->itype.index.block_size == PAGE_SIZE) 1290 SetPageError(page); 1291 NVolSetErrors(vol); 1292 } 1293 if (page_is_dirty) { 1294 ntfs_debug("Page still contains one or more dirty ntfs " 1295 "records. Redirtying the page starting at " 1296 "record 0x%lx.", page->index << 1297 (PAGE_SHIFT - rec_size_bits)); 1298 redirty_page_for_writepage(wbc, page); 1299 unlock_page(page); 1300 } else { 1301 /* 1302 * Keep the VM happy. This must be done otherwise the 1303 * radix-tree tag PAGECACHE_TAG_DIRTY remains set even though 1304 * the page is clean. 1305 */ 1306 BUG_ON(PageWriteback(page)); 1307 set_page_writeback(page); 1308 unlock_page(page); 1309 end_page_writeback(page); 1310 } 1311 if (likely(!err)) 1312 ntfs_debug("Done."); 1313 return err; 1314 } 1315 --- 0-DAY CI Kernel Test Service, Intel Corporation https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org