home *** CD-ROM | disk | FTP | other *** search
/ Il CD di internet / CD.iso / SOURCE / KERNEL-S / V1.2 / LINUX-1.2 / LINUX-1 / linux / fs / ext2 / ialloc.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-03-06  |  15.7 KB  |  555 lines
  1. /*
  2.  *  linux/fs/ext2/ialloc.c
  3.  *
  4.  *  Copyright (C) 1992, 1993, 1994  Remy Card (card@masi.ibp.fr)
  5.  *                                  Laboratoire MASI - Institut Blaise Pascal
  6.  *                                  Universite Pierre et Marie Curie (Paris VI)
  7.  *
  8.  *  BSD ufs-inspired inode and directory allocation by 
  9.  *  Stephen Tweedie (sct@dcs.ed.ac.uk), 1993
  10.  */
  11.  
  12. /*
  13.  * ialloc.c contains the inodes allocation and deallocation routines
  14.  */
  15.  
  16. /*
  17.  * The free inodes are managed by bitmaps.  A file system contains several
  18.  * blocks groups.  Each group contains 1 bitmap block for blocks, 1 bitmap
  19.  * block for inodes, N blocks for the inode table and data blocks.
  20.  *
  21.  * The file system contains group descriptors which are located after the
  22.  * super block.  Each descriptor contains the number of the bitmap block and
  23.  * the free blocks count in the block.  The descriptors are loaded in memory
  24.  * when a file system is mounted (see ext2_read_super).
  25.  */
  26.  
  27. #include <linux/fs.h>
  28. #include <linux/ext2_fs.h>
  29. #include <linux/sched.h>
  30. #include <linux/stat.h>
  31. #include <linux/string.h>
  32. #include <linux/locks.h>
  33.  
  34. #include <asm/bitops.h>
  35.  
  36. static struct ext2_group_desc * get_group_desc (struct super_block * sb,
  37.                         unsigned int block_group,
  38.                         struct buffer_head ** bh)
  39. {
  40.     unsigned long group_desc;
  41.     unsigned long desc;
  42.     struct ext2_group_desc * gdp;
  43.  
  44.     if (block_group >= sb->u.ext2_sb.s_groups_count)
  45.         ext2_panic (sb, "get_group_desc",
  46.                 "block_group >= groups_count - "
  47.                 "block_group = %d, groups_count = %lu",
  48.                 block_group, sb->u.ext2_sb.s_groups_count);
  49.  
  50.     group_desc = block_group / EXT2_DESC_PER_BLOCK(sb);
  51.     desc = block_group % EXT2_DESC_PER_BLOCK(sb);
  52.     if (!sb->u.ext2_sb.s_group_desc[group_desc])
  53.         ext2_panic (sb, "get_group_desc",
  54.                 "Group descriptor not loaded - "
  55.                 "block_group = %d, group_desc = %lu, desc = %lu",
  56.                  block_group, group_desc, desc);
  57.     gdp = (struct ext2_group_desc *) 
  58.         sb->u.ext2_sb.s_group_desc[group_desc]->b_data;
  59.     if (bh)
  60.         *bh = sb->u.ext2_sb.s_group_desc[group_desc];
  61.     return gdp + desc;
  62. }
  63.  
  64. static void read_inode_bitmap (struct super_block * sb,
  65.                    unsigned long block_group,
  66.                    unsigned int bitmap_nr)
  67. {
  68.     struct ext2_group_desc * gdp;
  69.     struct buffer_head * bh;
  70.  
  71.     gdp = get_group_desc (sb, block_group, NULL);
  72.     bh = bread (sb->s_dev, gdp->bg_inode_bitmap, sb->s_blocksize);
  73.     if (!bh)
  74.         ext2_panic (sb, "read_inode_bitmap",
  75.                 "Cannot read inode bitmap - "
  76.                 "block_group = %lu, inode_bitmap = %lu",
  77.                 block_group, (unsigned long) gdp->bg_inode_bitmap);
  78.     sb->u.ext2_sb.s_inode_bitmap_number[bitmap_nr] = block_group;
  79.     sb->u.ext2_sb.s_inode_bitmap[bitmap_nr] = bh;
  80. }
  81.  
  82. /*
  83.  * load_inode_bitmap loads the inode bitmap for a blocks group
  84.  *
  85.  * It maintains a cache for the last bitmaps loaded.  This cache is managed
  86.  * with a LRU algorithm.
  87.  *
  88.  * Notes:
  89.  * 1/ There is one cache per mounted file system.
  90.  * 2/ If the file system contains less than EXT2_MAX_GROUP_LOADED groups,
  91.  *    this function reads the bitmap without maintaining a LRU cache.
  92.  */
  93. static int load_inode_bitmap (struct super_block * sb,
  94.                   unsigned int block_group)
  95. {
  96.     int i, j;
  97.     unsigned long inode_bitmap_number;
  98.     struct buffer_head * inode_bitmap;
  99.  
  100.     if (block_group >= sb->u.ext2_sb.s_groups_count)
  101.         ext2_panic (sb, "load_inode_bitmap",
  102.                 "block_group >= groups_count - "
  103.                 "block_group = %d, groups_count = %lu",
  104.                  block_group, sb->u.ext2_sb.s_groups_count);
  105.     if (sb->u.ext2_sb.s_loaded_inode_bitmaps > 0 &&
  106.         sb->u.ext2_sb.s_inode_bitmap_number[0] == block_group)
  107.         return 0;
  108.     if (sb->u.ext2_sb.s_groups_count <= EXT2_MAX_GROUP_LOADED) {
  109.         if (sb->u.ext2_sb.s_inode_bitmap[block_group]) {
  110.             if (sb->u.ext2_sb.s_inode_bitmap_number[block_group] != block_group)
  111.                 ext2_panic (sb, "load_inode_bitmap",
  112.                         "block_group != inode_bitmap_number");
  113.             else
  114.                 return block_group;
  115.         } else {
  116.             read_inode_bitmap (sb, block_group, block_group);
  117.             return block_group;
  118.         }
  119.     }
  120.  
  121.     for (i = 0; i < sb->u.ext2_sb.s_loaded_inode_bitmaps &&
  122.             sb->u.ext2_sb.s_inode_bitmap_number[i] != block_group;
  123.          i++)
  124.         ;
  125.     if (i < sb->u.ext2_sb.s_loaded_inode_bitmaps &&
  126.           sb->u.ext2_sb.s_inode_bitmap_number[i] == block_group) {
  127.         inode_bitmap_number = sb->u.ext2_sb.s_inode_bitmap_number[i];
  128.         inode_bitmap = sb->u.ext2_sb.s_inode_bitmap[i];
  129.         for (j = i; j > 0; j--) {
  130.             sb->u.ext2_sb.s_inode_bitmap_number[j] =
  131.                 sb->u.ext2_sb.s_inode_bitmap_number[j - 1];
  132.             sb->u.ext2_sb.s_inode_bitmap[j] =
  133.                 sb->u.ext2_sb.s_inode_bitmap[j - 1];
  134.         }
  135.         sb->u.ext2_sb.s_inode_bitmap_number[0] = inode_bitmap_number;
  136.         sb->u.ext2_sb.s_inode_bitmap[0] = inode_bitmap;
  137.     } else {
  138.         if (sb->u.ext2_sb.s_loaded_inode_bitmaps < EXT2_MAX_GROUP_LOADED)
  139.             sb->u.ext2_sb.s_loaded_inode_bitmaps++;
  140.         else
  141.             brelse (sb->u.ext2_sb.s_inode_bitmap[EXT2_MAX_GROUP_LOADED - 1]);
  142.         for (j = sb->u.ext2_sb.s_loaded_inode_bitmaps - 1; j > 0; j--) {
  143.             sb->u.ext2_sb.s_inode_bitmap_number[j] =
  144.                 sb->u.ext2_sb.s_inode_bitmap_number[j - 1];
  145.             sb->u.ext2_sb.s_inode_bitmap[j] =
  146.                 sb->u.ext2_sb.s_inode_bitmap[j - 1];
  147.         }
  148.         read_inode_bitmap (sb, block_group, 0);
  149.     }
  150.     return 0;
  151. }
  152.  
  153. /*
  154.  * This function sets the deletion time for the inode
  155.  *
  156.  * This may be used one day by an 'undelete' program
  157.  */
  158. static void set_inode_dtime (struct inode * inode,
  159.                  struct ext2_group_desc * gdp)
  160. {
  161.     unsigned long inode_block;
  162.     struct buffer_head * bh;
  163.     struct ext2_inode * raw_inode;
  164.  
  165.     inode_block = gdp->bg_inode_table + (((inode->i_ino - 1) %
  166.             EXT2_INODES_PER_GROUP(inode->i_sb)) /
  167.             EXT2_INODES_PER_BLOCK(inode->i_sb));
  168.     bh = bread (inode->i_sb->s_dev, inode_block, inode->i_sb->s_blocksize);
  169.     if (!bh)
  170.         ext2_panic (inode->i_sb, "set_inode_dtime",
  171.                 "Cannot load inode table block - "
  172.                 "inode=%lu, inode_block=%lu",
  173.                 inode->i_ino, inode_block);
  174.     raw_inode = ((struct ext2_inode *) bh->b_data) +
  175.             (((inode->i_ino - 1) %
  176.             EXT2_INODES_PER_GROUP(inode->i_sb)) %
  177.             EXT2_INODES_PER_BLOCK(inode->i_sb));
  178.     raw_inode->i_links_count = 0;
  179.     raw_inode->i_dtime = CURRENT_TIME;
  180.     mark_buffer_dirty(bh, 1);
  181.     if (IS_SYNC(inode)) {
  182.         ll_rw_block (WRITE, 1, &bh);
  183.         wait_on_buffer (bh);
  184.     }
  185.     brelse (bh);
  186. }
  187.  
  188. void ext2_free_inode (struct inode * inode)
  189. {
  190.     struct super_block * sb;
  191.     struct buffer_head * bh;
  192.     struct buffer_head * bh2;
  193.     unsigned long block_group;
  194.     unsigned long bit;
  195.     int bitmap_nr;
  196.     struct ext2_group_desc * gdp;
  197.     struct ext2_super_block * es;
  198.  
  199.     if (!inode)
  200.         return;
  201.     if (!inode->i_dev) {
  202.         printk ("ext2_free_inode: inode has no device\n");
  203.         return;
  204.     }
  205.     if (inode->i_count > 1) {
  206.         printk ("ext2_free_inode: inode has count=%d\n",
  207.             inode->i_count);
  208.         return;
  209.     }
  210.     if (inode->i_nlink) {
  211.         printk ("ext2_free_inode: inode has nlink=%d\n",
  212.             inode->i_nlink);
  213.         return;
  214.     }
  215.     if (!inode->i_sb) {
  216.         printk("ext2_free_inode: inode on nonexistent device\n");
  217.         return;
  218.     }
  219.  
  220.     ext2_debug ("freeing inode %lu\n", inode->i_ino);
  221.  
  222.     sb = inode->i_sb;
  223.     lock_super (sb);
  224.     if (inode->i_ino < EXT2_FIRST_INO ||
  225.         inode->i_ino > sb->u.ext2_sb.s_es->s_inodes_count) {
  226.         ext2_error (sb, "free_inode",
  227.                 "reserved inode or nonexistent inode");
  228.         unlock_super (sb);
  229.         return;
  230.     }
  231.     es = sb->u.ext2_sb.s_es;
  232.     block_group = (inode->i_ino - 1) / EXT2_INODES_PER_GROUP(sb);
  233.     bit = (inode->i_ino - 1) % EXT2_INODES_PER_GROUP(sb);
  234.     bitmap_nr = load_inode_bitmap (sb, block_group);
  235.     bh = sb->u.ext2_sb.s_inode_bitmap[bitmap_nr];
  236.     if (!clear_bit (bit, bh->b_data))
  237.         ext2_warning (sb, "ext2_free_inode",
  238.                   "bit already cleared for inode %lu", inode->i_ino);
  239.     else {
  240.         gdp = get_group_desc (sb, block_group, &bh2);
  241.         gdp->bg_free_inodes_count++;
  242.         if (S_ISDIR(inode->i_mode))
  243.             gdp->bg_used_dirs_count--;
  244.         mark_buffer_dirty(bh2, 1);
  245.         es->s_free_inodes_count++;
  246.         mark_buffer_dirty(sb->u.ext2_sb.s_sbh, 1);
  247.         set_inode_dtime (inode, gdp);
  248.     }
  249.     mark_buffer_dirty(bh, 1);
  250.     if (sb->s_flags & MS_SYNCHRONOUS) {
  251.         ll_rw_block (WRITE, 1, &bh);
  252.         wait_on_buffer (bh);
  253.     }
  254.  
  255.     sb->s_dirt = 1;
  256.     clear_inode (inode);
  257.     unlock_super (sb);
  258. }
  259.  
  260. /*
  261.  * This function increments the inode version number
  262.  *
  263.  * This may be used one day by the NFS server
  264.  */
  265. static void inc_inode_version (struct inode * inode,
  266.                    struct ext2_group_desc *gdp,
  267.                    int mode)
  268. {
  269.     unsigned long inode_block;
  270.     struct buffer_head * bh;
  271.     struct ext2_inode * raw_inode;
  272.  
  273.     inode_block = gdp->bg_inode_table + (((inode->i_ino - 1) %
  274.             EXT2_INODES_PER_GROUP(inode->i_sb)) /
  275.             EXT2_INODES_PER_BLOCK(inode->i_sb));
  276.     bh = bread (inode->i_sb->s_dev, inode_block, inode->i_sb->s_blocksize);
  277.     if (!bh) {
  278.         ext2_error (inode->i_sb, "inc_inode_version",
  279.                 "Cannot load inode table block - "
  280.                 "inode=%lu, inode_block=%lu\n",
  281.                 inode->i_ino, inode_block);
  282.         inode->u.ext2_i.i_version = 1;
  283.         return;
  284.     }
  285.     raw_inode = ((struct ext2_inode *) bh->b_data) +
  286.             (((inode->i_ino - 1) %
  287.             EXT2_INODES_PER_GROUP(inode->i_sb)) %
  288.             EXT2_INODES_PER_BLOCK(inode->i_sb));
  289.     raw_inode->i_version++;
  290.     inode->u.ext2_i.i_version = raw_inode->i_version;
  291.     mark_buffer_dirty(bh, 1);
  292.     brelse (bh);
  293. }
  294.  
  295. /*
  296.  * There are two policies for allocating an inode.  If the new inode is
  297.  * a directory, then a forward search is made for a block group with both
  298.  * free space and a low directory-to-inode ratio; if that fails, then of
  299.  * the groups with above-average free space, that group with the fewest
  300.  * directories already is chosen.
  301.  *
  302.  * For other inodes, search forward from the parent directory\'s block
  303.  * group to find a free inode.
  304.  */
  305. struct inode * ext2_new_inode (const struct inode * dir, int mode)
  306. {
  307.     struct super_block * sb;
  308.     struct buffer_head * bh;
  309.     struct buffer_head * bh2;
  310.     int i, j, avefreei;
  311.     struct inode * inode;
  312.     int bitmap_nr;
  313.     struct ext2_group_desc * gdp;
  314.     struct ext2_group_desc * tmp;
  315.     struct ext2_super_block * es;
  316.  
  317.     if (!dir || !(inode = get_empty_inode ()))
  318.         return NULL;
  319.     sb = dir->i_sb;
  320.     inode->i_sb = sb;
  321.     inode->i_flags = sb->s_flags;
  322.     lock_super (sb);
  323.     es = sb->u.ext2_sb.s_es;
  324. repeat:
  325.     gdp = NULL; i=0;
  326.     
  327.     if (S_ISDIR(mode)) {
  328.         avefreei = es->s_free_inodes_count /
  329.             sb->u.ext2_sb.s_groups_count;
  330. /* I am not yet convinced that this next bit is necessary.
  331.         i = dir->u.ext2_i.i_block_group;
  332.         for (j = 0; j < sb->u.ext2_sb.s_groups_count; j++) {
  333.             tmp = get_group_desc (sb, i, &bh2);
  334.             if ((tmp->bg_used_dirs_count << 8) < 
  335.                 tmp->bg_free_inodes_count) {
  336.                 gdp = tmp;
  337.                 break;
  338.             }
  339.             else
  340.             i = ++i % sb->u.ext2_sb.s_groups_count;
  341.         }
  342. */
  343.         if (!gdp) {
  344.             for (j = 0; j < sb->u.ext2_sb.s_groups_count; j++) {
  345.                 tmp = get_group_desc (sb, j, &bh2);
  346.                 if (tmp->bg_free_inodes_count &&
  347.                     tmp->bg_free_inodes_count >= avefreei) {
  348.                     if (!gdp || 
  349.                         (tmp->bg_free_blocks_count >
  350.                          gdp->bg_free_blocks_count)) {
  351.                         i = j;
  352.                         gdp = tmp;
  353.                     }
  354.                 }
  355.             }
  356.         }
  357.     }
  358.     else 
  359.     {
  360.         /*
  361.          * Try to place the inode in its parent directory
  362.          */
  363.         i = dir->u.ext2_i.i_block_group;
  364.         tmp = get_group_desc (sb, i, &bh2);
  365.         if (tmp->bg_free_inodes_count)
  366.             gdp = tmp;
  367.         else
  368.         {
  369.             /*
  370.              * Use a quadratic hash to find a group with a
  371.              * free inode
  372.              */
  373.             for (j = 1; j < sb->u.ext2_sb.s_groups_count; j <<= 1) {
  374.                 i += j;
  375.                 if (i >= sb->u.ext2_sb.s_groups_count)
  376.                     i -= sb->u.ext2_sb.s_groups_count;
  377.                 tmp = get_group_desc (sb, i, &bh2);
  378.                 if (tmp->bg_free_inodes_count) {
  379.                     gdp = tmp;
  380.                     break;
  381.                 }
  382.             }
  383.         }
  384.         if (!gdp) {
  385.             /*
  386.              * That failed: try linear search for a free inode
  387.              */
  388.             i = dir->u.ext2_i.i_block_group + 1;
  389.             for (j = 2; j < sb->u.ext2_sb.s_groups_count; j++) {
  390.                 if (++i >= sb->u.ext2_sb.s_groups_count)
  391.                     i = 0;
  392.                 tmp = get_group_desc (sb, i, &bh2);
  393.                 if (tmp->bg_free_inodes_count) {
  394.                     gdp = tmp;
  395.                     break;
  396.                 }
  397.             }
  398.         }
  399.     }
  400.  
  401.     if (!gdp) {
  402.         unlock_super (sb);
  403.         iput(inode);
  404.         return NULL;
  405.     }
  406.     bitmap_nr = load_inode_bitmap (sb, i);
  407.     bh = sb->u.ext2_sb.s_inode_bitmap[bitmap_nr];
  408.     if ((j = find_first_zero_bit ((unsigned long *) bh->b_data,
  409.                       EXT2_INODES_PER_GROUP(sb))) <
  410.         EXT2_INODES_PER_GROUP(sb)) {
  411.         if (set_bit (j, bh->b_data)) {
  412.             ext2_warning (sb, "ext2_new_inode",
  413.                       "bit already set for inode %d", j);
  414.             goto repeat;
  415.         }
  416.         mark_buffer_dirty(bh, 1);
  417.         if (sb->s_flags & MS_SYNCHRONOUS) {
  418.             ll_rw_block (WRITE, 1, &bh);
  419.             wait_on_buffer (bh);
  420.         }
  421.     } else {
  422.         if (gdp->bg_free_inodes_count != 0) {
  423.             ext2_error (sb, "ext2_new_inode",
  424.                     "Free inodes count corrupted in group %d",
  425.                     i);
  426.             unlock_super (sb);
  427.             iput (inode);
  428.             return NULL;
  429.         }
  430.         goto repeat;
  431.     }
  432.     j += i * EXT2_INODES_PER_GROUP(sb) + 1;
  433.     if (j < EXT2_FIRST_INO || j > es->s_inodes_count) {
  434.         ext2_error (sb, "ext2_new_inode",
  435.                 "reserved inode or inode > inodes count - "
  436.                 "block_group = %d,inode=%d", i, j);
  437.         unlock_super (sb);
  438.         iput (inode);
  439.         return NULL;
  440.     }
  441.     gdp->bg_free_inodes_count--;
  442.     if (S_ISDIR(mode))
  443.         gdp->bg_used_dirs_count++;
  444.     mark_buffer_dirty(bh2, 1);
  445.     es->s_free_inodes_count--;
  446.     mark_buffer_dirty(sb->u.ext2_sb.s_sbh, 1);
  447.     sb->s_dirt = 1;
  448.     inode->i_mode = mode;
  449.     inode->i_sb = sb;
  450.     inode->i_count = 1;
  451.     inode->i_nlink = 1;
  452.     inode->i_dev = sb->s_dev;
  453.     inode->i_uid = current->fsuid;
  454.     if (test_opt (sb, GRPID))
  455.         inode->i_gid = dir->i_gid;
  456.     else if (dir->i_mode & S_ISGID) {
  457.         inode->i_gid = dir->i_gid;
  458.         if (S_ISDIR(mode))
  459.             mode |= S_ISGID;
  460.     } else
  461.         inode->i_gid = current->fsgid;
  462.     inode->i_dirt = 1;
  463.     inode->i_ino = j;
  464.     inode->i_blksize = sb->s_blocksize;
  465.     inode->i_blocks = 0;
  466.     inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
  467.     inode->u.ext2_i.i_flags = dir->u.ext2_i.i_flags;
  468.     if (S_ISLNK(mode))
  469.         inode->u.ext2_i.i_flags &= ~(EXT2_IMMUTABLE_FL | EXT2_APPEND_FL);
  470.     inode->u.ext2_i.i_faddr = 0;
  471.     inode->u.ext2_i.i_frag_no = 0;
  472.     inode->u.ext2_i.i_frag_size = 0;
  473.     inode->u.ext2_i.i_file_acl = 0;
  474.     inode->u.ext2_i.i_dir_acl = 0;
  475.     inode->u.ext2_i.i_dtime = 0;
  476.     inode->u.ext2_i.i_block_group = i;
  477.     inode->i_op = NULL;
  478.     if (inode->u.ext2_i.i_flags & EXT2_SYNC_FL)
  479.         inode->i_flags |= MS_SYNCHRONOUS;
  480.     insert_inode_hash(inode);
  481.     inc_inode_version (inode, gdp, mode);
  482.  
  483.     ext2_debug ("allocating inode %lu\n", inode->i_ino);
  484.  
  485.     unlock_super (sb);
  486.     return inode;
  487. }
  488.  
  489. unsigned long ext2_count_free_inodes (struct super_block * sb)
  490. {
  491. #ifdef EXT2FS_DEBUG
  492.     struct ext2_super_block * es;
  493.     unsigned long desc_count, bitmap_count, x;
  494.     int bitmap_nr;
  495.     struct ext2_group_desc * gdp;
  496.     int i;
  497.  
  498.     lock_super (sb);
  499.     es = sb->u.ext2_sb.s_es;
  500.     desc_count = 0;
  501.     bitmap_count = 0;
  502.     gdp = NULL;
  503.     for (i = 0; i < sb->u.ext2_sb.s_groups_count; i++) {
  504.         gdp = get_group_desc (sb, i, NULL);
  505.         desc_count += gdp->bg_free_inodes_count;
  506.         bitmap_nr = load_inode_bitmap (sb, i);
  507.         x = ext2_count_free (sb->u.ext2_sb.s_inode_bitmap[bitmap_nr],
  508.                      EXT2_INODES_PER_GROUP(sb) / 8);
  509.         printk ("group %d: stored = %d, counted = %lu\n",
  510.             i, gdp->bg_free_inodes_count, x);
  511.         bitmap_count += x;
  512.     }
  513.     printk("ext2_count_free_inodes: stored = %lu, computed = %lu, %lu\n",
  514.         es->s_free_inodes_count, desc_count, bitmap_count);
  515.     unlock_super (sb);
  516.     return desc_count;
  517. #else
  518.     return sb->u.ext2_sb.s_es->s_free_inodes_count;
  519. #endif
  520. }
  521.  
  522. void ext2_check_inodes_bitmap (struct super_block * sb)
  523. {
  524.     struct ext2_super_block * es;
  525.     unsigned long desc_count, bitmap_count, x;
  526.     int bitmap_nr;
  527.     struct ext2_group_desc * gdp;
  528.     int i;
  529.  
  530.     lock_super (sb);
  531.     es = sb->u.ext2_sb.s_es;
  532.     desc_count = 0;
  533.     bitmap_count = 0;
  534.     gdp = NULL;
  535.     for (i = 0; i < sb->u.ext2_sb.s_groups_count; i++) {
  536.         gdp = get_group_desc (sb, i, NULL);
  537.         desc_count += gdp->bg_free_inodes_count;
  538.         bitmap_nr = load_inode_bitmap (sb, i);
  539.         x = ext2_count_free (sb->u.ext2_sb.s_inode_bitmap[bitmap_nr],
  540.                      EXT2_INODES_PER_GROUP(sb) / 8);
  541.         if (gdp->bg_free_inodes_count != x)
  542.             ext2_error (sb, "ext2_check_inodes_bitmap",
  543.                     "Wrong free inodes count in group %d, "
  544.                     "stored = %d, counted = %lu", i,
  545.                     gdp->bg_free_inodes_count, x);
  546.         bitmap_count += x;
  547.     }
  548.     if (es->s_free_inodes_count != bitmap_count)
  549.         ext2_error (sb, "ext2_check_inodes_bitmap",
  550.                 "Wrong free inodes count in super block, "
  551.                 "stored = %lu, counted = %lu",
  552.                 (unsigned long) es->s_free_inodes_count, bitmap_count);
  553.     unlock_super (sb);
  554. }
  555.