Hi Li, kernel test robot noticed the following build errors: [auto build test ERROR on brauner-vfs/vfs.all] [also build test ERROR on tytso-ext4/dev linus/master v6.12-rc6 next-20241104] [If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in https://git-scm.com/docs/git-format-patch#_base_tree_information] url: https://github.com/intel-lab-lkp/linux/commits/Li-Dongyang/jbd2-use-rhashtable-for-revoke-records-during-replay/20241104-170737 base: https://git.kernel.org/pub/scm/linux/kernel/git/vfs/vfs.git vfs.all patch link: https://lore.kernel.org/r/20241104090550.256635-1-dongyangli%40ddn.com patch subject: [PATCH] jbd2: use rhashtable for revoke records during replay config: i386-buildonly-randconfig-002-20241104 (https://download.01.org/0day-ci/archive/20241104/202411042321.ntLVyS1K-lkp@xxxxxxxxx/config) compiler: gcc-12 (Debian 12.2.0-14) 12.2.0 reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20241104/202411042321.ntLVyS1K-lkp@xxxxxxxxx/reproduce) If you fix the issue in a separate patch/commit (i.e. not just a new version of the same patch/commit), kindly add following tags | Reported-by: kernel test robot <lkp@xxxxxxxxx> | Closes: https://lore.kernel.org/oe-kbuild-all/202411042321.ntLVyS1K-lkp@xxxxxxxxx/ All errors (new ones prefixed by >>): In file included from fs/jbd2/checkpoint.c:19: >> include/linux/jbd2.h:1128:33: error: field 'j_revoke_rhtable' has incomplete type 1128 | struct rhashtable j_revoke_rhtable; | ^~~~~~~~~~~~~~~~ vim +/j_revoke_rhtable +1128 include/linux/jbd2.h 745 746 /** 747 * struct journal_s - The journal_s type is the concrete type associated with 748 * journal_t. 749 */ 750 struct journal_s 751 { 752 /** 753 * @j_flags: General journaling state flags [j_state_lock, 754 * no lock for quick racy checks] 755 */ 756 unsigned long j_flags; 757 758 /** 759 * @j_errno: 760 * 761 * Is there an outstanding uncleared error on the journal (from a prior 762 * abort)? [j_state_lock] 763 */ 764 int j_errno; 765 766 /** 767 * @j_abort_mutex: Lock the whole aborting procedure. 768 */ 769 struct mutex j_abort_mutex; 770 771 /** 772 * @j_sb_buffer: The first part of the superblock buffer. 773 */ 774 struct buffer_head *j_sb_buffer; 775 776 /** 777 * @j_superblock: The second part of the superblock buffer. 778 */ 779 journal_superblock_t *j_superblock; 780 781 /** 782 * @j_state_lock: Protect the various scalars in the journal. 783 */ 784 rwlock_t j_state_lock; 785 786 /** 787 * @j_barrier_count: 788 * 789 * Number of processes waiting to create a barrier lock [j_state_lock, 790 * no lock for quick racy checks] 791 */ 792 int j_barrier_count; 793 794 /** 795 * @j_barrier: The barrier lock itself. 796 */ 797 struct mutex j_barrier; 798 799 /** 800 * @j_running_transaction: 801 * 802 * Transactions: The current running transaction... 803 * [j_state_lock, no lock for quick racy checks] [caller holding 804 * open handle] 805 */ 806 transaction_t *j_running_transaction; 807 808 /** 809 * @j_committing_transaction: 810 * 811 * the transaction we are pushing to disk 812 * [j_state_lock] [caller holding open handle] 813 */ 814 transaction_t *j_committing_transaction; 815 816 /** 817 * @j_checkpoint_transactions: 818 * 819 * ... and a linked circular list of all transactions waiting for 820 * checkpointing. [j_list_lock] 821 */ 822 transaction_t *j_checkpoint_transactions; 823 824 /** 825 * @j_wait_transaction_locked: 826 * 827 * Wait queue for waiting for a locked transaction to start committing, 828 * or for a barrier lock to be released. 829 */ 830 wait_queue_head_t j_wait_transaction_locked; 831 832 /** 833 * @j_wait_done_commit: Wait queue for waiting for commit to complete. 834 */ 835 wait_queue_head_t j_wait_done_commit; 836 837 /** 838 * @j_wait_commit: Wait queue to trigger commit. 839 */ 840 wait_queue_head_t j_wait_commit; 841 842 /** 843 * @j_wait_updates: Wait queue to wait for updates to complete. 844 */ 845 wait_queue_head_t j_wait_updates; 846 847 /** 848 * @j_wait_reserved: 849 * 850 * Wait queue to wait for reserved buffer credits to drop. 851 */ 852 wait_queue_head_t j_wait_reserved; 853 854 /** 855 * @j_fc_wait: 856 * 857 * Wait queue to wait for completion of async fast commits. 858 */ 859 wait_queue_head_t j_fc_wait; 860 861 /** 862 * @j_checkpoint_mutex: 863 * 864 * Semaphore for locking against concurrent checkpoints. 865 */ 866 struct mutex j_checkpoint_mutex; 867 868 /** 869 * @j_chkpt_bhs: 870 * 871 * List of buffer heads used by the checkpoint routine. This 872 * was moved from jbd2_log_do_checkpoint() to reduce stack 873 * usage. Access to this array is controlled by the 874 * @j_checkpoint_mutex. [j_checkpoint_mutex] 875 */ 876 struct buffer_head *j_chkpt_bhs[JBD2_NR_BATCH]; 877 878 /** 879 * @j_shrinker: 880 * 881 * Journal head shrinker, reclaim buffer's journal head which 882 * has been written back. 883 */ 884 struct shrinker *j_shrinker; 885 886 /** 887 * @j_checkpoint_jh_count: 888 * 889 * Number of journal buffers on the checkpoint list. [j_list_lock] 890 */ 891 struct percpu_counter j_checkpoint_jh_count; 892 893 /** 894 * @j_shrink_transaction: 895 * 896 * Record next transaction will shrink on the checkpoint list. 897 * [j_list_lock] 898 */ 899 transaction_t *j_shrink_transaction; 900 901 /** 902 * @j_head: 903 * 904 * Journal head: identifies the first unused block in the journal. 905 * [j_state_lock] 906 */ 907 unsigned long j_head; 908 909 /** 910 * @j_tail: 911 * 912 * Journal tail: identifies the oldest still-used block in the journal. 913 * [j_state_lock] 914 */ 915 unsigned long j_tail; 916 917 /** 918 * @j_free: 919 * 920 * Journal free: how many free blocks are there in the journal? 921 * [j_state_lock] 922 */ 923 unsigned long j_free; 924 925 /** 926 * @j_first: 927 * 928 * The block number of the first usable block in the journal 929 * [j_state_lock]. 930 */ 931 unsigned long j_first; 932 933 /** 934 * @j_last: 935 * 936 * The block number one beyond the last usable block in the journal 937 * [j_state_lock]. 938 */ 939 unsigned long j_last; 940 941 /** 942 * @j_fc_first: 943 * 944 * The block number of the first fast commit block in the journal 945 * [j_state_lock]. 946 */ 947 unsigned long j_fc_first; 948 949 /** 950 * @j_fc_off: 951 * 952 * Number of fast commit blocks currently allocated. Accessed only 953 * during fast commit. Currently only process can do fast commit, so 954 * this field is not protected by any lock. 955 */ 956 unsigned long j_fc_off; 957 958 /** 959 * @j_fc_last: 960 * 961 * The block number one beyond the last fast commit block in the journal 962 * [j_state_lock]. 963 */ 964 unsigned long j_fc_last; 965 966 /** 967 * @j_dev: Device where we store the journal. 968 */ 969 struct block_device *j_dev; 970 971 /** 972 * @j_blocksize: Block size for the location where we store the journal. 973 */ 974 int j_blocksize; 975 976 /** 977 * @j_blk_offset: 978 * 979 * Starting block offset into the device where we store the journal. 980 */ 981 unsigned long long j_blk_offset; 982 983 /** 984 * @j_devname: Journal device name. 985 */ 986 char j_devname[BDEVNAME_SIZE+24]; 987 988 /** 989 * @j_fs_dev: 990 * 991 * Device which holds the client fs. For internal journal this will be 992 * equal to j_dev. 993 */ 994 struct block_device *j_fs_dev; 995 996 /** 997 * @j_fs_dev_wb_err: 998 * 999 * Records the errseq of the client fs's backing block device. 1000 */ 1001 errseq_t j_fs_dev_wb_err; 1002 1003 /** 1004 * @j_total_len: Total maximum capacity of the journal region on disk. 1005 */ 1006 unsigned int j_total_len; 1007 1008 /** 1009 * @j_reserved_credits: 1010 * 1011 * Number of buffers reserved from the running transaction. 1012 */ 1013 atomic_t j_reserved_credits; 1014 1015 /** 1016 * @j_list_lock: Protects the buffer lists and internal buffer state. 1017 */ 1018 spinlock_t j_list_lock; 1019 1020 /** 1021 * @j_inode: 1022 * 1023 * Optional inode where we store the journal. If present, all 1024 * journal block numbers are mapped into this inode via bmap(). 1025 */ 1026 struct inode *j_inode; 1027 1028 /** 1029 * @j_tail_sequence: 1030 * 1031 * Sequence number of the oldest transaction in the log [j_state_lock] 1032 */ 1033 tid_t j_tail_sequence; 1034 1035 /** 1036 * @j_transaction_sequence: 1037 * 1038 * Sequence number of the next transaction to grant [j_state_lock] 1039 */ 1040 tid_t j_transaction_sequence; 1041 1042 /** 1043 * @j_commit_sequence: 1044 * 1045 * Sequence number of the most recently committed transaction 1046 * [j_state_lock, no lock for quick racy checks] 1047 */ 1048 tid_t j_commit_sequence; 1049 1050 /** 1051 * @j_commit_request: 1052 * 1053 * Sequence number of the most recent transaction wanting commit 1054 * [j_state_lock, no lock for quick racy checks] 1055 */ 1056 tid_t j_commit_request; 1057 1058 /** 1059 * @j_uuid: 1060 * 1061 * Journal uuid: identifies the object (filesystem, LVM volume etc) 1062 * backed by this journal. This will eventually be replaced by an array 1063 * of uuids, allowing us to index multiple devices within a single 1064 * journal and to perform atomic updates across them. 1065 */ 1066 __u8 j_uuid[16]; 1067 1068 /** 1069 * @j_task: Pointer to the current commit thread for this journal. 1070 */ 1071 struct task_struct *j_task; 1072 1073 /** 1074 * @j_max_transaction_buffers: 1075 * 1076 * Maximum number of metadata buffers to allow in a single compound 1077 * commit transaction. 1078 */ 1079 int j_max_transaction_buffers; 1080 1081 /** 1082 * @j_revoke_records_per_block: 1083 * 1084 * Number of revoke records that fit in one descriptor block. 1085 */ 1086 int j_revoke_records_per_block; 1087 1088 /** 1089 * @j_transaction_overhead_buffers: 1090 * 1091 * Number of blocks each transaction needs for its own bookkeeping 1092 */ 1093 int j_transaction_overhead_buffers; 1094 1095 /** 1096 * @j_commit_interval: 1097 * 1098 * What is the maximum transaction lifetime before we begin a commit? 1099 */ 1100 unsigned long j_commit_interval; 1101 1102 /** 1103 * @j_commit_timer: The timer used to wakeup the commit thread. 1104 */ 1105 struct timer_list j_commit_timer; 1106 1107 /** 1108 * @j_revoke_lock: Protect the revoke table. 1109 */ 1110 spinlock_t j_revoke_lock; 1111 1112 /** 1113 * @j_revoke: 1114 * 1115 * The revoke table - maintains the list of revoked blocks in the 1116 * current transaction. 1117 */ 1118 struct jbd2_revoke_table_s *j_revoke; 1119 1120 /** 1121 * @j_revoke_table: Alternate revoke tables for j_revoke. 1122 */ 1123 struct jbd2_revoke_table_s *j_revoke_table[2]; 1124 1125 /** 1126 * @j_revoke_rhtable: rhashtable for revoke records during recovery 1127 */ > 1128 struct rhashtable j_revoke_rhtable; 1129 1130 /** 1131 * @j_wbuf: Array of bhs for jbd2_journal_commit_transaction. 1132 */ 1133 struct buffer_head **j_wbuf; 1134 1135 /** 1136 * @j_fc_wbuf: Array of fast commit bhs for fast commit. Accessed only 1137 * during a fast commit. Currently only process can do fast commit, so 1138 * this field is not protected by any lock. 1139 */ 1140 struct buffer_head **j_fc_wbuf; 1141 1142 /** 1143 * @j_wbufsize: 1144 * 1145 * Size of @j_wbuf array. 1146 */ 1147 int j_wbufsize; 1148 1149 /** 1150 * @j_fc_wbufsize: 1151 * 1152 * Size of @j_fc_wbuf array. 1153 */ 1154 int j_fc_wbufsize; 1155 1156 /** 1157 * @j_last_sync_writer: 1158 * 1159 * The pid of the last person to run a synchronous operation 1160 * through the journal. 1161 */ 1162 pid_t j_last_sync_writer; 1163 1164 /** 1165 * @j_average_commit_time: 1166 * 1167 * The average amount of time in nanoseconds it takes to commit a 1168 * transaction to disk. [j_state_lock] 1169 */ 1170 u64 j_average_commit_time; 1171 1172 /** 1173 * @j_min_batch_time: 1174 * 1175 * Minimum time that we should wait for additional filesystem operations 1176 * to get batched into a synchronous handle in microseconds. 1177 */ 1178 u32 j_min_batch_time; 1179 1180 /** 1181 * @j_max_batch_time: 1182 * 1183 * Maximum time that we should wait for additional filesystem operations 1184 * to get batched into a synchronous handle in microseconds. 1185 */ 1186 u32 j_max_batch_time; 1187 1188 /** 1189 * @j_commit_callback: 1190 * 1191 * This function is called when a transaction is closed. 1192 */ 1193 void (*j_commit_callback)(journal_t *, 1194 transaction_t *); 1195 1196 /** 1197 * @j_submit_inode_data_buffers: 1198 * 1199 * This function is called for all inodes associated with the 1200 * committing transaction marked with JI_WRITE_DATA flag 1201 * before we start to write out the transaction to the journal. 1202 */ 1203 int (*j_submit_inode_data_buffers) 1204 (struct jbd2_inode *); 1205 1206 /** 1207 * @j_finish_inode_data_buffers: 1208 * 1209 * This function is called for all inodes associated with the 1210 * committing transaction marked with JI_WAIT_DATA flag 1211 * after we have written the transaction to the journal 1212 * but before we write out the commit block. 1213 */ 1214 int (*j_finish_inode_data_buffers) 1215 (struct jbd2_inode *); 1216 1217 /* 1218 * Journal statistics 1219 */ 1220 1221 /** 1222 * @j_history_lock: Protect the transactions statistics history. 1223 */ 1224 spinlock_t j_history_lock; 1225 1226 /** 1227 * @j_proc_entry: procfs entry for the jbd statistics directory. 1228 */ 1229 struct proc_dir_entry *j_proc_entry; 1230 1231 /** 1232 * @j_stats: Overall statistics. 1233 */ 1234 struct transaction_stats_s j_stats; 1235 1236 /** 1237 * @j_failed_commit: Failed journal commit ID. 1238 */ 1239 unsigned int j_failed_commit; 1240 1241 /** 1242 * @j_private: 1243 * 1244 * An opaque pointer to fs-private information. ext3 puts its 1245 * superblock pointer here. 1246 */ 1247 void *j_private; 1248 1249 /** 1250 * @j_chksum_driver: 1251 * 1252 * Reference to checksum algorithm driver via cryptoapi. 1253 */ 1254 struct crypto_shash *j_chksum_driver; 1255 1256 /** 1257 * @j_csum_seed: 1258 * 1259 * Precomputed journal UUID checksum for seeding other checksums. 1260 */ 1261 __u32 j_csum_seed; 1262 -- 0-DAY CI Kernel Test Service https://github.com/intel/lkp-tests/wiki
