Root/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 */
53static struct buffer_head *
54read_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));
69error_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 */
89void 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
173error_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 */
188static 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
242static 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
318fallback:
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
340static 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 */
407struct inode *ext3_new_inode(handle_t *handle, struct inode * dir,
408                 const struct qstr *qstr, int mode)
409{
410    struct super_block *sb;
411    struct buffer_head *bitmap_bh = NULL;
412    struct buffer_head *bh2;
413    int group;
414    unsigned long ino = 0;
415    struct inode * inode;
416    struct ext3_group_desc * gdp = NULL;
417    struct ext3_super_block * es;
418    struct ext3_inode_info *ei;
419    struct ext3_sb_info *sbi;
420    int err = 0;
421    struct inode *ret;
422    int i;
423
424    /* Cannot create files in a deleted directory */
425    if (!dir || !dir->i_nlink)
426        return ERR_PTR(-EPERM);
427
428    sb = dir->i_sb;
429    inode = new_inode(sb);
430    if (!inode)
431        return ERR_PTR(-ENOMEM);
432    ei = EXT3_I(inode);
433
434    sbi = EXT3_SB(sb);
435    es = sbi->s_es;
436    if (S_ISDIR(mode)) {
437        if (test_opt (sb, OLDALLOC))
438            group = find_group_dir(sb, dir);
439        else
440            group = find_group_orlov(sb, dir);
441    } else
442        group = find_group_other(sb, dir);
443
444    err = -ENOSPC;
445    if (group == -1)
446        goto out;
447
448    for (i = 0; i < sbi->s_groups_count; i++) {
449        err = -EIO;
450
451        gdp = ext3_get_group_desc(sb, group, &bh2);
452        if (!gdp)
453            goto fail;
454
455        brelse(bitmap_bh);
456        bitmap_bh = read_inode_bitmap(sb, group);
457        if (!bitmap_bh)
458            goto fail;
459
460        ino = 0;
461
462repeat_in_this_group:
463        ino = ext3_find_next_zero_bit((unsigned long *)
464                bitmap_bh->b_data, EXT3_INODES_PER_GROUP(sb), ino);
465        if (ino < EXT3_INODES_PER_GROUP(sb)) {
466
467            BUFFER_TRACE(bitmap_bh, "get_write_access");
468            err = ext3_journal_get_write_access(handle, bitmap_bh);
469            if (err)
470                goto fail;
471
472            if (!ext3_set_bit_atomic(sb_bgl_lock(sbi, group),
473                        ino, bitmap_bh->b_data)) {
474                /* we won it */
475                BUFFER_TRACE(bitmap_bh,
476                    "call ext3_journal_dirty_metadata");
477                err = ext3_journal_dirty_metadata(handle,
478                                bitmap_bh);
479                if (err)
480                    goto fail;
481                goto got;
482            }
483            /* we lost it */
484            journal_release_buffer(handle, bitmap_bh);
485
486            if (++ino < EXT3_INODES_PER_GROUP(sb))
487                goto repeat_in_this_group;
488        }
489
490        /*
491         * This case is possible in concurrent environment. It is very
492         * rare. We cannot repeat the find_group_xxx() call because
493         * that will simply return the same blockgroup, because the
494         * group descriptor metadata has not yet been updated.
495         * So we just go onto the next blockgroup.
496         */
497        if (++group == sbi->s_groups_count)
498            group = 0;
499    }
500    err = -ENOSPC;
501    goto out;
502
503got:
504    ino += group * EXT3_INODES_PER_GROUP(sb) + 1;
505    if (ino < EXT3_FIRST_INO(sb) || ino > le32_to_cpu(es->s_inodes_count)) {
506        ext3_error (sb, "ext3_new_inode",
507                "reserved inode or inode > inodes count - "
508                "block_group = %d, inode=%lu", group, ino);
509        err = -EIO;
510        goto fail;
511    }
512
513    BUFFER_TRACE(bh2, "get_write_access");
514    err = ext3_journal_get_write_access(handle, bh2);
515    if (err) goto fail;
516    spin_lock(sb_bgl_lock(sbi, group));
517    le16_add_cpu(&gdp->bg_free_inodes_count, -1);
518    if (S_ISDIR(mode)) {
519        le16_add_cpu(&gdp->bg_used_dirs_count, 1);
520    }
521    spin_unlock(sb_bgl_lock(sbi, group));
522    BUFFER_TRACE(bh2, "call ext3_journal_dirty_metadata");
523    err = ext3_journal_dirty_metadata(handle, bh2);
524    if (err) goto fail;
525
526    percpu_counter_dec(&sbi->s_freeinodes_counter);
527    if (S_ISDIR(mode))
528        percpu_counter_inc(&sbi->s_dirs_counter);
529
530
531    if (test_opt(sb, GRPID)) {
532        inode->i_mode = mode;
533        inode->i_uid = current_fsuid();
534        inode->i_gid = dir->i_gid;
535    } else
536        inode_init_owner(inode, dir, mode);
537
538    inode->i_ino = ino;
539    /* This is the optimal IO size (for stat), not the fs block size */
540    inode->i_blocks = 0;
541    inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME_SEC;
542
543    memset(ei->i_data, 0, sizeof(ei->i_data));
544    ei->i_dir_start_lookup = 0;
545    ei->i_disksize = 0;
546
547    ei->i_flags =
548        ext3_mask_flags(mode, EXT3_I(dir)->i_flags & EXT3_FL_INHERITED);
549#ifdef EXT3_FRAGMENTS
550    ei->i_faddr = 0;
551    ei->i_frag_no = 0;
552    ei->i_frag_size = 0;
553#endif
554    ei->i_file_acl = 0;
555    ei->i_dir_acl = 0;
556    ei->i_dtime = 0;
557    ei->i_block_alloc_info = NULL;
558    ei->i_block_group = group;
559
560    ext3_set_inode_flags(inode);
561    if (IS_DIRSYNC(inode))
562        handle->h_sync = 1;
563    if (insert_inode_locked(inode) < 0) {
564        err = -EINVAL;
565        goto fail_drop;
566    }
567    spin_lock(&sbi->s_next_gen_lock);
568    inode->i_generation = sbi->s_next_generation++;
569    spin_unlock(&sbi->s_next_gen_lock);
570
571    ei->i_state_flags = 0;
572    ext3_set_inode_state(inode, EXT3_STATE_NEW);
573
574    /* See comment in ext3_iget for explanation */
575    if (ino >= EXT3_FIRST_INO(sb) + 1 &&
576        EXT3_INODE_SIZE(sb) > EXT3_GOOD_OLD_INODE_SIZE) {
577        ei->i_extra_isize =
578            sizeof(struct ext3_inode) - EXT3_GOOD_OLD_INODE_SIZE;
579    } else {
580        ei->i_extra_isize = 0;
581    }
582
583    ret = inode;
584    dquot_initialize(inode);
585    err = dquot_alloc_inode(inode);
586    if (err)
587        goto fail_drop;
588
589    err = ext3_init_acl(handle, inode, dir);
590    if (err)
591        goto fail_free_drop;
592
593    err = ext3_init_security(handle, inode, dir, qstr);
594    if (err)
595        goto fail_free_drop;
596
597    err = ext3_mark_inode_dirty(handle, inode);
598    if (err) {
599        ext3_std_error(sb, err);
600        goto fail_free_drop;
601    }
602
603    ext3_debug("allocating inode %lu\n", inode->i_ino);
604    goto really_out;
605fail:
606    ext3_std_error(sb, err);
607out:
608    iput(inode);
609    ret = ERR_PTR(err);
610really_out:
611    brelse(bitmap_bh);
612    return ret;
613
614fail_free_drop:
615    dquot_free_inode(inode);
616
617fail_drop:
618    dquot_drop(inode);
619    inode->i_flags |= S_NOQUOTA;
620    inode->i_nlink = 0;
621    unlock_new_inode(inode);
622    iput(inode);
623    brelse(bitmap_bh);
624    return ERR_PTR(err);
625}
626
627/* Verify that we are loading a valid orphan from disk */
628struct inode *ext3_orphan_get(struct super_block *sb, unsigned long ino)
629{
630    unsigned long max_ino = le32_to_cpu(EXT3_SB(sb)->s_es->s_inodes_count);
631    unsigned long block_group;
632    int bit;
633    struct buffer_head *bitmap_bh;
634    struct inode *inode = NULL;
635    long err = -EIO;
636
637    /* Error cases - e2fsck has already cleaned up for us */
638    if (ino > max_ino) {
639        ext3_warning(sb, __func__,
640                 "bad orphan ino %lu! e2fsck was run?", ino);
641        goto error;
642    }
643
644    block_group = (ino - 1) / EXT3_INODES_PER_GROUP(sb);
645    bit = (ino - 1) % EXT3_INODES_PER_GROUP(sb);
646    bitmap_bh = read_inode_bitmap(sb, block_group);
647    if (!bitmap_bh) {
648        ext3_warning(sb, __func__,
649                 "inode bitmap error for orphan %lu", ino);
650        goto error;
651    }
652
653    /* Having the inode bit set should be a 100% indicator that this
654     * is a valid orphan (no e2fsck run on fs). Orphans also include
655     * inodes that were being truncated, so we can't check i_nlink==0.
656     */
657    if (!ext3_test_bit(bit, bitmap_bh->b_data))
658        goto bad_orphan;
659
660    inode = ext3_iget(sb, ino);
661    if (IS_ERR(inode))
662        goto iget_failed;
663
664    /*
665     * If the orphans has i_nlinks > 0 then it should be able to be
666     * truncated, otherwise it won't be removed from the orphan list
667     * during processing and an infinite loop will result.
668     */
669    if (inode->i_nlink && !ext3_can_truncate(inode))
670        goto bad_orphan;
671
672    if (NEXT_ORPHAN(inode) > max_ino)
673        goto bad_orphan;
674    brelse(bitmap_bh);
675    return inode;
676
677iget_failed:
678    err = PTR_ERR(inode);
679    inode = NULL;
680bad_orphan:
681    ext3_warning(sb, __func__,
682             "bad orphan inode %lu! e2fsck was run?", ino);
683    printk(KERN_NOTICE "ext3_test_bit(bit=%d, block=%llu) = %d\n",
684           bit, (unsigned long long)bitmap_bh->b_blocknr,
685           ext3_test_bit(bit, bitmap_bh->b_data));
686    printk(KERN_NOTICE "inode=%p\n", inode);
687    if (inode) {
688        printk(KERN_NOTICE "is_bad_inode(inode)=%d\n",
689               is_bad_inode(inode));
690        printk(KERN_NOTICE "NEXT_ORPHAN(inode)=%u\n",
691               NEXT_ORPHAN(inode));
692        printk(KERN_NOTICE "max_ino=%lu\n", max_ino);
693        printk(KERN_NOTICE "i_nlink=%u\n", inode->i_nlink);
694        /* Avoid freeing blocks if we got a bad deleted inode */
695        if (inode->i_nlink == 0)
696            inode->i_blocks = 0;
697        iput(inode);
698    }
699    brelse(bitmap_bh);
700error:
701    return ERR_PTR(err);
702}
703
704unsigned long ext3_count_free_inodes (struct super_block * sb)
705{
706    unsigned long desc_count;
707    struct ext3_group_desc *gdp;
708    int i;
709#ifdef EXT3FS_DEBUG
710    struct ext3_super_block *es;
711    unsigned long bitmap_count, x;
712    struct buffer_head *bitmap_bh = NULL;
713
714    es = EXT3_SB(sb)->s_es;
715    desc_count = 0;
716    bitmap_count = 0;
717    gdp = NULL;
718    for (i = 0; i < EXT3_SB(sb)->s_groups_count; i++) {
719        gdp = ext3_get_group_desc (sb, i, NULL);
720        if (!gdp)
721            continue;
722        desc_count += le16_to_cpu(gdp->bg_free_inodes_count);
723        brelse(bitmap_bh);
724        bitmap_bh = read_inode_bitmap(sb, i);
725        if (!bitmap_bh)
726            continue;
727
728        x = ext3_count_free(bitmap_bh, EXT3_INODES_PER_GROUP(sb) / 8);
729        printk("group %d: stored = %d, counted = %lu\n",
730            i, le16_to_cpu(gdp->bg_free_inodes_count), x);
731        bitmap_count += x;
732    }
733    brelse(bitmap_bh);
734    printk("ext3_count_free_inodes: stored = %u, computed = %lu, %lu\n",
735        le32_to_cpu(es->s_free_inodes_count), desc_count, bitmap_count);
736    return desc_count;
737#else
738    desc_count = 0;
739    for (i = 0; i < EXT3_SB(sb)->s_groups_count; i++) {
740        gdp = ext3_get_group_desc (sb, i, NULL);
741        if (!gdp)
742            continue;
743        desc_count += le16_to_cpu(gdp->bg_free_inodes_count);
744        cond_resched();
745    }
746    return desc_count;
747#endif
748}
749
750/* Called at mount-time, super-block is locked */
751unsigned long ext3_count_dirs (struct super_block * sb)
752{
753    unsigned long count = 0;
754    int i;
755
756    for (i = 0; i < EXT3_SB(sb)->s_groups_count; i++) {
757        struct ext3_group_desc *gdp = ext3_get_group_desc (sb, i, NULL);
758        if (!gdp)
759            continue;
760        count += le16_to_cpu(gdp->bg_used_dirs_count);
761    }
762    return count;
763}
764
765

Archive Download this file



interactive