| 1 | |
| 2 | * linux/fs/ext3/ialloc.c
|
| 3 | *
|
| 4 | * Copyright (C) 1992, 1993, 1994, 1995
|
| 5 | * Remy Card ([email protected])
|
| 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 ([email protected]), 1993
|
| 11 | * Big-endian to little-endian byte-swapping/bitmaps by
|
| 12 | * David S. Miller ([email protected]), 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 | |
| 123 | * Note: we must free any quota before locking the superblock,
|
| 124 | * as writing the quota to disk may need the lock as well.
|
| 125 |
|
| 126 | DQUOT_INIT(inode);
|
| 127 | ext3_xattr_delete_inode(handle, inode);
|
| 128 | DQUOT_FREE_INODE(inode);
|
| 129 | DQUOT_DROP(inode);
|
| 130 |
|
| 131 | is_directory = S_ISDIR(inode->i_mode);
|
| 132 |
|
| 133 |
|
| 134 | clear_inode (inode);
|
| 135 |
|
| 136 | es = EXT3_SB(sb)->s_es;
|
| 137 | if (ino < EXT3_FIRST_INO(sb) || ino > le32_to_cpu(es->s_inodes_count)) {
|
| 138 | ext3_error (sb, "ext3_free_inode",
|
| 139 | "reserved or nonexistent inode %lu", ino);
|
| 140 | goto error_return;
|
| 141 | }
|
| 142 | block_group = (ino - 1) / EXT3_INODES_PER_GROUP(sb);
|
| 143 | bit = (ino - 1) % EXT3_INODES_PER_GROUP(sb);
|
| 144 | bitmap_bh = read_inode_bitmap(sb, block_group);
|
| 145 | if (!bitmap_bh)
|
| 146 | goto error_return;
|
| 147 |
|
| 148 | BUFFER_TRACE(bitmap_bh, "get_write_access");
|
| 149 | fatal = ext3_journal_get_write_access(handle, bitmap_bh);
|
| 150 | if (fatal)
|
| 151 | goto error_return;
|
| 152 |
|
| 153 |
|
| 154 | if (!ext3_clear_bit_atomic(sb_bgl_lock(sbi, block_group),
|
| 155 | bit, bitmap_bh->b_data))
|
| 156 | ext3_error (sb, "ext3_free_inode",
|
| 157 | "bit already cleared for inode %lu", ino);
|
| 158 | else {
|
| 159 | gdp = ext3_get_group_desc (sb, block_group, &bh2);
|
| 160 |
|
| 161 | BUFFER_TRACE(bh2, "get_write_access");
|
| 162 | fatal = ext3_journal_get_write_access(handle, bh2);
|
| 163 | if (fatal) goto error_return;
|
| 164 |
|
| 165 | if (gdp) {
|
| 166 | spin_lock(sb_bgl_lock(sbi, block_group));
|
| 167 | gdp->bg_free_inodes_count = cpu_to_le16(
|
| 168 | le16_to_cpu(gdp->bg_free_inodes_count) + 1);
|
| 169 | if (is_directory)
|
| 170 | gdp->bg_used_dirs_count = cpu_to_le16(
|
| 171 | le16_to_cpu(gdp->bg_used_dirs_count) - 1);
|
| 172 | spin_unlock(sb_bgl_lock(sbi, block_group));
|
| 173 | percpu_counter_inc(&sbi->s_freeinodes_counter);
|
| 174 | if (is_directory)
|
| 175 | percpu_counter_dec(&sbi->s_dirs_counter);
|
| 176 |
|
| 177 | }
|
| 178 | BUFFER_TRACE(bh2, "call ext3_journal_dirty_metadata");
|
| 179 | err = ext3_journal_dirty_metadata(handle, bh2);
|
| 180 | if (!fatal) fatal = err;
|
| 181 | }
|
| 182 | BUFFER_TRACE(bitmap_bh, "call ext3_journal_dirty_metadata");
|
| 183 | err = ext3_journal_dirty_metadata(handle, bitmap_bh);
|
| 184 | if (!fatal)
|
| 185 | fatal = err;
|
| 186 | sb->s_dirt = 1;
|
| 187 | error_return:
|
| 188 | brelse(bitmap_bh);
|
| 189 | ext3_std_error(sb, fatal);
|
| 190 | }
|
| 191 |
|
| 192 | |
| 193 | * There are two policies for allocating an inode. If the new inode is
|
| 194 | * a directory, then a forward search is made for a block group with both
|
| 195 | * free space and a low directory-to-inode ratio; if that fails, then of
|
| 196 | * the groups with above-average free space, that group with the fewest
|
| 197 | * directories already is chosen.
|
| 198 | *
|
| 199 | * For other inodes, search forward from the parent directory\'s block
|
| 200 | * group to find a free inode.
|
| 201 |
|
| 202 | static int find_group_dir(struct super_block *sb, struct inode *parent)
|
| 203 | {
|
| 204 | int ngroups = EXT3_SB(sb)->s_groups_count;
|
| 205 | unsigned int freei, avefreei;
|
| 206 | struct ext3_group_desc *desc, *best_desc = NULL;
|
| 207 | struct buffer_head *bh;
|
| 208 | int group, best_group = -1;
|
| 209 |
|
| 210 | freei = percpu_counter_read_positive(&EXT3_SB(sb)->s_freeinodes_counter);
|
| 211 | avefreei = freei / ngroups;
|
| 212 |
|
| 213 | for (group = 0; group < ngroups; group++) {
|
| 214 | desc = ext3_get_group_desc (sb, group, &bh);
|
| 215 | if (!desc || !desc->bg_free_inodes_count)
|
| 216 | continue;
|
| 217 | if (le16_to_cpu(desc->bg_free_inodes_count) < avefreei)
|
| 218 | continue;
|
| 219 | if (!best_desc ||
|
| 220 | (le16_to_cpu(desc->bg_free_blocks_count) >
|
| 221 | le16_to_cpu(best_desc->bg_free_blocks_count))) {
|
| 222 | best_group = group;
|
| 223 | best_desc = desc;
|
| 224 | }
|
| 225 | }
|
| 226 | return best_group;
|
| 227 | }
|
| 228 |
|
| 229 | |
| 230 | * Orlov's allocator for directories.
|
| 231 | *
|
| 232 | * We always try to spread first-level directories.
|
| 233 | *
|
| 234 | * If there are blockgroups with both free inodes and free blocks counts
|
| 235 | * not worse than average we return one with smallest directory count.
|
| 236 | * Otherwise we simply return a random group.
|
| 237 | *
|
| 238 | * For the rest rules look so:
|
| 239 | *
|
| 240 | * It's OK to put directory into a group unless
|
| 241 | * it has too many directories already (max_dirs) or
|
| 242 | * it has too few free inodes left (min_inodes) or
|
| 243 | * it has too few free blocks left (min_blocks) or
|
| 244 | * it's already running too large debt (max_debt).
|
| 245 | * Parent's group is prefered, if it doesn't satisfy these
|
| 246 | * conditions we search cyclically through the rest. If none
|
| 247 | * of the groups look good we just look for a group with more
|
| 248 | * free inodes than average (starting at parent's group).
|
| 249 | *
|
| 250 | * Debt is incremented each time we allocate a directory and decremented
|
| 251 | * when we allocate an inode, within 0--255.
|
| 252 |
|
| 253 |
|
| 254 | #define INODE_COST 64
|
| 255 | #define BLOCK_COST 256
|
| 256 |
|
| 257 | static int find_group_orlov(struct super_block *sb, struct inode *parent)
|
| 258 | {
|
| 259 | int parent_group = EXT3_I(parent)->i_block_group;
|
| 260 | struct ext3_sb_info *sbi = EXT3_SB(sb);
|
| 261 | struct ext3_super_block *es = sbi->s_es;
|
| 262 | int ngroups = sbi->s_groups_count;
|
| 263 | int inodes_per_group = EXT3_INODES_PER_GROUP(sb);
|
| 264 | unsigned int freei, avefreei;
|
| 265 | ext3_fsblk_t freeb, avefreeb;
|
| 266 | ext3_fsblk_t blocks_per_dir;
|
| 267 | unsigned int ndirs;
|
| 268 | int max_debt, max_dirs, min_inodes;
|
| 269 | ext3_grpblk_t min_blocks;
|
| 270 | int group = -1, i;
|
| 271 | struct ext3_group_desc *desc;
|
| 272 | struct buffer_head *bh;
|
| 273 |
|
| 274 | freei = percpu_counter_read_positive(&sbi->s_freeinodes_counter);
|
| 275 | avefreei = freei / ngroups;
|
| 276 | freeb = percpu_counter_read_positive(&sbi->s_freeblocks_counter);
|
| 277 | avefreeb = freeb / ngroups;
|
| 278 | ndirs = percpu_counter_read_positive(&sbi->s_dirs_counter);
|
| 279 |
|
| 280 | if ((parent == sb->s_root->d_inode) ||
|
| 281 | (EXT3_I(parent)->i_flags & EXT3_TOPDIR_FL)) {
|
| 282 | int best_ndir = inodes_per_group;
|
| 283 | int best_group = -1;
|
| 284 |
|
| 285 | get_random_bytes(&group, sizeof(group));
|
| 286 | parent_group = (unsigned)group % ngroups;
|
| 287 | for (i = 0; i < ngroups; i++) {
|
| 288 | group = (parent_group + i) % ngroups;
|
| 289 | desc = ext3_get_group_desc (sb, group, &bh);
|
| 290 | if (!desc || !desc->bg_free_inodes_count)
|
| 291 | continue;
|
| 292 | if (le16_to_cpu(desc->bg_used_dirs_count) >= best_ndir)
|
| 293 | continue;
|
| 294 | if (le16_to_cpu(desc->bg_free_inodes_count) < avefreei)
|
| 295 | continue;
|
| 296 | if (le16_to_cpu(desc->bg_free_blocks_count) < avefreeb)
|
| 297 | continue;
|
| 298 | best_group = group;
|
| 299 | best_ndir = le16_to_cpu(desc->bg_used_dirs_count);
|
| 300 | }
|
| 301 | if (best_group >= 0)
|
| 302 | return best_group;
|
| 303 | goto fallback;
|
| 304 | }
|
| 305 |
|
| 306 | blocks_per_dir = (le32_to_cpu(es->s_blocks_count) - freeb) / ndirs;
|
| 307 |
|
| 308 | max_dirs = ndirs / ngroups + inodes_per_group / 16;
|
| 309 | min_inodes = avefreei - inodes_per_group / 4;
|
| 310 | min_blocks = avefreeb - EXT3_BLOCKS_PER_GROUP(sb) / 4;
|
| 311 |
|
| 312 | max_debt = EXT3_BLOCKS_PER_GROUP(sb) / max(blocks_per_dir, (ext3_fsblk_t)BLOCK_COST);
|
| 313 | if (max_debt * INODE_COST > inodes_per_group)
|
| 314 | max_debt = inodes_per_group / INODE_COST;
|
| 315 | if (max_debt > 255)
|
| 316 | max_debt = 255;
|
| 317 | if (max_debt == 0)
|
| 318 | max_debt = 1;
|
| 319 |
|
| 320 | for (i = 0; i < ngroups; i++) {
|
| 321 | group = (parent_group + i) % ngroups;
|
| 322 | desc = ext3_get_group_desc (sb, group, &bh);
|
| 323 | if (!desc || !desc->bg_free_inodes_count)
|
| 324 | continue;
|
| 325 | if (le16_to_cpu(desc->bg_used_dirs_count) >= max_dirs)
|
| 326 | continue;
|
| 327 | if (le16_to_cpu(desc->bg_free_inodes_count) < min_inodes)
|
| 328 | continue;
|
| 329 | if (le16_to_cpu(desc->bg_free_blocks_count) < min_blocks)
|
| 330 | continue;
|
| 331 | return group;
|
| 332 | }
|
| 333 |
|
| 334 | fallback:
|
| 335 | for (i = 0; i < ngroups; i++) {
|
| 336 | group = (parent_group + i) % ngroups;
|
| 337 | desc = ext3_get_group_desc (sb, group, &bh);
|
| 338 | if (!desc || !desc->bg_free_inodes_count)
|
| 339 | continue;
|
| 340 | if (le16_to_cpu(desc->bg_free_inodes_count) >= avefreei)
|
| 341 | return group;
|
| 342 | }
|
| 343 |
|
| 344 | if (avefreei) {
|
| 345 | |
| 346 | * The free-inodes counter is approximate, and for really small
|
| 347 | * filesystems the above test can fail to find any blockgroups
|
| 348 |
|
| 349 | avefreei = 0;
|
| 350 | goto fallback;
|
| 351 | }
|
| 352 |
|
| 353 | return -1;
|
| 354 | }
|
| 355 |
|
| 356 | static int find_group_other(struct super_block *sb, struct inode *parent)
|
| 357 | {
|
| 358 | int parent_group = EXT3_I(parent)->i_block_group;
|
| 359 | int ngroups = EXT3_SB(sb)->s_groups_count;
|
| 360 | struct ext3_group_desc *desc;
|
| 361 | struct buffer_head *bh;
|
| 362 | int group, i;
|
| 363 |
|
| 364 | |
| 365 | * Try to place the inode in its parent directory
|
| 366 |
|
| 367 | group = parent_group;
|
| 368 | desc = ext3_get_group_desc (sb, group, &bh);
|
| 369 | if (desc && le16_to_cpu(desc->bg_free_inodes_count) &&
|
| 370 | le16_to_cpu(desc->bg_free_blocks_count))
|
| 371 | return group;
|
| 372 |
|
| 373 | |
| 374 | * We're going to place this inode in a different blockgroup from its
|
| 375 | * parent. We want to cause files in a common directory to all land in
|
| 376 | * the same blockgroup. But we want files which are in a different
|
| 377 | * directory which shares a blockgroup with our parent to land in a
|
| 378 | * different blockgroup.
|
| 379 | *
|
| 380 | * So add our directory's i_ino into the starting point for the hash.
|
| 381 |
|
| 382 | group = (group + parent->i_ino) % ngroups;
|
| 383 |
|
| 384 | |
| 385 | * Use a quadratic hash to find a group with a free inode and some free
|
| 386 | * blocks.
|
| 387 |
|
| 388 | for (i = 1; i < ngroups; i <<= 1) {
|
| 389 | group += i;
|
| 390 | if (group >= ngroups)
|
| 391 | group -= ngroups;
|
| 392 | desc = ext3_get_group_desc (sb, group, &bh);
|
| 393 | if (desc && le16_to_cpu(desc->bg_free_inodes_count) &&
|
| 394 | le16_to_cpu(desc->bg_free_blocks_count))
|
| 395 | return group;
|
| 396 | }
|
| 397 |
|
| 398 | |
| 399 | * That failed: try linear search for a free inode, even if that group
|
| 400 | * has no free blocks.
|
| 401 |
|
| 402 | group = parent_group;
|
| 403 | for (i = 0; i < ngroups; i++) {
|
| 404 | if (++group >= ngroups)
|
| 405 | group = 0;
|
| 406 | desc = ext3_get_group_desc (sb, group, &bh);
|
| 407 | if (desc && le16_to_cpu(desc->bg_free_inodes_count))
|
| 408 | return group;
|
| 409 | }
|
| 410 |
|
| 411 | return -1;
|
| 412 | }
|
| 413 |
|
| 414 | |
| 415 | * There are two policies for allocating an inode. If the new inode is
|
| 416 | * a directory, then a forward search is made for a block group with both
|
| 417 | * free space and a low directory-to-inode ratio; if that fails, then of
|
| 418 | * the groups with above-average free space, that group with the fewest
|
| 419 | * directories already is chosen.
|
| 420 | *
|
| 421 | * For other inodes, search forward from the parent directory's block
|
| 422 | * group to find a free inode.
|
| 423 |
|
| 424 | struct inode *ext3_new_inode(handle_t *handle, struct inode * dir, int mode)
|
| 425 | {
|
| 426 | struct super_block *sb;
|
| 427 | struct buffer_head *bitmap_bh = NULL;
|
| 428 | struct buffer_head *bh2;
|
| 429 | int group;
|
| 430 | unsigned long ino = 0;
|
| 431 | struct inode * inode;
|
| 432 | struct ext3_group_desc * gdp = NULL;
|
| 433 | struct ext3_super_block * es;
|
| 434 | struct ext3_inode_info *ei;
|
| 435 | struct ext3_sb_info *sbi;
|
| 436 | int err = 0;
|
| 437 | struct inode *ret;
|
| 438 | int i;
|
| 439 |
|
| 440 |
|
| 441 | if (!dir || !dir->i_nlink)
|
| 442 | return ERR_PTR(-EPERM);
|
| 443 |
|
| 444 | sb = dir->i_sb;
|
| 445 | inode = new_inode(sb);
|
| 446 | if (!inode)
|
| 447 | return ERR_PTR(-ENOMEM);
|
| 448 | ei = EXT3_I(inode);
|
| 449 |
|
| 450 | sbi = EXT3_SB(sb);
|
| 451 | es = sbi->s_es;
|
| 452 | if (S_ISDIR(mode)) {
|
| 453 | if (test_opt (sb, OLDALLOC))
|
| 454 | group = find_group_dir(sb, dir);
|
| 455 | else
|
| 456 | group = find_group_orlov(sb, dir);
|
| 457 | } else
|
| 458 | group = find_group_other(sb, dir);
|
| 459 |
|
| 460 | err = -ENOSPC;
|
| 461 | if (group == -1)
|
| 462 | goto out;
|
| 463 |
|
| 464 | for (i = 0; i < sbi->s_groups_count; i++) {
|
| 465 | err = -EIO;
|
| 466 |
|
| 467 | gdp = ext3_get_group_desc(sb, group, &bh2);
|
| 468 | if (!gdp)
|
| 469 | goto fail;
|
| 470 |
|
| 471 | brelse(bitmap_bh);
|
| 472 | bitmap_bh = read_inode_bitmap(sb, group);
|
| 473 | if (!bitmap_bh)
|
| 474 | goto fail;
|
| 475 |
|
| 476 | ino = 0;
|
| 477 |
|
| 478 | repeat_in_this_group:
|
| 479 | ino = ext3_find_next_zero_bit((unsigned long *)
|
| 480 | bitmap_bh->b_data, EXT3_INODES_PER_GROUP(sb), ino);
|
| 481 | if (ino < EXT3_INODES_PER_GROUP(sb)) {
|
| 482 |
|
| 483 | BUFFER_TRACE(bitmap_bh, "get_write_access");
|
| 484 | err = ext3_journal_get_write_access(handle, bitmap_bh);
|
| 485 | if (err)
|
| 486 | goto fail;
|
| 487 |
|
| 488 | if (!ext3_set_bit_atomic(sb_bgl_lock(sbi, group),
|
| 489 | ino, bitmap_bh->b_data)) {
|
| 490 |
|
| 491 | BUFFER_TRACE(bitmap_bh,
|
| 492 | "call ext3_journal_dirty_metadata");
|
| 493 | err = ext3_journal_dirty_metadata(handle,
|
| 494 | bitmap_bh);
|
| 495 | if (err)
|
| 496 | goto fail;
|
| 497 | goto got;
|
| 498 | }
|
| 499 |
|
| 500 | journal_release_buffer(handle, bitmap_bh);
|
| 501 |
|
| 502 | if (++ino < EXT3_INODES_PER_GROUP(sb))
|
| 503 | goto repeat_in_this_group;
|
| 504 | }
|
| 505 |
|
| 506 | |
| 507 | * This case is possible in concurrent environment. It is very
|
| 508 | * rare. We cannot repeat the find_group_xxx() call because
|
| 509 | * that will simply return the same blockgroup, because the
|
| 510 | * group descriptor metadata has not yet been updated.
|
| 511 | * So we just go onto the next blockgroup.
|
| 512 |
|
| 513 | if (++group == sbi->s_groups_count)
|
| 514 | group = 0;
|
| 515 | }
|
| 516 | err = -ENOSPC;
|
| 517 | goto out;
|
| 518 |
|
| 519 | got:
|
| 520 | ino += group * EXT3_INODES_PER_GROUP(sb) + 1;
|
| 521 | if (ino < EXT3_FIRST_INO(sb) || ino > le32_to_cpu(es->s_inodes_count)) {
|
| 522 | ext3_error (sb, "ext3_new_inode",
|
| 523 | "reserved inode or inode > inodes count - "
|
| 524 | "block_group = %d, inode=%lu", group, ino);
|
| 525 | err = -EIO;
|
| 526 | goto fail;
|
| 527 | }
|
| 528 |
|
| 529 | BUFFER_TRACE(bh2, "get_write_access");
|
| 530 | err = ext3_journal_get_write_access(handle, bh2);
|
| 531 | if (err) goto fail;
|
| 532 | spin_lock(sb_bgl_lock(sbi, group));
|
| 533 | gdp->bg_free_inodes_count =
|
| 534 | cpu_to_le16(le16_to_cpu(gdp->bg_free_inodes_count) - 1);
|
| 535 | if (S_ISDIR(mode)) {
|
| 536 | gdp->bg_used_dirs_count =
|
| 537 | cpu_to_le16(le16_to_cpu(gdp->bg_used_dirs_count) + 1);
|
| 538 | }
|
| 539 | spin_unlock(sb_bgl_lock(sbi, group));
|
| 540 | BUFFER_TRACE(bh2, "call ext3_journal_dirty_metadata");
|
| 541 | err = ext3_journal_dirty_metadata(handle, bh2);
|
| 542 | if (err) goto fail;
|
| 543 |
|
| 544 | percpu_counter_dec(&sbi->s_freeinodes_counter);
|
| 545 | if (S_ISDIR(mode))
|
| 546 | percpu_counter_inc(&sbi->s_dirs_counter);
|
| 547 | sb->s_dirt = 1;
|
| 548 |
|
| 549 | inode->i_uid = current->fsuid;
|
| 550 | if (test_opt (sb, GRPID))
|
| 551 | inode->i_gid = dir->i_gid;
|
| 552 | else if (dir->i_mode & S_ISGID) {
|
| 553 | inode->i_gid = dir->i_gid;
|
| 554 | if (S_ISDIR(mode))
|
| 555 | mode |= S_ISGID;
|
| 556 | } else
|
| 557 | inode->i_gid = current->fsgid;
|
| 558 | inode->i_mode = mode;
|
| 559 |
|
| 560 | inode->i_ino = ino;
|
| 561 |
|
| 562 | inode->i_blocks = 0;
|
| 563 | inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME_SEC;
|
| 564 |
|
| 565 | memset(ei->i_data, 0, sizeof(ei->i_data));
|
| 566 | ei->i_dir_start_lookup = 0;
|
| 567 | ei->i_disksize = 0;
|
| 568 |
|
| 569 | ei->i_flags = EXT3_I(dir)->i_flags & ~EXT3_INDEX_FL;
|
| 570 | if (S_ISLNK(mode))
|
| 571 | ei->i_flags &= ~(EXT3_IMMUTABLE_FL|EXT3_APPEND_FL);
|
| 572 |
|
| 573 | if (!S_ISDIR(mode))
|
| 574 | ei->i_flags &= ~EXT3_DIRSYNC_FL;
|
| 575 | #ifdef EXT3_FRAGMENTS
|
| 576 | ei->i_faddr = 0;
|
| 577 | ei->i_frag_no = 0;
|
| 578 | ei->i_frag_size = 0;
|
| 579 | #endif
|
| 580 | ei->i_file_acl = 0;
|
| 581 | ei->i_dir_acl = 0;
|
| 582 | ei->i_dtime = 0;
|
| 583 | ei->i_block_alloc_info = NULL;
|
| 584 | ei->i_block_group = group;
|
| 585 |
|
| 586 | ext3_set_inode_flags(inode);
|
| 587 | if (IS_DIRSYNC(inode))
|
| 588 | handle->h_sync = 1;
|
| 589 | insert_inode_hash(inode);
|
| 590 | spin_lock(&sbi->s_next_gen_lock);
|
| 591 | inode->i_generation = sbi->s_next_generation++;
|
| 592 | spin_unlock(&sbi->s_next_gen_lock);
|
| 593 |
|
| 594 | ei->i_state = EXT3_STATE_NEW;
|
| 595 | ei->i_extra_isize =
|
| 596 | (EXT3_INODE_SIZE(inode->i_sb) > EXT3_GOOD_OLD_INODE_SIZE) ?
|
| 597 | sizeof(struct ext3_inode) - EXT3_GOOD_OLD_INODE_SIZE : 0;
|
| 598 |
|
| 599 | ret = inode;
|
| 600 | if(DQUOT_ALLOC_INODE(inode)) {
|
| 601 | err = -EDQUOT;
|
| 602 | goto fail_drop;
|
| 603 | }
|
| 604 |
|
| 605 | err = ext3_init_acl(handle, inode, dir);
|
| 606 | if (err)
|
| 607 | goto fail_free_drop;
|
| 608 |
|
| 609 | err = ext3_init_security(handle,inode, dir);
|
| 610 | if (err)
|
| 611 | goto fail_free_drop;
|
| 612 |
|
| 613 | err = ext3_mark_inode_dirty(handle, inode);
|
| 614 | if (err) {
|
| 615 | ext3_std_error(sb, err);
|
| 616 | goto fail_free_drop;
|
| 617 | }
|
| 618 |
|
| 619 | ext3_debug("allocating inode %lu\n", inode->i_ino);
|
| 620 | goto really_out;
|
| 621 | fail:
|
| 622 | ext3_std_error(sb, err);
|
| 623 | out:
|
| 624 | iput(inode);
|
| 625 | ret = ERR_PTR(err);
|
| 626 | really_out:
|
| 627 | brelse(bitmap_bh);
|
| 628 | return ret;
|
| 629 |
|
| 630 | fail_free_drop:
|
| 631 | DQUOT_FREE_INODE(inode);
|
| 632 |
|
| 633 | fail_drop:
|
| 634 | DQUOT_DROP(inode);
|
| 635 | inode->i_flags |= S_NOQUOTA;
|
| 636 | inode->i_nlink = 0;
|
| 637 | iput(inode);
|
| 638 | brelse(bitmap_bh);
|
| 639 | return ERR_PTR(err);
|
| 640 | }
|
| 641 |
|
| 642 |
|
| 643 | struct inode *ext3_orphan_get(struct super_block *sb, unsigned long ino)
|
| 644 | {
|
| 645 | unsigned long max_ino = le32_to_cpu(EXT3_SB(sb)->s_es->s_inodes_count);
|
| 646 | unsigned long block_group;
|
| 647 | int bit;
|
| 648 | struct buffer_head *bitmap_bh = NULL;
|
| 649 | struct inode *inode = NULL;
|
| 650 |
|
| 651 |
|
| 652 | if (ino > max_ino) {
|
| 653 | ext3_warning(sb, __FUNCTION__,
|
| 654 | "bad orphan ino %lu! e2fsck was run?", ino);
|
| 655 | goto out;
|
| 656 | }
|
| 657 |
|
| 658 | block_group = (ino - 1) / EXT3_INODES_PER_GROUP(sb);
|
| 659 | bit = (ino - 1) % EXT3_INODES_PER_GROUP(sb);
|
| 660 | bitmap_bh = read_inode_bitmap(sb, block_group);
|
| 661 | if (!bitmap_bh) {
|
| 662 | ext3_warning(sb, __FUNCTION__,
|
| 663 | "inode bitmap error for orphan %lu", ino);
|
| 664 | goto out;
|
| 665 | }
|
| 666 |
|
| 667 | |
| 668 | * is a valid orphan (no e2fsck run on fs). Orphans also include
|
| 669 | * inodes that were being truncated, so we can't check i_nlink==0.
|
| 670 |
|
| 671 | if (!ext3_test_bit(bit, bitmap_bh->b_data) ||
|
| 672 | !(inode = iget(sb, ino)) || is_bad_inode(inode) ||
|
| 673 | NEXT_ORPHAN(inode) > max_ino) {
|
| 674 | ext3_warning(sb, __FUNCTION__,
|
| 675 | "bad orphan inode %lu! e2fsck was run?", ino);
|
| 676 | printk(KERN_NOTICE "ext3_test_bit(bit=%d, block=%llu) = %d\n",
|
| 677 | bit, (unsigned long long)bitmap_bh->b_blocknr,
|
| 678 | ext3_test_bit(bit, bitmap_bh->b_data));
|
| 679 | printk(KERN_NOTICE "inode=%p\n", inode);
|
| 680 | if (inode) {
|
| 681 | printk(KERN_NOTICE "is_bad_inode(inode)=%d\n",
|
| 682 | is_bad_inode(inode));
|
| 683 | printk(KERN_NOTICE "NEXT_ORPHAN(inode)=%u\n",
|
| 684 | NEXT_ORPHAN(inode));
|
| 685 | printk(KERN_NOTICE "max_ino=%lu\n", max_ino);
|
| 686 | }
|
| 687 |
|
| 688 | if (inode && inode->i_nlink == 0)
|
| 689 | inode->i_blocks = 0;
|
| 690 | iput(inode);
|
| 691 | inode = NULL;
|
| 692 | }
|
| 693 | out:
|
| 694 | brelse(bitmap_bh);
|
| 695 | return inode;
|
| 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 |
|
| 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 |
|