Whamcloud - gitweb
LU-9410 ldiskfs: no check mb bitmap if flex_bg enabled
[fs/lustre-release.git] / ldiskfs / kernel_patches / patches / sles12sp2 / ext4-mballoc-extra-checks.patch
1 Index: linux-3.10.0-123.el7.x86_64/fs/ext4/ext4.h
2 ===================================================================
3 --- linux-3.10.0-123.el7.x86_64.orig/fs/ext4/ext4.h
4 +++ linux-3.10.0-123.el7.x86_64/fs/ext4/ext4.h
5 @@ -2391,6 +2391,7 @@ struct ext4_group_info {
6         ext4_grpblk_t   bb_fragments;   /* nr of freespace fragments */
7         ext4_grpblk_t   bb_largest_free_order;/* order of largest frag in BG */
8         struct          list_head bb_prealloc_list;
9 +       unsigned long   bb_prealloc_nr;
10  #ifdef DOUBLE_CHECK
11         void            *bb_bitmap;
12  #endif
13 Index: linux-3.10.0-123.el7.x86_64/fs/ext4/mballoc.c
14 ===================================================================
15 --- linux-3.10.0-123.el7.x86_64.orig/fs/ext4/mballoc.c
16 +++ linux-3.10.0-123.el7.x86_64/fs/ext4/mballoc.c
17 @@ -362,7 +362,7 @@ static const char *ext4_groupinfo_slab_n
18         "ext4_groupinfo_64k", "ext4_groupinfo_128k"
19  };
20  
21 -static void ext4_mb_generate_from_pa(struct super_block *sb, void *bitmap,
22 +static int ext4_mb_generate_from_pa(struct super_block *sb, void *bitmap,
23                                         ext4_group_t group);
24  static void ext4_mb_generate_from_freelist(struct super_block *sb, void *bitmap,
25                                                 ext4_group_t group);
26 @@ -718,7 +718,7 @@ mb_set_largest_free_order(struct super_b
27  }
28  
29  static noinline_for_stack
30 -void ext4_mb_generate_buddy(struct super_block *sb,
31 +int ext4_mb_generate_buddy(struct super_block *sb,
32                                 void *buddy, void *bitmap, ext4_group_t group)
33  {
34         struct ext4_group_info *grp = ext4_get_group_info(sb, group);
35 @@ -750,19 +750,13 @@ void ext4_mb_generate_buddy(struct super
36         grp->bb_fragments = fragments;
37  
38         if (free != grp->bb_free) {
39 -               ext4_grp_locked_error(sb, group, 0, 0,
40 -                                     "block bitmap and bg descriptor "
41 -                                     "inconsistent: %u vs %u free clusters",
42 -                                     free, grp->bb_free);
43 -               /*
44 -                * If we intend to continue, we consider group descriptor
45 -                * corrupt and update bb_free using bitmap value
46 -                */
47 -               grp->bb_free = free;
48 -               if (!EXT4_MB_GRP_BBITMAP_CORRUPT(grp))
49 -                       percpu_counter_sub(&sbi->s_freeclusters_counter,
50 -                                          grp->bb_free);
51 -               set_bit(EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT, &grp->bb_state);
52 +               struct ext4_group_desc *gdp;
53 +               gdp = ext4_get_group_desc(sb, group, NULL);
54 +               ext4_error(sb, "group %lu: %u blocks in bitmap, %u in bb, "
55 +                       "%u in gd, %lu pa's\n", (long unsigned int)group,
56 +                       free, grp->bb_free, ext4_free_group_clusters(sb, gdp),
57 +                       grp->bb_prealloc_nr);
58 +               return -EIO;
59         }
60         mb_set_largest_free_order(sb, grp);
61  
62 @@ -768,6 +767,8 @@ void ext4_mb_generate_buddy(struct super
63         EXT4_SB(sb)->s_mb_buddies_generated++;
64         EXT4_SB(sb)->s_mb_generation_time += period;
65         spin_unlock(&EXT4_SB(sb)->s_bal_lock);
66 +
67 +       return 0;
68  }
69  
70  static void mb_regenerate_buddy(struct ext4_buddy *e4b)
71 @@ -883,7 +884,7 @@ static int ext4_mb_init_cache(struct pag
72         }
73  
74         first_block = page->index * blocks_per_page;
75 -       for (i = 0; i < blocks_per_page; i++) {
76 +       for (i = 0; i < blocks_per_page && err == 0; i++) {
77                 group = (first_block + i) >> 1;
78                 if (group >= ngroups)
79                         break;
80 @@ -922,7 +923,7 @@ static int ext4_mb_init_cache(struct pag
81                         ext4_lock_group(sb, group);
82                         /* init the buddy */
83                         memset(data, 0xff, blocksize);
84 -                       ext4_mb_generate_buddy(sb, data, incore, group);
85 +                       err = ext4_mb_generate_buddy(sb, data, incore, group);
86                         ext4_unlock_group(sb, group);
87                         incore = NULL;
88                 } else {
89 @@ -937,7 +938,7 @@ static int ext4_mb_init_cache(struct pag
90                         memcpy(data, bitmap, blocksize);
91  
92                         /* mark all preallocated blks used in in-core bitmap */
93 -                       ext4_mb_generate_from_pa(sb, data, group);
94 +                       err = ext4_mb_generate_from_pa(sb, data, group);
95                         ext4_mb_generate_from_freelist(sb, data, group);
96                         ext4_unlock_group(sb, group);
97  
98 @@ -947,7 +948,8 @@ static int ext4_mb_init_cache(struct pag
99                         incore = data;
100                 }
101         }
102 -       SetPageUptodate(page);
103 +       if (likely(err == 0))
104 +               SetPageUptodate(page);
105  
106  out:
107         if (bh) {
108 @@ -2224,9 +2226,11 @@ static void *ext4_mb_seq_groups_next(str
109  static int ext4_mb_seq_groups_show(struct seq_file *seq, void *v)
110  {
111         struct super_block *sb = seq->private;
112 +       struct ext4_group_desc *gdp;
113         ext4_group_t group = (ext4_group_t) ((unsigned long) v);
114         int i;
115         int err, buddy_loaded = 0;
116 +       int free = 0;
117         struct ext4_buddy e4b;
118         struct ext4_group_info *grinfo;
119         struct sg {
120 @@ -2236,7 +2240,7 @@ static int ext4_mb_seq_groups_show(struc
121  
122         group--;
123         if (group == 0)
124 -               seq_puts(seq, "#group: free  frags first ["
125 +               seq_puts(seq, "#group: bfree gfree frags first pa    ["
126                               " 2^0   2^1   2^2   2^3   2^4   2^5   2^6  "
127                               " 2^7   2^8   2^9   2^10  2^11  2^12  2^13  ]");
128  
129 @@ -2256,13 +2260,19 @@ static int ext4_mb_seq_groups_show(struc
130                 buddy_loaded = 1;
131         }
132  
133 +       gdp = ext4_get_group_desc(sb, group, NULL);
134 +       if (gdp != NULL)
135 +               free = ext4_free_group_clusters(sb, gdp);
136 +
137         memcpy(&sg, ext4_get_group_info(sb, group), i);
138  
139         if (buddy_loaded)
140                 ext4_mb_unload_buddy(&e4b);
141  
142 -       seq_printf(seq, "#%-5u: %-5u %-5u %-5u [", group, sg.info.bb_free,
143 -                       sg.info.bb_fragments, sg.info.bb_first_free);
144 +       seq_printf(seq, "#%-5lu: %-5u %-5u %-5u %-5u %-5lu [",
145 +                       (long unsigned int)group, sg.info.bb_free, free,
146 +                       sg.info.bb_fragments, sg.info.bb_first_free,
147 +                       sg.info.bb_prealloc_nr);
148         for (i = 0; i <= 13; i++)
149                 seq_printf(seq, " %-5u", i <= sb->s_blocksize_bits + 1 ?
150                                 sg.info.bb_counters[i] : 0);
151 @@ -3507,22 +3517,71 @@ static void ext4_mb_generate_from_freeli
152  }
153  
154  /*
155 + * check free blocks in bitmap match free block in group descriptor
156 + * do this before taking preallocated blocks into account to be able
157 + * to detect on-disk corruptions. The group lock should be hold by the
158 + * caller.
159 + */
160 +int ext4_mb_check_ondisk_bitmap(struct super_block *sb, void *bitmap,
161 +                               struct ext4_group_desc *gdp, int group)
162 +{
163 +       unsigned short max = EXT4_CLUSTERS_PER_GROUP(sb);
164 +       unsigned short i, first, free = 0;
165 +       unsigned short free_in_gdp = ext4_free_group_clusters(sb, gdp);
166 +
167 +       if (free_in_gdp == 0 && gdp->bg_flags & cpu_to_le16(EXT4_BG_BLOCK_UNINIT))
168 +               return 0;
169 +
170 +       i = mb_find_next_zero_bit(bitmap, max, 0);
171 +
172 +       while (i < max) {
173 +               first = i;
174 +               i = mb_find_next_bit(bitmap, max, i);
175 +               if (i > max)
176 +                       i = max;
177 +               free += i - first;
178 +               if (i < max)
179 +                       i = mb_find_next_zero_bit(bitmap, max, i);
180 +       }
181 +
182 +       if (free != free_in_gdp) {
183 +               ext4_error(sb, "on-disk bitmap for group %d"
184 +                       "corrupted: %u blocks free in bitmap, %u - in gd\n",
185 +                       group, free, free_in_gdp);
186 +               return -EIO;
187 +       }
188 +       return 0;
189 +}
190 +
191 +/*
192   * the function goes through all preallocation in this group and marks them
193   * used in in-core bitmap. buddy must be generated from this bitmap
194   * Need to be called with ext4 group lock held
195   */
196  static noinline_for_stack
197 -void ext4_mb_generate_from_pa(struct super_block *sb, void *bitmap,
198 +int ext4_mb_generate_from_pa(struct super_block *sb, void *bitmap,
199                                         ext4_group_t group)
200  {
201         struct ext4_group_info *grp = ext4_get_group_info(sb, group);
202         struct ext4_prealloc_space *pa;
203 +       struct ext4_group_desc *gdp;
204         struct list_head *cur;
205         ext4_group_t groupnr;
206         ext4_grpblk_t start;
207         int preallocated = 0;
208 +       int skip = 0, count = 0;
209 +       int err;
210         int len;
211  
212 +       gdp = ext4_get_group_desc(sb, group, NULL);
213 +       if (gdp == NULL)
214 +               return -EIO;
215 +
216 +       /* before applying preallocations, check bitmap consistency */
217 +       err = ext4_mb_check_ondisk_bitmap(sb, bitmap, gdp, group);
218 +       if (err)
219 +               return err;
220 +
221         /* all form of preallocation discards first load group,
222          * so the only competing code is preallocation use.
223          * we don't need any locking here
224 @@ -3538,13 +3593,23 @@ void ext4_mb_generate_from_pa(struct sup
225                                              &groupnr, &start);
226                 len = pa->pa_len;
227                 spin_unlock(&pa->pa_lock);
228 -               if (unlikely(len == 0))
229 +               if (unlikely(len == 0)) {
230 +                       skip++;
231                         continue;
232 +               }
233                 BUG_ON(groupnr != group);
234                 ext4_set_bits(bitmap, start, len);
235                 preallocated += len;
236 +               count++;
237 +       }
238 +       if (count + skip != grp->bb_prealloc_nr) {
239 +               ext4_error(sb, "lost preallocations: "
240 +                          "count %d, bb_prealloc_nr %lu, skip %d\n",
241 +                          count, grp->bb_prealloc_nr, skip);
242 +               return -EIO;
243         }
244         mb_debug(1, "prellocated %u for group %u\n", preallocated, group);
245 +       return 0;
246  }
247  
248  static void ext4_mb_pa_callback(struct rcu_head *head)
249 @@ -3603,6 +3668,7 @@ static void ext4_mb_put_pa(struct ext4_a
250          */
251         ext4_lock_group(sb, grp);
252         list_del(&pa->pa_group_list);
253 +       ext4_get_group_info(sb, grp)->bb_prealloc_nr--;
254         ext4_unlock_group(sb, grp);
255  
256         spin_lock(pa->pa_obj_lock);
257 @@ -3697,6 +3763,7 @@ ext4_mb_new_inode_pa(struct ext4_allocat
258  
259         ext4_lock_group(sb, ac->ac_b_ex.fe_group);
260         list_add(&pa->pa_group_list, &grp->bb_prealloc_list);
261 +       grp->bb_prealloc_nr++;
262         ext4_unlock_group(sb, ac->ac_b_ex.fe_group);
263  
264         spin_lock(pa->pa_obj_lock);
265 @@ -3758,6 +3825,7 @@ ext4_mb_new_group_pa(struct ext4_allocat
266  
267         ext4_lock_group(sb, ac->ac_b_ex.fe_group);
268         list_add(&pa->pa_group_list, &grp->bb_prealloc_list);
269 +       grp->bb_prealloc_nr++;
270         ext4_unlock_group(sb, ac->ac_b_ex.fe_group);
271  
272         /*
273 @@ -3927,6 +3995,8 @@ repeat:
274  
275                 spin_unlock(&pa->pa_lock);
276  
277 +               BUG_ON(grp->bb_prealloc_nr == 0);
278 +               grp->bb_prealloc_nr--;
279                 list_del(&pa->pa_group_list);
280                 list_add(&pa->u.pa_tmp_list, &list);
281         }
282 @@ -4056,7 +4126,7 @@ repeat:
283                 if (err) {
284                         ext4_error(sb, "Error loading buddy information for %u",
285                                         group);
286 -                       continue;
287 +                       return;
288                 }
289  
290                 bitmap_bh = ext4_read_block_bitmap(sb, group);
291 @@ -4068,6 +4138,8 @@ repeat:
292                 }
293  
294                 ext4_lock_group(sb, group);
295 +               BUG_ON(e4b.bd_info->bb_prealloc_nr == 0);
296 +               e4b.bd_info->bb_prealloc_nr--;
297                 list_del(&pa->pa_group_list);
298                 ext4_mb_release_inode_pa(&e4b, bitmap_bh, pa);
299                 ext4_unlock_group(sb, group);
300 @@ -4328,6 +4400,7 @@ ext4_mb_discard_lg_preallocations(struct
301                 }
302                 ext4_lock_group(sb, group);
303                 list_del(&pa->pa_group_list);
304 +               ext4_get_group_info(sb, group)->bb_prealloc_nr--;
305                 ext4_mb_release_group_pa(&e4b, pa);
306                 ext4_unlock_group(sb, group);
307  
308 Index: linux-3.10.0-123.el7.x86_64/fs/ext4/mballoc.h
309 ===================================================================
310 --- linux-3.10.0-123.el7.x86_64.orig/fs/ext4/mballoc.h
311 +++ linux-3.10.0-123.el7.x86_64/fs/ext4/mballoc.h
312 @@ -82,7 +82,7 @@ extern ushort ext4_mballoc_debug;
313  /*
314   * for which requests use 2^N search using buddies
315   */
316 -#define MB_DEFAULT_ORDER2_REQS         2
317 +#define MB_DEFAULT_ORDER2_REQS         8
318  
319  /*
320   * default group prealloc size 512 blocks