xref: /openbmc/linux/fs/ext4/ialloc.c (revision 0f4630f3)
1 /*
2  *  linux/fs/ext4/ialloc.c
3  *
4  * Copyright (C) 1992, 1993, 1994, 1995
5  * Remy Card (card@masi.ibp.fr)
6  * Laboratoire MASI - Institut Blaise Pascal
7  * Universite Pierre et Marie Curie (Paris VI)
8  *
9  *  BSD ufs-inspired inode and directory allocation by
10  *  Stephen Tweedie (sct@redhat.com), 1993
11  *  Big-endian to little-endian byte-swapping/bitmaps by
12  *        David S. Miller (davem@caip.rutgers.edu), 1995
13  */
14 
15 #include <linux/time.h>
16 #include <linux/fs.h>
17 #include <linux/stat.h>
18 #include <linux/string.h>
19 #include <linux/quotaops.h>
20 #include <linux/buffer_head.h>
21 #include <linux/random.h>
22 #include <linux/bitops.h>
23 #include <linux/blkdev.h>
24 #include <asm/byteorder.h>
25 
26 #include "ext4.h"
27 #include "ext4_jbd2.h"
28 #include "xattr.h"
29 #include "acl.h"
30 
31 #include <trace/events/ext4.h>
32 
33 /*
34  * ialloc.c contains the inodes allocation and deallocation routines
35  */
36 
37 /*
38  * The free inodes are managed by bitmaps.  A file system contains several
39  * blocks groups.  Each group contains 1 bitmap block for blocks, 1 bitmap
40  * block for inodes, N blocks for the inode table and data blocks.
41  *
42  * The file system contains group descriptors which are located after the
43  * super block.  Each descriptor contains the number of the bitmap block and
44  * the free blocks count in the block.
45  */
46 
47 /*
48  * To avoid calling the atomic setbit hundreds or thousands of times, we only
49  * need to use it within a single byte (to ensure we get endianness right).
50  * We can use memset for the rest of the bitmap as there are no other users.
51  */
52 void ext4_mark_bitmap_end(int start_bit, int end_bit, char *bitmap)
53 {
54 	int i;
55 
56 	if (start_bit >= end_bit)
57 		return;
58 
59 	ext4_debug("mark end bits +%d through +%d used\n", start_bit, end_bit);
60 	for (i = start_bit; i < ((start_bit + 7) & ~7UL); i++)
61 		ext4_set_bit(i, bitmap);
62 	if (i < end_bit)
63 		memset(bitmap + (i >> 3), 0xff, (end_bit - i) >> 3);
64 }
65 
66 /* Initializes an uninitialized inode bitmap */
67 static int ext4_init_inode_bitmap(struct super_block *sb,
68 				       struct buffer_head *bh,
69 				       ext4_group_t block_group,
70 				       struct ext4_group_desc *gdp)
71 {
72 	struct ext4_group_info *grp;
73 	struct ext4_sb_info *sbi = EXT4_SB(sb);
74 	J_ASSERT_BH(bh, buffer_locked(bh));
75 
76 	/* If checksum is bad mark all blocks and inodes use to prevent
77 	 * allocation, essentially implementing a per-group read-only flag. */
78 	if (!ext4_group_desc_csum_verify(sb, block_group, gdp)) {
79 		ext4_error(sb, "Checksum bad for group %u", block_group);
80 		grp = ext4_get_group_info(sb, block_group);
81 		if (!EXT4_MB_GRP_BBITMAP_CORRUPT(grp))
82 			percpu_counter_sub(&sbi->s_freeclusters_counter,
83 					   grp->bb_free);
84 		set_bit(EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT, &grp->bb_state);
85 		if (!EXT4_MB_GRP_IBITMAP_CORRUPT(grp)) {
86 			int count;
87 			count = ext4_free_inodes_count(sb, gdp);
88 			percpu_counter_sub(&sbi->s_freeinodes_counter,
89 					   count);
90 		}
91 		set_bit(EXT4_GROUP_INFO_IBITMAP_CORRUPT_BIT, &grp->bb_state);
92 		return -EFSBADCRC;
93 	}
94 
95 	memset(bh->b_data, 0, (EXT4_INODES_PER_GROUP(sb) + 7) / 8);
96 	ext4_mark_bitmap_end(EXT4_INODES_PER_GROUP(sb), sb->s_blocksize * 8,
97 			bh->b_data);
98 	ext4_inode_bitmap_csum_set(sb, block_group, gdp, bh,
99 				   EXT4_INODES_PER_GROUP(sb) / 8);
100 	ext4_group_desc_csum_set(sb, block_group, gdp);
101 
102 	return 0;
103 }
104 
105 void ext4_end_bitmap_read(struct buffer_head *bh, int uptodate)
106 {
107 	if (uptodate) {
108 		set_buffer_uptodate(bh);
109 		set_bitmap_uptodate(bh);
110 	}
111 	unlock_buffer(bh);
112 	put_bh(bh);
113 }
114 
115 static int ext4_validate_inode_bitmap(struct super_block *sb,
116 				      struct ext4_group_desc *desc,
117 				      ext4_group_t block_group,
118 				      struct buffer_head *bh)
119 {
120 	ext4_fsblk_t	blk;
121 	struct ext4_group_info *grp = ext4_get_group_info(sb, block_group);
122 	struct ext4_sb_info *sbi = EXT4_SB(sb);
123 
124 	if (buffer_verified(bh))
125 		return 0;
126 	if (EXT4_MB_GRP_IBITMAP_CORRUPT(grp))
127 		return -EFSCORRUPTED;
128 
129 	ext4_lock_group(sb, block_group);
130 	blk = ext4_inode_bitmap(sb, desc);
131 	if (!ext4_inode_bitmap_csum_verify(sb, block_group, desc, bh,
132 					   EXT4_INODES_PER_GROUP(sb) / 8)) {
133 		ext4_unlock_group(sb, block_group);
134 		ext4_error(sb, "Corrupt inode bitmap - block_group = %u, "
135 			   "inode_bitmap = %llu", block_group, blk);
136 		grp = ext4_get_group_info(sb, block_group);
137 		if (!EXT4_MB_GRP_IBITMAP_CORRUPT(grp)) {
138 			int count;
139 			count = ext4_free_inodes_count(sb, desc);
140 			percpu_counter_sub(&sbi->s_freeinodes_counter,
141 					   count);
142 		}
143 		set_bit(EXT4_GROUP_INFO_IBITMAP_CORRUPT_BIT, &grp->bb_state);
144 		return -EFSBADCRC;
145 	}
146 	set_buffer_verified(bh);
147 	ext4_unlock_group(sb, block_group);
148 	return 0;
149 }
150 
151 /*
152  * Read the inode allocation bitmap for a given block_group, reading
153  * into the specified slot in the superblock's bitmap cache.
154  *
155  * Return buffer_head of bitmap on success or NULL.
156  */
157 static struct buffer_head *
158 ext4_read_inode_bitmap(struct super_block *sb, ext4_group_t block_group)
159 {
160 	struct ext4_group_desc *desc;
161 	struct buffer_head *bh = NULL;
162 	ext4_fsblk_t bitmap_blk;
163 	int err;
164 
165 	desc = ext4_get_group_desc(sb, block_group, NULL);
166 	if (!desc)
167 		return ERR_PTR(-EFSCORRUPTED);
168 
169 	bitmap_blk = ext4_inode_bitmap(sb, desc);
170 	bh = sb_getblk(sb, bitmap_blk);
171 	if (unlikely(!bh)) {
172 		ext4_error(sb, "Cannot read inode bitmap - "
173 			    "block_group = %u, inode_bitmap = %llu",
174 			    block_group, bitmap_blk);
175 		return ERR_PTR(-EIO);
176 	}
177 	if (bitmap_uptodate(bh))
178 		goto verify;
179 
180 	lock_buffer(bh);
181 	if (bitmap_uptodate(bh)) {
182 		unlock_buffer(bh);
183 		goto verify;
184 	}
185 
186 	ext4_lock_group(sb, block_group);
187 	if (desc->bg_flags & cpu_to_le16(EXT4_BG_INODE_UNINIT)) {
188 		err = ext4_init_inode_bitmap(sb, bh, block_group, desc);
189 		set_bitmap_uptodate(bh);
190 		set_buffer_uptodate(bh);
191 		set_buffer_verified(bh);
192 		ext4_unlock_group(sb, block_group);
193 		unlock_buffer(bh);
194 		if (err)
195 			goto out;
196 		return bh;
197 	}
198 	ext4_unlock_group(sb, block_group);
199 
200 	if (buffer_uptodate(bh)) {
201 		/*
202 		 * if not uninit if bh is uptodate,
203 		 * bitmap is also uptodate
204 		 */
205 		set_bitmap_uptodate(bh);
206 		unlock_buffer(bh);
207 		goto verify;
208 	}
209 	/*
210 	 * submit the buffer_head for reading
211 	 */
212 	trace_ext4_load_inode_bitmap(sb, block_group);
213 	bh->b_end_io = ext4_end_bitmap_read;
214 	get_bh(bh);
215 	submit_bh(READ | REQ_META | REQ_PRIO, bh);
216 	wait_on_buffer(bh);
217 	if (!buffer_uptodate(bh)) {
218 		put_bh(bh);
219 		ext4_error(sb, "Cannot read inode bitmap - "
220 			   "block_group = %u, inode_bitmap = %llu",
221 			   block_group, bitmap_blk);
222 		return ERR_PTR(-EIO);
223 	}
224 
225 verify:
226 	err = ext4_validate_inode_bitmap(sb, desc, block_group, bh);
227 	if (err)
228 		goto out;
229 	return bh;
230 out:
231 	put_bh(bh);
232 	return ERR_PTR(err);
233 }
234 
235 /*
236  * NOTE! When we get the inode, we're the only people
237  * that have access to it, and as such there are no
238  * race conditions we have to worry about. The inode
239  * is not on the hash-lists, and it cannot be reached
240  * through the filesystem because the directory entry
241  * has been deleted earlier.
242  *
243  * HOWEVER: we must make sure that we get no aliases,
244  * which means that we have to call "clear_inode()"
245  * _before_ we mark the inode not in use in the inode
246  * bitmaps. Otherwise a newly created file might use
247  * the same inode number (not actually the same pointer
248  * though), and then we'd have two inodes sharing the
249  * same inode number and space on the harddisk.
250  */
251 void ext4_free_inode(handle_t *handle, struct inode *inode)
252 {
253 	struct super_block *sb = inode->i_sb;
254 	int is_directory;
255 	unsigned long ino;
256 	struct buffer_head *bitmap_bh = NULL;
257 	struct buffer_head *bh2;
258 	ext4_group_t block_group;
259 	unsigned long bit;
260 	struct ext4_group_desc *gdp;
261 	struct ext4_super_block *es;
262 	struct ext4_sb_info *sbi;
263 	int fatal = 0, err, count, cleared;
264 	struct ext4_group_info *grp;
265 
266 	if (!sb) {
267 		printk(KERN_ERR "EXT4-fs: %s:%d: inode on "
268 		       "nonexistent device\n", __func__, __LINE__);
269 		return;
270 	}
271 	if (atomic_read(&inode->i_count) > 1) {
272 		ext4_msg(sb, KERN_ERR, "%s:%d: inode #%lu: count=%d",
273 			 __func__, __LINE__, inode->i_ino,
274 			 atomic_read(&inode->i_count));
275 		return;
276 	}
277 	if (inode->i_nlink) {
278 		ext4_msg(sb, KERN_ERR, "%s:%d: inode #%lu: nlink=%d\n",
279 			 __func__, __LINE__, inode->i_ino, inode->i_nlink);
280 		return;
281 	}
282 	sbi = EXT4_SB(sb);
283 
284 	ino = inode->i_ino;
285 	ext4_debug("freeing inode %lu\n", ino);
286 	trace_ext4_free_inode(inode);
287 
288 	/*
289 	 * Note: we must free any quota before locking the superblock,
290 	 * as writing the quota to disk may need the lock as well.
291 	 */
292 	dquot_initialize(inode);
293 	ext4_xattr_delete_inode(handle, inode);
294 	dquot_free_inode(inode);
295 	dquot_drop(inode);
296 
297 	is_directory = S_ISDIR(inode->i_mode);
298 
299 	/* Do this BEFORE marking the inode not in use or returning an error */
300 	ext4_clear_inode(inode);
301 
302 	es = EXT4_SB(sb)->s_es;
303 	if (ino < EXT4_FIRST_INO(sb) || ino > le32_to_cpu(es->s_inodes_count)) {
304 		ext4_error(sb, "reserved or nonexistent inode %lu", ino);
305 		goto error_return;
306 	}
307 	block_group = (ino - 1) / EXT4_INODES_PER_GROUP(sb);
308 	bit = (ino - 1) % EXT4_INODES_PER_GROUP(sb);
309 	bitmap_bh = ext4_read_inode_bitmap(sb, block_group);
310 	/* Don't bother if the inode bitmap is corrupt. */
311 	grp = ext4_get_group_info(sb, block_group);
312 	if (IS_ERR(bitmap_bh)) {
313 		fatal = PTR_ERR(bitmap_bh);
314 		bitmap_bh = NULL;
315 		goto error_return;
316 	}
317 	if (unlikely(EXT4_MB_GRP_IBITMAP_CORRUPT(grp))) {
318 		fatal = -EFSCORRUPTED;
319 		goto error_return;
320 	}
321 
322 	BUFFER_TRACE(bitmap_bh, "get_write_access");
323 	fatal = ext4_journal_get_write_access(handle, bitmap_bh);
324 	if (fatal)
325 		goto error_return;
326 
327 	fatal = -ESRCH;
328 	gdp = ext4_get_group_desc(sb, block_group, &bh2);
329 	if (gdp) {
330 		BUFFER_TRACE(bh2, "get_write_access");
331 		fatal = ext4_journal_get_write_access(handle, bh2);
332 	}
333 	ext4_lock_group(sb, block_group);
334 	cleared = ext4_test_and_clear_bit(bit, bitmap_bh->b_data);
335 	if (fatal || !cleared) {
336 		ext4_unlock_group(sb, block_group);
337 		goto out;
338 	}
339 
340 	count = ext4_free_inodes_count(sb, gdp) + 1;
341 	ext4_free_inodes_set(sb, gdp, count);
342 	if (is_directory) {
343 		count = ext4_used_dirs_count(sb, gdp) - 1;
344 		ext4_used_dirs_set(sb, gdp, count);
345 		percpu_counter_dec(&sbi->s_dirs_counter);
346 	}
347 	ext4_inode_bitmap_csum_set(sb, block_group, gdp, bitmap_bh,
348 				   EXT4_INODES_PER_GROUP(sb) / 8);
349 	ext4_group_desc_csum_set(sb, block_group, gdp);
350 	ext4_unlock_group(sb, block_group);
351 
352 	percpu_counter_inc(&sbi->s_freeinodes_counter);
353 	if (sbi->s_log_groups_per_flex) {
354 		ext4_group_t f = ext4_flex_group(sbi, block_group);
355 
356 		atomic_inc(&sbi->s_flex_groups[f].free_inodes);
357 		if (is_directory)
358 			atomic_dec(&sbi->s_flex_groups[f].used_dirs);
359 	}
360 	BUFFER_TRACE(bh2, "call ext4_handle_dirty_metadata");
361 	fatal = ext4_handle_dirty_metadata(handle, NULL, bh2);
362 out:
363 	if (cleared) {
364 		BUFFER_TRACE(bitmap_bh, "call ext4_handle_dirty_metadata");
365 		err = ext4_handle_dirty_metadata(handle, NULL, bitmap_bh);
366 		if (!fatal)
367 			fatal = err;
368 	} else {
369 		ext4_error(sb, "bit already cleared for inode %lu", ino);
370 		if (gdp && !EXT4_MB_GRP_IBITMAP_CORRUPT(grp)) {
371 			int count;
372 			count = ext4_free_inodes_count(sb, gdp);
373 			percpu_counter_sub(&sbi->s_freeinodes_counter,
374 					   count);
375 		}
376 		set_bit(EXT4_GROUP_INFO_IBITMAP_CORRUPT_BIT, &grp->bb_state);
377 	}
378 
379 error_return:
380 	brelse(bitmap_bh);
381 	ext4_std_error(sb, fatal);
382 }
383 
384 struct orlov_stats {
385 	__u64 free_clusters;
386 	__u32 free_inodes;
387 	__u32 used_dirs;
388 };
389 
390 /*
391  * Helper function for Orlov's allocator; returns critical information
392  * for a particular block group or flex_bg.  If flex_size is 1, then g
393  * is a block group number; otherwise it is flex_bg number.
394  */
395 static void get_orlov_stats(struct super_block *sb, ext4_group_t g,
396 			    int flex_size, struct orlov_stats *stats)
397 {
398 	struct ext4_group_desc *desc;
399 	struct flex_groups *flex_group = EXT4_SB(sb)->s_flex_groups;
400 
401 	if (flex_size > 1) {
402 		stats->free_inodes = atomic_read(&flex_group[g].free_inodes);
403 		stats->free_clusters = atomic64_read(&flex_group[g].free_clusters);
404 		stats->used_dirs = atomic_read(&flex_group[g].used_dirs);
405 		return;
406 	}
407 
408 	desc = ext4_get_group_desc(sb, g, NULL);
409 	if (desc) {
410 		stats->free_inodes = ext4_free_inodes_count(sb, desc);
411 		stats->free_clusters = ext4_free_group_clusters(sb, desc);
412 		stats->used_dirs = ext4_used_dirs_count(sb, desc);
413 	} else {
414 		stats->free_inodes = 0;
415 		stats->free_clusters = 0;
416 		stats->used_dirs = 0;
417 	}
418 }
419 
420 /*
421  * Orlov's allocator for directories.
422  *
423  * We always try to spread first-level directories.
424  *
425  * If there are blockgroups with both free inodes and free blocks counts
426  * not worse than average we return one with smallest directory count.
427  * Otherwise we simply return a random group.
428  *
429  * For the rest rules look so:
430  *
431  * It's OK to put directory into a group unless
432  * it has too many directories already (max_dirs) or
433  * it has too few free inodes left (min_inodes) or
434  * it has too few free blocks left (min_blocks) or
435  * Parent's group is preferred, if it doesn't satisfy these
436  * conditions we search cyclically through the rest. If none
437  * of the groups look good we just look for a group with more
438  * free inodes than average (starting at parent's group).
439  */
440 
441 static int find_group_orlov(struct super_block *sb, struct inode *parent,
442 			    ext4_group_t *group, umode_t mode,
443 			    const struct qstr *qstr)
444 {
445 	ext4_group_t parent_group = EXT4_I(parent)->i_block_group;
446 	struct ext4_sb_info *sbi = EXT4_SB(sb);
447 	ext4_group_t real_ngroups = ext4_get_groups_count(sb);
448 	int inodes_per_group = EXT4_INODES_PER_GROUP(sb);
449 	unsigned int freei, avefreei, grp_free;
450 	ext4_fsblk_t freeb, avefreec;
451 	unsigned int ndirs;
452 	int max_dirs, min_inodes;
453 	ext4_grpblk_t min_clusters;
454 	ext4_group_t i, grp, g, ngroups;
455 	struct ext4_group_desc *desc;
456 	struct orlov_stats stats;
457 	int flex_size = ext4_flex_bg_size(sbi);
458 	struct dx_hash_info hinfo;
459 
460 	ngroups = real_ngroups;
461 	if (flex_size > 1) {
462 		ngroups = (real_ngroups + flex_size - 1) >>
463 			sbi->s_log_groups_per_flex;
464 		parent_group >>= sbi->s_log_groups_per_flex;
465 	}
466 
467 	freei = percpu_counter_read_positive(&sbi->s_freeinodes_counter);
468 	avefreei = freei / ngroups;
469 	freeb = EXT4_C2B(sbi,
470 		percpu_counter_read_positive(&sbi->s_freeclusters_counter));
471 	avefreec = freeb;
472 	do_div(avefreec, ngroups);
473 	ndirs = percpu_counter_read_positive(&sbi->s_dirs_counter);
474 
475 	if (S_ISDIR(mode) &&
476 	    ((parent == d_inode(sb->s_root)) ||
477 	     (ext4_test_inode_flag(parent, EXT4_INODE_TOPDIR)))) {
478 		int best_ndir = inodes_per_group;
479 		int ret = -1;
480 
481 		if (qstr) {
482 			hinfo.hash_version = DX_HASH_HALF_MD4;
483 			hinfo.seed = sbi->s_hash_seed;
484 			ext4fs_dirhash(qstr->name, qstr->len, &hinfo);
485 			grp = hinfo.hash;
486 		} else
487 			grp = prandom_u32();
488 		parent_group = (unsigned)grp % ngroups;
489 		for (i = 0; i < ngroups; i++) {
490 			g = (parent_group + i) % ngroups;
491 			get_orlov_stats(sb, g, flex_size, &stats);
492 			if (!stats.free_inodes)
493 				continue;
494 			if (stats.used_dirs >= best_ndir)
495 				continue;
496 			if (stats.free_inodes < avefreei)
497 				continue;
498 			if (stats.free_clusters < avefreec)
499 				continue;
500 			grp = g;
501 			ret = 0;
502 			best_ndir = stats.used_dirs;
503 		}
504 		if (ret)
505 			goto fallback;
506 	found_flex_bg:
507 		if (flex_size == 1) {
508 			*group = grp;
509 			return 0;
510 		}
511 
512 		/*
513 		 * We pack inodes at the beginning of the flexgroup's
514 		 * inode tables.  Block allocation decisions will do
515 		 * something similar, although regular files will
516 		 * start at 2nd block group of the flexgroup.  See
517 		 * ext4_ext_find_goal() and ext4_find_near().
518 		 */
519 		grp *= flex_size;
520 		for (i = 0; i < flex_size; i++) {
521 			if (grp+i >= real_ngroups)
522 				break;
523 			desc = ext4_get_group_desc(sb, grp+i, NULL);
524 			if (desc && ext4_free_inodes_count(sb, desc)) {
525 				*group = grp+i;
526 				return 0;
527 			}
528 		}
529 		goto fallback;
530 	}
531 
532 	max_dirs = ndirs / ngroups + inodes_per_group / 16;
533 	min_inodes = avefreei - inodes_per_group*flex_size / 4;
534 	if (min_inodes < 1)
535 		min_inodes = 1;
536 	min_clusters = avefreec - EXT4_CLUSTERS_PER_GROUP(sb)*flex_size / 4;
537 
538 	/*
539 	 * Start looking in the flex group where we last allocated an
540 	 * inode for this parent directory
541 	 */
542 	if (EXT4_I(parent)->i_last_alloc_group != ~0) {
543 		parent_group = EXT4_I(parent)->i_last_alloc_group;
544 		if (flex_size > 1)
545 			parent_group >>= sbi->s_log_groups_per_flex;
546 	}
547 
548 	for (i = 0; i < ngroups; i++) {
549 		grp = (parent_group + i) % ngroups;
550 		get_orlov_stats(sb, grp, flex_size, &stats);
551 		if (stats.used_dirs >= max_dirs)
552 			continue;
553 		if (stats.free_inodes < min_inodes)
554 			continue;
555 		if (stats.free_clusters < min_clusters)
556 			continue;
557 		goto found_flex_bg;
558 	}
559 
560 fallback:
561 	ngroups = real_ngroups;
562 	avefreei = freei / ngroups;
563 fallback_retry:
564 	parent_group = EXT4_I(parent)->i_block_group;
565 	for (i = 0; i < ngroups; i++) {
566 		grp = (parent_group + i) % ngroups;
567 		desc = ext4_get_group_desc(sb, grp, NULL);
568 		if (desc) {
569 			grp_free = ext4_free_inodes_count(sb, desc);
570 			if (grp_free && grp_free >= avefreei) {
571 				*group = grp;
572 				return 0;
573 			}
574 		}
575 	}
576 
577 	if (avefreei) {
578 		/*
579 		 * The free-inodes counter is approximate, and for really small
580 		 * filesystems the above test can fail to find any blockgroups
581 		 */
582 		avefreei = 0;
583 		goto fallback_retry;
584 	}
585 
586 	return -1;
587 }
588 
589 static int find_group_other(struct super_block *sb, struct inode *parent,
590 			    ext4_group_t *group, umode_t mode)
591 {
592 	ext4_group_t parent_group = EXT4_I(parent)->i_block_group;
593 	ext4_group_t i, last, ngroups = ext4_get_groups_count(sb);
594 	struct ext4_group_desc *desc;
595 	int flex_size = ext4_flex_bg_size(EXT4_SB(sb));
596 
597 	/*
598 	 * Try to place the inode is the same flex group as its
599 	 * parent.  If we can't find space, use the Orlov algorithm to
600 	 * find another flex group, and store that information in the
601 	 * parent directory's inode information so that use that flex
602 	 * group for future allocations.
603 	 */
604 	if (flex_size > 1) {
605 		int retry = 0;
606 
607 	try_again:
608 		parent_group &= ~(flex_size-1);
609 		last = parent_group + flex_size;
610 		if (last > ngroups)
611 			last = ngroups;
612 		for  (i = parent_group; i < last; i++) {
613 			desc = ext4_get_group_desc(sb, i, NULL);
614 			if (desc && ext4_free_inodes_count(sb, desc)) {
615 				*group = i;
616 				return 0;
617 			}
618 		}
619 		if (!retry && EXT4_I(parent)->i_last_alloc_group != ~0) {
620 			retry = 1;
621 			parent_group = EXT4_I(parent)->i_last_alloc_group;
622 			goto try_again;
623 		}
624 		/*
625 		 * If this didn't work, use the Orlov search algorithm
626 		 * to find a new flex group; we pass in the mode to
627 		 * avoid the topdir algorithms.
628 		 */
629 		*group = parent_group + flex_size;
630 		if (*group > ngroups)
631 			*group = 0;
632 		return find_group_orlov(sb, parent, group, mode, NULL);
633 	}
634 
635 	/*
636 	 * Try to place the inode in its parent directory
637 	 */
638 	*group = parent_group;
639 	desc = ext4_get_group_desc(sb, *group, NULL);
640 	if (desc && ext4_free_inodes_count(sb, desc) &&
641 	    ext4_free_group_clusters(sb, desc))
642 		return 0;
643 
644 	/*
645 	 * We're going to place this inode in a different blockgroup from its
646 	 * parent.  We want to cause files in a common directory to all land in
647 	 * the same blockgroup.  But we want files which are in a different
648 	 * directory which shares a blockgroup with our parent to land in a
649 	 * different blockgroup.
650 	 *
651 	 * So add our directory's i_ino into the starting point for the hash.
652 	 */
653 	*group = (*group + parent->i_ino) % ngroups;
654 
655 	/*
656 	 * Use a quadratic hash to find a group with a free inode and some free
657 	 * blocks.
658 	 */
659 	for (i = 1; i < ngroups; i <<= 1) {
660 		*group += i;
661 		if (*group >= ngroups)
662 			*group -= ngroups;
663 		desc = ext4_get_group_desc(sb, *group, NULL);
664 		if (desc && ext4_free_inodes_count(sb, desc) &&
665 		    ext4_free_group_clusters(sb, desc))
666 			return 0;
667 	}
668 
669 	/*
670 	 * That failed: try linear search for a free inode, even if that group
671 	 * has no free blocks.
672 	 */
673 	*group = parent_group;
674 	for (i = 0; i < ngroups; i++) {
675 		if (++*group >= ngroups)
676 			*group = 0;
677 		desc = ext4_get_group_desc(sb, *group, NULL);
678 		if (desc && ext4_free_inodes_count(sb, desc))
679 			return 0;
680 	}
681 
682 	return -1;
683 }
684 
685 /*
686  * In no journal mode, if an inode has recently been deleted, we want
687  * to avoid reusing it until we're reasonably sure the inode table
688  * block has been written back to disk.  (Yes, these values are
689  * somewhat arbitrary...)
690  */
691 #define RECENTCY_MIN	5
692 #define RECENTCY_DIRTY	30
693 
694 static int recently_deleted(struct super_block *sb, ext4_group_t group, int ino)
695 {
696 	struct ext4_group_desc	*gdp;
697 	struct ext4_inode	*raw_inode;
698 	struct buffer_head	*bh;
699 	unsigned long		dtime, now;
700 	int	inodes_per_block = EXT4_SB(sb)->s_inodes_per_block;
701 	int	offset, ret = 0, recentcy = RECENTCY_MIN;
702 
703 	gdp = ext4_get_group_desc(sb, group, NULL);
704 	if (unlikely(!gdp))
705 		return 0;
706 
707 	bh = sb_getblk(sb, ext4_inode_table(sb, gdp) +
708 		       (ino / inodes_per_block));
709 	if (unlikely(!bh) || !buffer_uptodate(bh))
710 		/*
711 		 * If the block is not in the buffer cache, then it
712 		 * must have been written out.
713 		 */
714 		goto out;
715 
716 	offset = (ino % inodes_per_block) * EXT4_INODE_SIZE(sb);
717 	raw_inode = (struct ext4_inode *) (bh->b_data + offset);
718 	dtime = le32_to_cpu(raw_inode->i_dtime);
719 	now = get_seconds();
720 	if (buffer_dirty(bh))
721 		recentcy += RECENTCY_DIRTY;
722 
723 	if (dtime && (dtime < now) && (now < dtime + recentcy))
724 		ret = 1;
725 out:
726 	brelse(bh);
727 	return ret;
728 }
729 
730 /*
731  * There are two policies for allocating an inode.  If the new inode is
732  * a directory, then a forward search is made for a block group with both
733  * free space and a low directory-to-inode ratio; if that fails, then of
734  * the groups with above-average free space, that group with the fewest
735  * directories already is chosen.
736  *
737  * For other inodes, search forward from the parent directory's block
738  * group to find a free inode.
739  */
740 struct inode *__ext4_new_inode(handle_t *handle, struct inode *dir,
741 			       umode_t mode, const struct qstr *qstr,
742 			       __u32 goal, uid_t *owner, int handle_type,
743 			       unsigned int line_no, int nblocks)
744 {
745 	struct super_block *sb;
746 	struct buffer_head *inode_bitmap_bh = NULL;
747 	struct buffer_head *group_desc_bh;
748 	ext4_group_t ngroups, group = 0;
749 	unsigned long ino = 0;
750 	struct inode *inode;
751 	struct ext4_group_desc *gdp = NULL;
752 	struct ext4_inode_info *ei;
753 	struct ext4_sb_info *sbi;
754 	int ret2, err;
755 	struct inode *ret;
756 	ext4_group_t i;
757 	ext4_group_t flex_group;
758 	struct ext4_group_info *grp;
759 	int encrypt = 0;
760 
761 	/* Cannot create files in a deleted directory */
762 	if (!dir || !dir->i_nlink)
763 		return ERR_PTR(-EPERM);
764 
765 	if ((ext4_encrypted_inode(dir) ||
766 	     DUMMY_ENCRYPTION_ENABLED(EXT4_SB(dir->i_sb))) &&
767 	    (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode))) {
768 		err = ext4_get_encryption_info(dir);
769 		if (err)
770 			return ERR_PTR(err);
771 		if (ext4_encryption_info(dir) == NULL)
772 			return ERR_PTR(-EPERM);
773 		if (!handle)
774 			nblocks += EXT4_DATA_TRANS_BLOCKS(dir->i_sb);
775 		encrypt = 1;
776 	}
777 
778 	sb = dir->i_sb;
779 	ngroups = ext4_get_groups_count(sb);
780 	trace_ext4_request_inode(dir, mode);
781 	inode = new_inode(sb);
782 	if (!inode)
783 		return ERR_PTR(-ENOMEM);
784 	ei = EXT4_I(inode);
785 	sbi = EXT4_SB(sb);
786 
787 	/*
788 	 * Initalize owners and quota early so that we don't have to account
789 	 * for quota initialization worst case in standard inode creating
790 	 * transaction
791 	 */
792 	if (owner) {
793 		inode->i_mode = mode;
794 		i_uid_write(inode, owner[0]);
795 		i_gid_write(inode, owner[1]);
796 	} else if (test_opt(sb, GRPID)) {
797 		inode->i_mode = mode;
798 		inode->i_uid = current_fsuid();
799 		inode->i_gid = dir->i_gid;
800 	} else
801 		inode_init_owner(inode, dir, mode);
802 	err = dquot_initialize(inode);
803 	if (err)
804 		goto out;
805 
806 	if (!goal)
807 		goal = sbi->s_inode_goal;
808 
809 	if (goal && goal <= le32_to_cpu(sbi->s_es->s_inodes_count)) {
810 		group = (goal - 1) / EXT4_INODES_PER_GROUP(sb);
811 		ino = (goal - 1) % EXT4_INODES_PER_GROUP(sb);
812 		ret2 = 0;
813 		goto got_group;
814 	}
815 
816 	if (S_ISDIR(mode))
817 		ret2 = find_group_orlov(sb, dir, &group, mode, qstr);
818 	else
819 		ret2 = find_group_other(sb, dir, &group, mode);
820 
821 got_group:
822 	EXT4_I(dir)->i_last_alloc_group = group;
823 	err = -ENOSPC;
824 	if (ret2 == -1)
825 		goto out;
826 
827 	/*
828 	 * Normally we will only go through one pass of this loop,
829 	 * unless we get unlucky and it turns out the group we selected
830 	 * had its last inode grabbed by someone else.
831 	 */
832 	for (i = 0; i < ngroups; i++, ino = 0) {
833 		err = -EIO;
834 
835 		gdp = ext4_get_group_desc(sb, group, &group_desc_bh);
836 		if (!gdp)
837 			goto out;
838 
839 		/*
840 		 * Check free inodes count before loading bitmap.
841 		 */
842 		if (ext4_free_inodes_count(sb, gdp) == 0) {
843 			if (++group == ngroups)
844 				group = 0;
845 			continue;
846 		}
847 
848 		grp = ext4_get_group_info(sb, group);
849 		/* Skip groups with already-known suspicious inode tables */
850 		if (EXT4_MB_GRP_IBITMAP_CORRUPT(grp)) {
851 			if (++group == ngroups)
852 				group = 0;
853 			continue;
854 		}
855 
856 		brelse(inode_bitmap_bh);
857 		inode_bitmap_bh = ext4_read_inode_bitmap(sb, group);
858 		/* Skip groups with suspicious inode tables */
859 		if (EXT4_MB_GRP_IBITMAP_CORRUPT(grp) ||
860 		    IS_ERR(inode_bitmap_bh)) {
861 			inode_bitmap_bh = NULL;
862 			if (++group == ngroups)
863 				group = 0;
864 			continue;
865 		}
866 
867 repeat_in_this_group:
868 		ino = ext4_find_next_zero_bit((unsigned long *)
869 					      inode_bitmap_bh->b_data,
870 					      EXT4_INODES_PER_GROUP(sb), ino);
871 		if (ino >= EXT4_INODES_PER_GROUP(sb))
872 			goto next_group;
873 		if (group == 0 && (ino+1) < EXT4_FIRST_INO(sb)) {
874 			ext4_error(sb, "reserved inode found cleared - "
875 				   "inode=%lu", ino + 1);
876 			continue;
877 		}
878 		if ((EXT4_SB(sb)->s_journal == NULL) &&
879 		    recently_deleted(sb, group, ino)) {
880 			ino++;
881 			goto next_inode;
882 		}
883 		if (!handle) {
884 			BUG_ON(nblocks <= 0);
885 			handle = __ext4_journal_start_sb(dir->i_sb, line_no,
886 							 handle_type, nblocks,
887 							 0);
888 			if (IS_ERR(handle)) {
889 				err = PTR_ERR(handle);
890 				ext4_std_error(sb, err);
891 				goto out;
892 			}
893 		}
894 		BUFFER_TRACE(inode_bitmap_bh, "get_write_access");
895 		err = ext4_journal_get_write_access(handle, inode_bitmap_bh);
896 		if (err) {
897 			ext4_std_error(sb, err);
898 			goto out;
899 		}
900 		ext4_lock_group(sb, group);
901 		ret2 = ext4_test_and_set_bit(ino, inode_bitmap_bh->b_data);
902 		ext4_unlock_group(sb, group);
903 		ino++;		/* the inode bitmap is zero-based */
904 		if (!ret2)
905 			goto got; /* we grabbed the inode! */
906 next_inode:
907 		if (ino < EXT4_INODES_PER_GROUP(sb))
908 			goto repeat_in_this_group;
909 next_group:
910 		if (++group == ngroups)
911 			group = 0;
912 	}
913 	err = -ENOSPC;
914 	goto out;
915 
916 got:
917 	BUFFER_TRACE(inode_bitmap_bh, "call ext4_handle_dirty_metadata");
918 	err = ext4_handle_dirty_metadata(handle, NULL, inode_bitmap_bh);
919 	if (err) {
920 		ext4_std_error(sb, err);
921 		goto out;
922 	}
923 
924 	BUFFER_TRACE(group_desc_bh, "get_write_access");
925 	err = ext4_journal_get_write_access(handle, group_desc_bh);
926 	if (err) {
927 		ext4_std_error(sb, err);
928 		goto out;
929 	}
930 
931 	/* We may have to initialize the block bitmap if it isn't already */
932 	if (ext4_has_group_desc_csum(sb) &&
933 	    gdp->bg_flags & cpu_to_le16(EXT4_BG_BLOCK_UNINIT)) {
934 		struct buffer_head *block_bitmap_bh;
935 
936 		block_bitmap_bh = ext4_read_block_bitmap(sb, group);
937 		if (IS_ERR(block_bitmap_bh)) {
938 			err = PTR_ERR(block_bitmap_bh);
939 			goto out;
940 		}
941 		BUFFER_TRACE(block_bitmap_bh, "get block bitmap access");
942 		err = ext4_journal_get_write_access(handle, block_bitmap_bh);
943 		if (err) {
944 			brelse(block_bitmap_bh);
945 			ext4_std_error(sb, err);
946 			goto out;
947 		}
948 
949 		BUFFER_TRACE(block_bitmap_bh, "dirty block bitmap");
950 		err = ext4_handle_dirty_metadata(handle, NULL, block_bitmap_bh);
951 
952 		/* recheck and clear flag under lock if we still need to */
953 		ext4_lock_group(sb, group);
954 		if (gdp->bg_flags & cpu_to_le16(EXT4_BG_BLOCK_UNINIT)) {
955 			gdp->bg_flags &= cpu_to_le16(~EXT4_BG_BLOCK_UNINIT);
956 			ext4_free_group_clusters_set(sb, gdp,
957 				ext4_free_clusters_after_init(sb, group, gdp));
958 			ext4_block_bitmap_csum_set(sb, group, gdp,
959 						   block_bitmap_bh);
960 			ext4_group_desc_csum_set(sb, group, gdp);
961 		}
962 		ext4_unlock_group(sb, group);
963 		brelse(block_bitmap_bh);
964 
965 		if (err) {
966 			ext4_std_error(sb, err);
967 			goto out;
968 		}
969 	}
970 
971 	/* Update the relevant bg descriptor fields */
972 	if (ext4_has_group_desc_csum(sb)) {
973 		int free;
974 		struct ext4_group_info *grp = ext4_get_group_info(sb, group);
975 
976 		down_read(&grp->alloc_sem); /* protect vs itable lazyinit */
977 		ext4_lock_group(sb, group); /* while we modify the bg desc */
978 		free = EXT4_INODES_PER_GROUP(sb) -
979 			ext4_itable_unused_count(sb, gdp);
980 		if (gdp->bg_flags & cpu_to_le16(EXT4_BG_INODE_UNINIT)) {
981 			gdp->bg_flags &= cpu_to_le16(~EXT4_BG_INODE_UNINIT);
982 			free = 0;
983 		}
984 		/*
985 		 * Check the relative inode number against the last used
986 		 * relative inode number in this group. if it is greater
987 		 * we need to update the bg_itable_unused count
988 		 */
989 		if (ino > free)
990 			ext4_itable_unused_set(sb, gdp,
991 					(EXT4_INODES_PER_GROUP(sb) - ino));
992 		up_read(&grp->alloc_sem);
993 	} else {
994 		ext4_lock_group(sb, group);
995 	}
996 
997 	ext4_free_inodes_set(sb, gdp, ext4_free_inodes_count(sb, gdp) - 1);
998 	if (S_ISDIR(mode)) {
999 		ext4_used_dirs_set(sb, gdp, ext4_used_dirs_count(sb, gdp) + 1);
1000 		if (sbi->s_log_groups_per_flex) {
1001 			ext4_group_t f = ext4_flex_group(sbi, group);
1002 
1003 			atomic_inc(&sbi->s_flex_groups[f].used_dirs);
1004 		}
1005 	}
1006 	if (ext4_has_group_desc_csum(sb)) {
1007 		ext4_inode_bitmap_csum_set(sb, group, gdp, inode_bitmap_bh,
1008 					   EXT4_INODES_PER_GROUP(sb) / 8);
1009 		ext4_group_desc_csum_set(sb, group, gdp);
1010 	}
1011 	ext4_unlock_group(sb, group);
1012 
1013 	BUFFER_TRACE(group_desc_bh, "call ext4_handle_dirty_metadata");
1014 	err = ext4_handle_dirty_metadata(handle, NULL, group_desc_bh);
1015 	if (err) {
1016 		ext4_std_error(sb, err);
1017 		goto out;
1018 	}
1019 
1020 	percpu_counter_dec(&sbi->s_freeinodes_counter);
1021 	if (S_ISDIR(mode))
1022 		percpu_counter_inc(&sbi->s_dirs_counter);
1023 
1024 	if (sbi->s_log_groups_per_flex) {
1025 		flex_group = ext4_flex_group(sbi, group);
1026 		atomic_dec(&sbi->s_flex_groups[flex_group].free_inodes);
1027 	}
1028 
1029 	inode->i_ino = ino + group * EXT4_INODES_PER_GROUP(sb);
1030 	/* This is the optimal IO size (for stat), not the fs block size */
1031 	inode->i_blocks = 0;
1032 	inode->i_mtime = inode->i_atime = inode->i_ctime = ei->i_crtime =
1033 						       ext4_current_time(inode);
1034 
1035 	memset(ei->i_data, 0, sizeof(ei->i_data));
1036 	ei->i_dir_start_lookup = 0;
1037 	ei->i_disksize = 0;
1038 
1039 	/* Don't inherit extent flag from directory, amongst others. */
1040 	ei->i_flags =
1041 		ext4_mask_flags(mode, EXT4_I(dir)->i_flags & EXT4_FL_INHERITED);
1042 	ei->i_file_acl = 0;
1043 	ei->i_dtime = 0;
1044 	ei->i_block_group = group;
1045 	ei->i_last_alloc_group = ~0;
1046 
1047 	ext4_set_inode_flags(inode);
1048 	if (IS_DIRSYNC(inode))
1049 		ext4_handle_sync(handle);
1050 	if (insert_inode_locked(inode) < 0) {
1051 		/*
1052 		 * Likely a bitmap corruption causing inode to be allocated
1053 		 * twice.
1054 		 */
1055 		err = -EIO;
1056 		ext4_error(sb, "failed to insert inode %lu: doubly allocated?",
1057 			   inode->i_ino);
1058 		goto out;
1059 	}
1060 	spin_lock(&sbi->s_next_gen_lock);
1061 	inode->i_generation = sbi->s_next_generation++;
1062 	spin_unlock(&sbi->s_next_gen_lock);
1063 
1064 	/* Precompute checksum seed for inode metadata */
1065 	if (ext4_has_metadata_csum(sb)) {
1066 		__u32 csum;
1067 		__le32 inum = cpu_to_le32(inode->i_ino);
1068 		__le32 gen = cpu_to_le32(inode->i_generation);
1069 		csum = ext4_chksum(sbi, sbi->s_csum_seed, (__u8 *)&inum,
1070 				   sizeof(inum));
1071 		ei->i_csum_seed = ext4_chksum(sbi, csum, (__u8 *)&gen,
1072 					      sizeof(gen));
1073 	}
1074 
1075 	ext4_clear_state_flags(ei); /* Only relevant on 32-bit archs */
1076 	ext4_set_inode_state(inode, EXT4_STATE_NEW);
1077 
1078 	ei->i_extra_isize = EXT4_SB(sb)->s_want_extra_isize;
1079 	ei->i_inline_off = 0;
1080 	if (ext4_has_feature_inline_data(sb))
1081 		ext4_set_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA);
1082 	ret = inode;
1083 	err = dquot_alloc_inode(inode);
1084 	if (err)
1085 		goto fail_drop;
1086 
1087 	err = ext4_init_acl(handle, inode, dir);
1088 	if (err)
1089 		goto fail_free_drop;
1090 
1091 	err = ext4_init_security(handle, inode, dir, qstr);
1092 	if (err)
1093 		goto fail_free_drop;
1094 
1095 	if (ext4_has_feature_extents(sb)) {
1096 		/* set extent flag only for directory, file and normal symlink*/
1097 		if (S_ISDIR(mode) || S_ISREG(mode) || S_ISLNK(mode)) {
1098 			ext4_set_inode_flag(inode, EXT4_INODE_EXTENTS);
1099 			ext4_ext_tree_init(handle, inode);
1100 		}
1101 	}
1102 
1103 	if (ext4_handle_valid(handle)) {
1104 		ei->i_sync_tid = handle->h_transaction->t_tid;
1105 		ei->i_datasync_tid = handle->h_transaction->t_tid;
1106 	}
1107 
1108 	if (encrypt) {
1109 		err = ext4_inherit_context(dir, inode);
1110 		if (err)
1111 			goto fail_free_drop;
1112 	}
1113 
1114 	err = ext4_mark_inode_dirty(handle, inode);
1115 	if (err) {
1116 		ext4_std_error(sb, err);
1117 		goto fail_free_drop;
1118 	}
1119 
1120 	ext4_debug("allocating inode %lu\n", inode->i_ino);
1121 	trace_ext4_allocate_inode(inode, dir, mode);
1122 	brelse(inode_bitmap_bh);
1123 	return ret;
1124 
1125 fail_free_drop:
1126 	dquot_free_inode(inode);
1127 fail_drop:
1128 	clear_nlink(inode);
1129 	unlock_new_inode(inode);
1130 out:
1131 	dquot_drop(inode);
1132 	inode->i_flags |= S_NOQUOTA;
1133 	iput(inode);
1134 	brelse(inode_bitmap_bh);
1135 	return ERR_PTR(err);
1136 }
1137 
1138 /* Verify that we are loading a valid orphan from disk */
1139 struct inode *ext4_orphan_get(struct super_block *sb, unsigned long ino)
1140 {
1141 	unsigned long max_ino = le32_to_cpu(EXT4_SB(sb)->s_es->s_inodes_count);
1142 	ext4_group_t block_group;
1143 	int bit;
1144 	struct buffer_head *bitmap_bh;
1145 	struct inode *inode = NULL;
1146 	long err = -EIO;
1147 
1148 	/* Error cases - e2fsck has already cleaned up for us */
1149 	if (ino > max_ino) {
1150 		ext4_warning(sb, "bad orphan ino %lu!  e2fsck was run?", ino);
1151 		err = -EFSCORRUPTED;
1152 		goto error;
1153 	}
1154 
1155 	block_group = (ino - 1) / EXT4_INODES_PER_GROUP(sb);
1156 	bit = (ino - 1) % EXT4_INODES_PER_GROUP(sb);
1157 	bitmap_bh = ext4_read_inode_bitmap(sb, block_group);
1158 	if (IS_ERR(bitmap_bh)) {
1159 		err = PTR_ERR(bitmap_bh);
1160 		ext4_warning(sb, "inode bitmap error %ld for orphan %lu",
1161 			     ino, err);
1162 		goto error;
1163 	}
1164 
1165 	/* Having the inode bit set should be a 100% indicator that this
1166 	 * is a valid orphan (no e2fsck run on fs).  Orphans also include
1167 	 * inodes that were being truncated, so we can't check i_nlink==0.
1168 	 */
1169 	if (!ext4_test_bit(bit, bitmap_bh->b_data))
1170 		goto bad_orphan;
1171 
1172 	inode = ext4_iget(sb, ino);
1173 	if (IS_ERR(inode))
1174 		goto iget_failed;
1175 
1176 	/*
1177 	 * If the orphans has i_nlinks > 0 then it should be able to be
1178 	 * truncated, otherwise it won't be removed from the orphan list
1179 	 * during processing and an infinite loop will result.
1180 	 */
1181 	if (inode->i_nlink && !ext4_can_truncate(inode))
1182 		goto bad_orphan;
1183 
1184 	if (NEXT_ORPHAN(inode) > max_ino)
1185 		goto bad_orphan;
1186 	brelse(bitmap_bh);
1187 	return inode;
1188 
1189 iget_failed:
1190 	err = PTR_ERR(inode);
1191 	inode = NULL;
1192 bad_orphan:
1193 	ext4_warning(sb, "bad orphan inode %lu!  e2fsck was run?", ino);
1194 	printk(KERN_WARNING "ext4_test_bit(bit=%d, block=%llu) = %d\n",
1195 	       bit, (unsigned long long)bitmap_bh->b_blocknr,
1196 	       ext4_test_bit(bit, bitmap_bh->b_data));
1197 	printk(KERN_WARNING "inode=%p\n", inode);
1198 	if (inode) {
1199 		printk(KERN_WARNING "is_bad_inode(inode)=%d\n",
1200 		       is_bad_inode(inode));
1201 		printk(KERN_WARNING "NEXT_ORPHAN(inode)=%u\n",
1202 		       NEXT_ORPHAN(inode));
1203 		printk(KERN_WARNING "max_ino=%lu\n", max_ino);
1204 		printk(KERN_WARNING "i_nlink=%u\n", inode->i_nlink);
1205 		/* Avoid freeing blocks if we got a bad deleted inode */
1206 		if (inode->i_nlink == 0)
1207 			inode->i_blocks = 0;
1208 		iput(inode);
1209 	}
1210 	brelse(bitmap_bh);
1211 error:
1212 	return ERR_PTR(err);
1213 }
1214 
1215 unsigned long ext4_count_free_inodes(struct super_block *sb)
1216 {
1217 	unsigned long desc_count;
1218 	struct ext4_group_desc *gdp;
1219 	ext4_group_t i, ngroups = ext4_get_groups_count(sb);
1220 #ifdef EXT4FS_DEBUG
1221 	struct ext4_super_block *es;
1222 	unsigned long bitmap_count, x;
1223 	struct buffer_head *bitmap_bh = NULL;
1224 
1225 	es = EXT4_SB(sb)->s_es;
1226 	desc_count = 0;
1227 	bitmap_count = 0;
1228 	gdp = NULL;
1229 	for (i = 0; i < ngroups; i++) {
1230 		gdp = ext4_get_group_desc(sb, i, NULL);
1231 		if (!gdp)
1232 			continue;
1233 		desc_count += ext4_free_inodes_count(sb, gdp);
1234 		brelse(bitmap_bh);
1235 		bitmap_bh = ext4_read_inode_bitmap(sb, i);
1236 		if (IS_ERR(bitmap_bh)) {
1237 			bitmap_bh = NULL;
1238 			continue;
1239 		}
1240 
1241 		x = ext4_count_free(bitmap_bh->b_data,
1242 				    EXT4_INODES_PER_GROUP(sb) / 8);
1243 		printk(KERN_DEBUG "group %lu: stored = %d, counted = %lu\n",
1244 			(unsigned long) i, ext4_free_inodes_count(sb, gdp), x);
1245 		bitmap_count += x;
1246 	}
1247 	brelse(bitmap_bh);
1248 	printk(KERN_DEBUG "ext4_count_free_inodes: "
1249 	       "stored = %u, computed = %lu, %lu\n",
1250 	       le32_to_cpu(es->s_free_inodes_count), desc_count, bitmap_count);
1251 	return desc_count;
1252 #else
1253 	desc_count = 0;
1254 	for (i = 0; i < ngroups; i++) {
1255 		gdp = ext4_get_group_desc(sb, i, NULL);
1256 		if (!gdp)
1257 			continue;
1258 		desc_count += ext4_free_inodes_count(sb, gdp);
1259 		cond_resched();
1260 	}
1261 	return desc_count;
1262 #endif
1263 }
1264 
1265 /* Called at mount-time, super-block is locked */
1266 unsigned long ext4_count_dirs(struct super_block * sb)
1267 {
1268 	unsigned long count = 0;
1269 	ext4_group_t i, ngroups = ext4_get_groups_count(sb);
1270 
1271 	for (i = 0; i < ngroups; i++) {
1272 		struct ext4_group_desc *gdp = ext4_get_group_desc(sb, i, NULL);
1273 		if (!gdp)
1274 			continue;
1275 		count += ext4_used_dirs_count(sb, gdp);
1276 	}
1277 	return count;
1278 }
1279 
1280 /*
1281  * Zeroes not yet zeroed inode table - just write zeroes through the whole
1282  * inode table. Must be called without any spinlock held. The only place
1283  * where it is called from on active part of filesystem is ext4lazyinit
1284  * thread, so we do not need any special locks, however we have to prevent
1285  * inode allocation from the current group, so we take alloc_sem lock, to
1286  * block ext4_new_inode() until we are finished.
1287  */
1288 int ext4_init_inode_table(struct super_block *sb, ext4_group_t group,
1289 				 int barrier)
1290 {
1291 	struct ext4_group_info *grp = ext4_get_group_info(sb, group);
1292 	struct ext4_sb_info *sbi = EXT4_SB(sb);
1293 	struct ext4_group_desc *gdp = NULL;
1294 	struct buffer_head *group_desc_bh;
1295 	handle_t *handle;
1296 	ext4_fsblk_t blk;
1297 	int num, ret = 0, used_blks = 0;
1298 
1299 	/* This should not happen, but just to be sure check this */
1300 	if (sb->s_flags & MS_RDONLY) {
1301 		ret = 1;
1302 		goto out;
1303 	}
1304 
1305 	gdp = ext4_get_group_desc(sb, group, &group_desc_bh);
1306 	if (!gdp)
1307 		goto out;
1308 
1309 	/*
1310 	 * We do not need to lock this, because we are the only one
1311 	 * handling this flag.
1312 	 */
1313 	if (gdp->bg_flags & cpu_to_le16(EXT4_BG_INODE_ZEROED))
1314 		goto out;
1315 
1316 	handle = ext4_journal_start_sb(sb, EXT4_HT_MISC, 1);
1317 	if (IS_ERR(handle)) {
1318 		ret = PTR_ERR(handle);
1319 		goto out;
1320 	}
1321 
1322 	down_write(&grp->alloc_sem);
1323 	/*
1324 	 * If inode bitmap was already initialized there may be some
1325 	 * used inodes so we need to skip blocks with used inodes in
1326 	 * inode table.
1327 	 */
1328 	if (!(gdp->bg_flags & cpu_to_le16(EXT4_BG_INODE_UNINIT)))
1329 		used_blks = DIV_ROUND_UP((EXT4_INODES_PER_GROUP(sb) -
1330 			    ext4_itable_unused_count(sb, gdp)),
1331 			    sbi->s_inodes_per_block);
1332 
1333 	if ((used_blks < 0) || (used_blks > sbi->s_itb_per_group)) {
1334 		ext4_error(sb, "Something is wrong with group %u: "
1335 			   "used itable blocks: %d; "
1336 			   "itable unused count: %u",
1337 			   group, used_blks,
1338 			   ext4_itable_unused_count(sb, gdp));
1339 		ret = 1;
1340 		goto err_out;
1341 	}
1342 
1343 	blk = ext4_inode_table(sb, gdp) + used_blks;
1344 	num = sbi->s_itb_per_group - used_blks;
1345 
1346 	BUFFER_TRACE(group_desc_bh, "get_write_access");
1347 	ret = ext4_journal_get_write_access(handle,
1348 					    group_desc_bh);
1349 	if (ret)
1350 		goto err_out;
1351 
1352 	/*
1353 	 * Skip zeroout if the inode table is full. But we set the ZEROED
1354 	 * flag anyway, because obviously, when it is full it does not need
1355 	 * further zeroing.
1356 	 */
1357 	if (unlikely(num == 0))
1358 		goto skip_zeroout;
1359 
1360 	ext4_debug("going to zero out inode table in group %d\n",
1361 		   group);
1362 	ret = sb_issue_zeroout(sb, blk, num, GFP_NOFS);
1363 	if (ret < 0)
1364 		goto err_out;
1365 	if (barrier)
1366 		blkdev_issue_flush(sb->s_bdev, GFP_NOFS, NULL);
1367 
1368 skip_zeroout:
1369 	ext4_lock_group(sb, group);
1370 	gdp->bg_flags |= cpu_to_le16(EXT4_BG_INODE_ZEROED);
1371 	ext4_group_desc_csum_set(sb, group, gdp);
1372 	ext4_unlock_group(sb, group);
1373 
1374 	BUFFER_TRACE(group_desc_bh,
1375 		     "call ext4_handle_dirty_metadata");
1376 	ret = ext4_handle_dirty_metadata(handle, NULL,
1377 					 group_desc_bh);
1378 
1379 err_out:
1380 	up_write(&grp->alloc_sem);
1381 	ext4_journal_stop(handle);
1382 out:
1383 	return ret;
1384 }
1385