mbcache: Remove unused features
[linux-2.6.git] / fs / ext3 / ialloc.c
1 /*
2  *  linux/fs/ext3/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/jbd.h>
18 #include <linux/ext3_fs.h>
19 #include <linux/ext3_jbd.h>
20 #include <linux/stat.h>
21 #include <linux/string.h>
22 #include <linux/quotaops.h>
23 #include <linux/buffer_head.h>
24 #include <linux/random.h>
25 #include <linux/bitops.h>
26
27 #include <asm/byteorder.h>
28
29 #include "xattr.h"
30 #include "acl.h"
31
32 /*
33  * ialloc.c contains the inodes allocation and deallocation routines
34  */
35
36 /*
37  * The free inodes are managed by bitmaps.  A file system contains several
38  * blocks groups.  Each group contains 1 bitmap block for blocks, 1 bitmap
39  * block for inodes, N blocks for the inode table and data blocks.
40  *
41  * The file system contains group descriptors which are located after the
42  * super block.  Each descriptor contains the number of the bitmap block and
43  * the free blocks count in the block.
44  */
45
46
47 /*
48  * Read the inode allocation bitmap for a given block_group, reading
49  * into the specified slot in the superblock's bitmap cache.
50  *
51  * Return buffer_head of bitmap on success or NULL.
52  */
53 static struct buffer_head *
54 read_inode_bitmap(struct super_block * sb, unsigned long block_group)
55 {
56         struct ext3_group_desc *desc;
57         struct buffer_head *bh = NULL;
58
59         desc = ext3_get_group_desc(sb, block_group, NULL);
60         if (!desc)
61                 goto error_out;
62
63         bh = sb_bread(sb, le32_to_cpu(desc->bg_inode_bitmap));
64         if (!bh)
65                 ext3_error(sb, "read_inode_bitmap",
66                             "Cannot read inode bitmap - "
67                             "block_group = %lu, inode_bitmap = %u",
68                             block_group, le32_to_cpu(desc->bg_inode_bitmap));
69 error_out:
70         return bh;
71 }
72
73 /*
74  * NOTE! When we get the inode, we're the only people
75  * that have access to it, and as such there are no
76  * race conditions we have to worry about. The inode
77  * is not on the hash-lists, and it cannot be reached
78  * through the filesystem because the directory entry
79  * has been deleted earlier.
80  *
81  * HOWEVER: we must make sure that we get no aliases,
82  * which means that we have to call "clear_inode()"
83  * _before_ we mark the inode not in use in the inode
84  * bitmaps. Otherwise a newly created file might use
85  * the same inode number (not actually the same pointer
86  * though), and then we'd have two inodes sharing the
87  * same inode number and space on the harddisk.
88  */
89 void ext3_free_inode (handle_t *handle, struct inode * inode)
90 {
91         struct super_block * sb = inode->i_sb;
92         int is_directory;
93         unsigned long ino;
94         struct buffer_head *bitmap_bh = NULL;
95         struct buffer_head *bh2;
96         unsigned long block_group;
97         unsigned long bit;
98         struct ext3_group_desc * gdp;
99         struct ext3_super_block * es;
100         struct ext3_sb_info *sbi;
101         int fatal = 0, err;
102
103         if (atomic_read(&inode->i_count) > 1) {
104                 printk ("ext3_free_inode: inode has count=%d\n",
105                                         atomic_read(&inode->i_count));
106                 return;
107         }
108         if (inode->i_nlink) {
109                 printk ("ext3_free_inode: inode has nlink=%d\n",
110                         inode->i_nlink);
111                 return;
112         }
113         if (!sb) {
114                 printk("ext3_free_inode: inode on nonexistent device\n");
115                 return;
116         }
117         sbi = EXT3_SB(sb);
118
119         ino = inode->i_ino;
120         ext3_debug ("freeing inode %lu\n", ino);
121
122         is_directory = S_ISDIR(inode->i_mode);
123
124         es = EXT3_SB(sb)->s_es;
125         if (ino < EXT3_FIRST_INO(sb) || ino > le32_to_cpu(es->s_inodes_count)) {
126                 ext3_error (sb, "ext3_free_inode",
127                             "reserved or nonexistent inode %lu", ino);
128                 goto error_return;
129         }
130         block_group = (ino - 1) / EXT3_INODES_PER_GROUP(sb);
131         bit = (ino - 1) % EXT3_INODES_PER_GROUP(sb);
132         bitmap_bh = read_inode_bitmap(sb, block_group);
133         if (!bitmap_bh)
134                 goto error_return;
135
136         BUFFER_TRACE(bitmap_bh, "get_write_access");
137         fatal = ext3_journal_get_write_access(handle, bitmap_bh);
138         if (fatal)
139                 goto error_return;
140
141         /* Ok, now we can actually update the inode bitmaps.. */
142         if (!ext3_clear_bit_atomic(sb_bgl_lock(sbi, block_group),
143                                         bit, bitmap_bh->b_data))
144                 ext3_error (sb, "ext3_free_inode",
145                               "bit already cleared for inode %lu", ino);
146         else {
147                 gdp = ext3_get_group_desc (sb, block_group, &bh2);
148
149                 BUFFER_TRACE(bh2, "get_write_access");
150                 fatal = ext3_journal_get_write_access(handle, bh2);
151                 if (fatal) goto error_return;
152
153                 if (gdp) {
154                         spin_lock(sb_bgl_lock(sbi, block_group));
155                         le16_add_cpu(&gdp->bg_free_inodes_count, 1);
156                         if (is_directory)
157                                 le16_add_cpu(&gdp->bg_used_dirs_count, -1);
158                         spin_unlock(sb_bgl_lock(sbi, block_group));
159                         percpu_counter_inc(&sbi->s_freeinodes_counter);
160                         if (is_directory)
161                                 percpu_counter_dec(&sbi->s_dirs_counter);
162
163                 }
164                 BUFFER_TRACE(bh2, "call ext3_journal_dirty_metadata");
165                 err = ext3_journal_dirty_metadata(handle, bh2);
166                 if (!fatal) fatal = err;
167         }
168         BUFFER_TRACE(bitmap_bh, "call ext3_journal_dirty_metadata");
169         err = ext3_journal_dirty_metadata(handle, bitmap_bh);
170         if (!fatal)
171                 fatal = err;
172
173 error_return:
174         brelse(bitmap_bh);
175         ext3_std_error(sb, fatal);
176 }
177
178 /*
179  * There are two policies for allocating an inode.  If the new inode is
180  * a directory, then a forward search is made for a block group with both
181  * free space and a low directory-to-inode ratio; if that fails, then of
182  * the groups with above-average free space, that group with the fewest
183  * directories already is chosen.
184  *
185  * For other inodes, search forward from the parent directory\'s block
186  * group to find a free inode.
187  */
188 static int find_group_dir(struct super_block *sb, struct inode *parent)
189 {
190         int ngroups = EXT3_SB(sb)->s_groups_count;
191         unsigned int freei, avefreei;
192         struct ext3_group_desc *desc, *best_desc = NULL;
193         int group, best_group = -1;
194
195         freei = percpu_counter_read_positive(&EXT3_SB(sb)->s_freeinodes_counter);
196         avefreei = freei / ngroups;
197
198         for (group = 0; group < ngroups; group++) {
199                 desc = ext3_get_group_desc (sb, group, NULL);
200                 if (!desc || !desc->bg_free_inodes_count)
201                         continue;
202                 if (le16_to_cpu(desc->bg_free_inodes_count) < avefreei)
203                         continue;
204                 if (!best_desc ||
205                     (le16_to_cpu(desc->bg_free_blocks_count) >
206                      le16_to_cpu(best_desc->bg_free_blocks_count))) {
207                         best_group = group;
208                         best_desc = desc;
209                 }
210         }
211         return best_group;
212 }
213
214 /*
215  * Orlov's allocator for directories.
216  *
217  * We always try to spread first-level directories.
218  *
219  * If there are blockgroups with both free inodes and free blocks counts
220  * not worse than average we return one with smallest directory count.
221  * Otherwise we simply return a random group.
222  *
223  * For the rest rules look so:
224  *
225  * It's OK to put directory into a group unless
226  * it has too many directories already (max_dirs) or
227  * it has too few free inodes left (min_inodes) or
228  * it has too few free blocks left (min_blocks) or
229  * it's already running too large debt (max_debt).
230  * Parent's group is preferred, if it doesn't satisfy these
231  * conditions we search cyclically through the rest. If none
232  * of the groups look good we just look for a group with more
233  * free inodes than average (starting at parent's group).
234  *
235  * Debt is incremented each time we allocate a directory and decremented
236  * when we allocate an inode, within 0--255.
237  */
238
239 #define INODE_COST 64
240 #define BLOCK_COST 256
241
242 static int find_group_orlov(struct super_block *sb, struct inode *parent)
243 {
244         int parent_group = EXT3_I(parent)->i_block_group;
245         struct ext3_sb_info *sbi = EXT3_SB(sb);
246         struct ext3_super_block *es = sbi->s_es;
247         int ngroups = sbi->s_groups_count;
248         int inodes_per_group = EXT3_INODES_PER_GROUP(sb);
249         unsigned int freei, avefreei;
250         ext3_fsblk_t freeb, avefreeb;
251         ext3_fsblk_t blocks_per_dir;
252         unsigned int ndirs;
253         int max_debt, max_dirs, min_inodes;
254         ext3_grpblk_t min_blocks;
255         int group = -1, i;
256         struct ext3_group_desc *desc;
257
258         freei = percpu_counter_read_positive(&sbi->s_freeinodes_counter);
259         avefreei = freei / ngroups;
260         freeb = percpu_counter_read_positive(&sbi->s_freeblocks_counter);
261         avefreeb = freeb / ngroups;
262         ndirs = percpu_counter_read_positive(&sbi->s_dirs_counter);
263
264         if ((parent == sb->s_root->d_inode) ||
265             (EXT3_I(parent)->i_flags & EXT3_TOPDIR_FL)) {
266                 int best_ndir = inodes_per_group;
267                 int best_group = -1;
268
269                 get_random_bytes(&group, sizeof(group));
270                 parent_group = (unsigned)group % ngroups;
271                 for (i = 0; i < ngroups; i++) {
272                         group = (parent_group + i) % ngroups;
273                         desc = ext3_get_group_desc (sb, group, NULL);
274                         if (!desc || !desc->bg_free_inodes_count)
275                                 continue;
276                         if (le16_to_cpu(desc->bg_used_dirs_count) >= best_ndir)
277                                 continue;
278                         if (le16_to_cpu(desc->bg_free_inodes_count) < avefreei)
279                                 continue;
280                         if (le16_to_cpu(desc->bg_free_blocks_count) < avefreeb)
281                                 continue;
282                         best_group = group;
283                         best_ndir = le16_to_cpu(desc->bg_used_dirs_count);
284                 }
285                 if (best_group >= 0)
286                         return best_group;
287                 goto fallback;
288         }
289
290         blocks_per_dir = (le32_to_cpu(es->s_blocks_count) - freeb) / ndirs;
291
292         max_dirs = ndirs / ngroups + inodes_per_group / 16;
293         min_inodes = avefreei - inodes_per_group / 4;
294         min_blocks = avefreeb - EXT3_BLOCKS_PER_GROUP(sb) / 4;
295
296         max_debt = EXT3_BLOCKS_PER_GROUP(sb) / max(blocks_per_dir, (ext3_fsblk_t)BLOCK_COST);
297         if (max_debt * INODE_COST > inodes_per_group)
298                 max_debt = inodes_per_group / INODE_COST;
299         if (max_debt > 255)
300                 max_debt = 255;
301         if (max_debt == 0)
302                 max_debt = 1;
303
304         for (i = 0; i < ngroups; i++) {
305                 group = (parent_group + i) % ngroups;
306                 desc = ext3_get_group_desc (sb, group, NULL);
307                 if (!desc || !desc->bg_free_inodes_count)
308                         continue;
309                 if (le16_to_cpu(desc->bg_used_dirs_count) >= max_dirs)
310                         continue;
311                 if (le16_to_cpu(desc->bg_free_inodes_count) < min_inodes)
312                         continue;
313                 if (le16_to_cpu(desc->bg_free_blocks_count) < min_blocks)
314                         continue;
315                 return group;
316         }
317
318 fallback:
319         for (i = 0; i < ngroups; i++) {
320                 group = (parent_group + i) % ngroups;
321                 desc = ext3_get_group_desc (sb, group, NULL);
322                 if (!desc || !desc->bg_free_inodes_count)
323                         continue;
324                 if (le16_to_cpu(desc->bg_free_inodes_count) >= avefreei)
325                         return group;
326         }
327
328         if (avefreei) {
329                 /*
330                  * The free-inodes counter is approximate, and for really small
331                  * filesystems the above test can fail to find any blockgroups
332                  */
333                 avefreei = 0;
334                 goto fallback;
335         }
336
337         return -1;
338 }
339
340 static int find_group_other(struct super_block *sb, struct inode *parent)
341 {
342         int parent_group = EXT3_I(parent)->i_block_group;
343         int ngroups = EXT3_SB(sb)->s_groups_count;
344         struct ext3_group_desc *desc;
345         int group, i;
346
347         /*
348          * Try to place the inode in its parent directory
349          */
350         group = parent_group;
351         desc = ext3_get_group_desc (sb, group, NULL);
352         if (desc && le16_to_cpu(desc->bg_free_inodes_count) &&
353                         le16_to_cpu(desc->bg_free_blocks_count))
354                 return group;
355
356         /*
357          * We're going to place this inode in a different blockgroup from its
358          * parent.  We want to cause files in a common directory to all land in
359          * the same blockgroup.  But we want files which are in a different
360          * directory which shares a blockgroup with our parent to land in a
361          * different blockgroup.
362          *
363          * So add our directory's i_ino into the starting point for the hash.
364          */
365         group = (group + parent->i_ino) % ngroups;
366
367         /*
368          * Use a quadratic hash to find a group with a free inode and some free
369          * blocks.
370          */
371         for (i = 1; i < ngroups; i <<= 1) {
372                 group += i;
373                 if (group >= ngroups)
374                         group -= ngroups;
375                 desc = ext3_get_group_desc (sb, group, NULL);
376                 if (desc && le16_to_cpu(desc->bg_free_inodes_count) &&
377                                 le16_to_cpu(desc->bg_free_blocks_count))
378                         return group;
379         }
380
381         /*
382          * That failed: try linear search for a free inode, even if that group
383          * has no free blocks.
384          */
385         group = parent_group;
386         for (i = 0; i < ngroups; i++) {
387                 if (++group >= ngroups)
388                         group = 0;
389                 desc = ext3_get_group_desc (sb, group, NULL);
390                 if (desc && le16_to_cpu(desc->bg_free_inodes_count))
391                         return group;
392         }
393
394         return -1;
395 }
396
397 /*
398  * There are two policies for allocating an inode.  If the new inode is
399  * a directory, then a forward search is made for a block group with both
400  * free space and a low directory-to-inode ratio; if that fails, then of
401  * the groups with above-average free space, that group with the fewest
402  * directories already is chosen.
403  *
404  * For other inodes, search forward from the parent directory's block
405  * group to find a free inode.
406  */
407 struct inode *ext3_new_inode(handle_t *handle, struct inode * dir, int mode)
408 {
409         struct super_block *sb;
410         struct buffer_head *bitmap_bh = NULL;
411         struct buffer_head *bh2;
412         int group;
413         unsigned long ino = 0;
414         struct inode * inode;
415         struct ext3_group_desc * gdp = NULL;
416         struct ext3_super_block * es;
417         struct ext3_inode_info *ei;
418         struct ext3_sb_info *sbi;
419         int err = 0;
420         struct inode *ret;
421         int i;
422
423         /* Cannot create files in a deleted directory */
424         if (!dir || !dir->i_nlink)
425                 return ERR_PTR(-EPERM);
426
427         sb = dir->i_sb;
428         inode = new_inode(sb);
429         if (!inode)
430                 return ERR_PTR(-ENOMEM);
431         ei = EXT3_I(inode);
432
433         sbi = EXT3_SB(sb);
434         es = sbi->s_es;
435         if (S_ISDIR(mode)) {
436                 if (test_opt (sb, OLDALLOC))
437                         group = find_group_dir(sb, dir);
438                 else
439                         group = find_group_orlov(sb, dir);
440         } else
441                 group = find_group_other(sb, dir);
442
443         err = -ENOSPC;
444         if (group == -1)
445                 goto out;
446
447         for (i = 0; i < sbi->s_groups_count; i++) {
448                 err = -EIO;
449
450                 gdp = ext3_get_group_desc(sb, group, &bh2);
451                 if (!gdp)
452                         goto fail;
453
454                 brelse(bitmap_bh);
455                 bitmap_bh = read_inode_bitmap(sb, group);
456                 if (!bitmap_bh)
457                         goto fail;
458
459                 ino = 0;
460
461 repeat_in_this_group:
462                 ino = ext3_find_next_zero_bit((unsigned long *)
463                                 bitmap_bh->b_data, EXT3_INODES_PER_GROUP(sb), ino);
464                 if (ino < EXT3_INODES_PER_GROUP(sb)) {
465
466                         BUFFER_TRACE(bitmap_bh, "get_write_access");
467                         err = ext3_journal_get_write_access(handle, bitmap_bh);
468                         if (err)
469                                 goto fail;
470
471                         if (!ext3_set_bit_atomic(sb_bgl_lock(sbi, group),
472                                                 ino, bitmap_bh->b_data)) {
473                                 /* we won it */
474                                 BUFFER_TRACE(bitmap_bh,
475                                         "call ext3_journal_dirty_metadata");
476                                 err = ext3_journal_dirty_metadata(handle,
477                                                                 bitmap_bh);
478                                 if (err)
479                                         goto fail;
480                                 goto got;
481                         }
482                         /* we lost it */
483                         journal_release_buffer(handle, bitmap_bh);
484
485                         if (++ino < EXT3_INODES_PER_GROUP(sb))
486                                 goto repeat_in_this_group;
487                 }
488
489                 /*
490                  * This case is possible in concurrent environment.  It is very
491                  * rare.  We cannot repeat the find_group_xxx() call because
492                  * that will simply return the same blockgroup, because the
493                  * group descriptor metadata has not yet been updated.
494                  * So we just go onto the next blockgroup.
495                  */
496                 if (++group == sbi->s_groups_count)
497                         group = 0;
498         }
499         err = -ENOSPC;
500         goto out;
501
502 got:
503         ino += group * EXT3_INODES_PER_GROUP(sb) + 1;
504         if (ino < EXT3_FIRST_INO(sb) || ino > le32_to_cpu(es->s_inodes_count)) {
505                 ext3_error (sb, "ext3_new_inode",
506                             "reserved inode or inode > inodes count - "
507                             "block_group = %d, inode=%lu", group, ino);
508                 err = -EIO;
509                 goto fail;
510         }
511
512         BUFFER_TRACE(bh2, "get_write_access");
513         err = ext3_journal_get_write_access(handle, bh2);
514         if (err) goto fail;
515         spin_lock(sb_bgl_lock(sbi, group));
516         le16_add_cpu(&gdp->bg_free_inodes_count, -1);
517         if (S_ISDIR(mode)) {
518                 le16_add_cpu(&gdp->bg_used_dirs_count, 1);
519         }
520         spin_unlock(sb_bgl_lock(sbi, group));
521         BUFFER_TRACE(bh2, "call ext3_journal_dirty_metadata");
522         err = ext3_journal_dirty_metadata(handle, bh2);
523         if (err) goto fail;
524
525         percpu_counter_dec(&sbi->s_freeinodes_counter);
526         if (S_ISDIR(mode))
527                 percpu_counter_inc(&sbi->s_dirs_counter);
528
529
530         if (test_opt(sb, GRPID)) {
531                 inode->i_mode = mode;
532                 inode->i_uid = current_fsuid();
533                 inode->i_gid = dir->i_gid;
534         } else
535                 inode_init_owner(inode, dir, mode);
536
537         inode->i_ino = ino;
538         /* This is the optimal IO size (for stat), not the fs block size */
539         inode->i_blocks = 0;
540         inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME_SEC;
541
542         memset(ei->i_data, 0, sizeof(ei->i_data));
543         ei->i_dir_start_lookup = 0;
544         ei->i_disksize = 0;
545
546         ei->i_flags =
547                 ext3_mask_flags(mode, EXT3_I(dir)->i_flags & EXT3_FL_INHERITED);
548 #ifdef EXT3_FRAGMENTS
549         ei->i_faddr = 0;
550         ei->i_frag_no = 0;
551         ei->i_frag_size = 0;
552 #endif
553         ei->i_file_acl = 0;
554         ei->i_dir_acl = 0;
555         ei->i_dtime = 0;
556         ei->i_block_alloc_info = NULL;
557         ei->i_block_group = group;
558
559         ext3_set_inode_flags(inode);
560         if (IS_DIRSYNC(inode))
561                 handle->h_sync = 1;
562         if (insert_inode_locked(inode) < 0) {
563                 err = -EINVAL;
564                 goto fail_drop;
565         }
566         spin_lock(&sbi->s_next_gen_lock);
567         inode->i_generation = sbi->s_next_generation++;
568         spin_unlock(&sbi->s_next_gen_lock);
569
570         ei->i_state_flags = 0;
571         ext3_set_inode_state(inode, EXT3_STATE_NEW);
572
573         ei->i_extra_isize =
574                 (EXT3_INODE_SIZE(inode->i_sb) > EXT3_GOOD_OLD_INODE_SIZE) ?
575                 sizeof(struct ext3_inode) - EXT3_GOOD_OLD_INODE_SIZE : 0;
576
577         ret = inode;
578         dquot_initialize(inode);
579         err = dquot_alloc_inode(inode);
580         if (err)
581                 goto fail_drop;
582
583         err = ext3_init_acl(handle, inode, dir);
584         if (err)
585                 goto fail_free_drop;
586
587         err = ext3_init_security(handle,inode, dir);
588         if (err)
589                 goto fail_free_drop;
590
591         err = ext3_mark_inode_dirty(handle, inode);
592         if (err) {
593                 ext3_std_error(sb, err);
594                 goto fail_free_drop;
595         }
596
597         ext3_debug("allocating inode %lu\n", inode->i_ino);
598         goto really_out;
599 fail:
600         ext3_std_error(sb, err);
601 out:
602         iput(inode);
603         ret = ERR_PTR(err);
604 really_out:
605         brelse(bitmap_bh);
606         return ret;
607
608 fail_free_drop:
609         dquot_free_inode(inode);
610
611 fail_drop:
612         dquot_drop(inode);
613         inode->i_flags |= S_NOQUOTA;
614         inode->i_nlink = 0;
615         unlock_new_inode(inode);
616         iput(inode);
617         brelse(bitmap_bh);
618         return ERR_PTR(err);
619 }
620
621 /* Verify that we are loading a valid orphan from disk */
622 struct inode *ext3_orphan_get(struct super_block *sb, unsigned long ino)
623 {
624         unsigned long max_ino = le32_to_cpu(EXT3_SB(sb)->s_es->s_inodes_count);
625         unsigned long block_group;
626         int bit;
627         struct buffer_head *bitmap_bh;
628         struct inode *inode = NULL;
629         long err = -EIO;
630
631         /* Error cases - e2fsck has already cleaned up for us */
632         if (ino > max_ino) {
633                 ext3_warning(sb, __func__,
634                              "bad orphan ino %lu!  e2fsck was run?", ino);
635                 goto error;
636         }
637
638         block_group = (ino - 1) / EXT3_INODES_PER_GROUP(sb);
639         bit = (ino - 1) % EXT3_INODES_PER_GROUP(sb);
640         bitmap_bh = read_inode_bitmap(sb, block_group);
641         if (!bitmap_bh) {
642                 ext3_warning(sb, __func__,
643                              "inode bitmap error for orphan %lu", ino);
644                 goto error;
645         }
646
647         /* Having the inode bit set should be a 100% indicator that this
648          * is a valid orphan (no e2fsck run on fs).  Orphans also include
649          * inodes that were being truncated, so we can't check i_nlink==0.
650          */
651         if (!ext3_test_bit(bit, bitmap_bh->b_data))
652                 goto bad_orphan;
653
654         inode = ext3_iget(sb, ino);
655         if (IS_ERR(inode))
656                 goto iget_failed;
657
658         /*
659          * If the orphans has i_nlinks > 0 then it should be able to be
660          * truncated, otherwise it won't be removed from the orphan list
661          * during processing and an infinite loop will result.
662          */
663         if (inode->i_nlink && !ext3_can_truncate(inode))
664                 goto bad_orphan;
665
666         if (NEXT_ORPHAN(inode) > max_ino)
667                 goto bad_orphan;
668         brelse(bitmap_bh);
669         return inode;
670
671 iget_failed:
672         err = PTR_ERR(inode);
673         inode = NULL;
674 bad_orphan:
675         ext3_warning(sb, __func__,
676                      "bad orphan inode %lu!  e2fsck was run?", ino);
677         printk(KERN_NOTICE "ext3_test_bit(bit=%d, block=%llu) = %d\n",
678                bit, (unsigned long long)bitmap_bh->b_blocknr,
679                ext3_test_bit(bit, bitmap_bh->b_data));
680         printk(KERN_NOTICE "inode=%p\n", inode);
681         if (inode) {
682                 printk(KERN_NOTICE "is_bad_inode(inode)=%d\n",
683                        is_bad_inode(inode));
684                 printk(KERN_NOTICE "NEXT_ORPHAN(inode)=%u\n",
685                        NEXT_ORPHAN(inode));
686                 printk(KERN_NOTICE "max_ino=%lu\n", max_ino);
687                 printk(KERN_NOTICE "i_nlink=%u\n", inode->i_nlink);
688                 /* Avoid freeing blocks if we got a bad deleted inode */
689                 if (inode->i_nlink == 0)
690                         inode->i_blocks = 0;
691                 iput(inode);
692         }
693         brelse(bitmap_bh);
694 error:
695         return ERR_PTR(err);
696 }
697
698 unsigned long ext3_count_free_inodes (struct super_block * sb)
699 {
700         unsigned long desc_count;
701         struct ext3_group_desc *gdp;
702         int i;
703 #ifdef EXT3FS_DEBUG
704         struct ext3_super_block *es;
705         unsigned long bitmap_count, x;
706         struct buffer_head *bitmap_bh = NULL;
707
708         es = EXT3_SB(sb)->s_es;
709         desc_count = 0;
710         bitmap_count = 0;
711         gdp = NULL;
712         for (i = 0; i < EXT3_SB(sb)->s_groups_count; i++) {
713                 gdp = ext3_get_group_desc (sb, i, NULL);
714                 if (!gdp)
715                         continue;
716                 desc_count += le16_to_cpu(gdp->bg_free_inodes_count);
717                 brelse(bitmap_bh);
718                 bitmap_bh = read_inode_bitmap(sb, i);
719                 if (!bitmap_bh)
720                         continue;
721
722                 x = ext3_count_free(bitmap_bh, EXT3_INODES_PER_GROUP(sb) / 8);
723                 printk("group %d: stored = %d, counted = %lu\n",
724                         i, le16_to_cpu(gdp->bg_free_inodes_count), x);
725                 bitmap_count += x;
726         }
727         brelse(bitmap_bh);
728         printk("ext3_count_free_inodes: stored = %u, computed = %lu, %lu\n",
729                 le32_to_cpu(es->s_free_inodes_count), desc_count, bitmap_count);
730         return desc_count;
731 #else
732         desc_count = 0;
733         for (i = 0; i < EXT3_SB(sb)->s_groups_count; i++) {
734                 gdp = ext3_get_group_desc (sb, i, NULL);
735                 if (!gdp)
736                         continue;
737                 desc_count += le16_to_cpu(gdp->bg_free_inodes_count);
738                 cond_resched();
739         }
740         return desc_count;
741 #endif
742 }
743
744 /* Called at mount-time, super-block is locked */
745 unsigned long ext3_count_dirs (struct super_block * sb)
746 {
747         unsigned long count = 0;
748         int i;
749
750         for (i = 0; i < EXT3_SB(sb)->s_groups_count; i++) {
751                 struct ext3_group_desc *gdp = ext3_get_group_desc (sb, i, NULL);
752                 if (!gdp)
753                         continue;
754                 count += le16_to_cpu(gdp->bg_used_dirs_count);
755         }
756         return count;
757 }
758