| 1 | |
| 2 | * linux/fs/ext4/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/jbd2.h>
|
| 18 | #include <linux/ext4_fs.h>
|
| 19 | #include <linux/ext4_jbd2.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 | #include <linux/blkdev.h>
|
| 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 ext4_group_desc *desc;
|
| 57 | struct buffer_head *bh = NULL;
|
| 58 |
|
| 59 | desc = ext4_get_group_desc(sb, block_group, NULL);
|
| 60 | if (!desc)
|
| 61 | goto error_out;
|
| 62 |
|
| 63 | bh = sb_bread(sb, ext4_inode_bitmap(sb, desc));
|
| 64 | if (!bh)
|
| 65 | ext4_error(sb, "read_inode_bitmap",
|
| 66 | "Cannot read inode bitmap - "
|
| 67 | "block_group = %lu, inode_bitmap = %llu",
|
| 68 | block_group, ext4_inode_bitmap(sb, desc));
|
| 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 ext4_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 ext4_group_desc * gdp;
|
| 99 | struct ext4_super_block * es;
|
| 100 | struct ext4_sb_info *sbi;
|
| 101 | int fatal = 0, err;
|
| 102 |
|
| 103 | if (atomic_read(&inode->i_count) > 1) {
|
| 104 | printk ("ext4_free_inode: inode has count=%d\n",
|
| 105 | atomic_read(&inode->i_count));
|
| 106 | return;
|
| 107 | }
|
| 108 | if (inode->i_nlink) {
|
| 109 | printk ("ext4_free_inode: inode has nlink=%d\n",
|
| 110 | inode->i_nlink);
|
| 111 | return;
|
| 112 | }
|
| 113 | if (!sb) {
|
| 114 | printk("ext4_free_inode: inode on nonexistent device\n");
|
| 115 | return;
|
| 116 | }
|
| 117 | sbi = EXT4_SB(sb);
|
| 118 |
|
| 119 | ino = inode->i_ino;
|
| 120 | ext4_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 | ext4_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 = EXT4_SB(sb)->s_es;
|
| 137 | if (ino < EXT4_FIRST_INO(sb) || ino > le32_to_cpu(es->s_inodes_count)) {
|
| 138 | ext4_error (sb, "ext4_free_inode",
|
| 139 | "reserved or nonexistent inode %lu", ino);
|
| 140 | goto error_return;
|
| 141 | }
|
| 142 | block_group = (ino - 1) / EXT4_INODES_PER_GROUP(sb);
|
| 143 | bit = (ino - 1) % EXT4_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 = ext4_journal_get_write_access(handle, bitmap_bh);
|
| 150 | if (fatal)
|
| 151 | goto error_return;
|
| 152 |
|
| 153 |
|
| 154 | if (!ext4_clear_bit_atomic(sb_bgl_lock(sbi, block_group),
|
| 155 | bit, bitmap_bh->b_data))
|
| 156 | ext4_error (sb, "ext4_free_inode",
|
| 157 | "bit already cleared for inode %lu", ino);
|
| 158 | else {
|
| 159 | gdp = ext4_get_group_desc (sb, block_group, &bh2);
|
| 160 |
|
| 161 | BUFFER_TRACE(bh2, "get_write_access");
|
| 162 | fatal = ext4_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 ext4_journal_dirty_metadata");
|
| 179 | err = ext4_journal_dirty_metadata(handle, bh2);
|
| 180 | if (!fatal) fatal = err;
|
| 181 | }
|
| 182 | BUFFER_TRACE(bitmap_bh, "call ext4_journal_dirty_metadata");
|
| 183 | err = ext4_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 | ext4_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 = EXT4_SB(sb)->s_groups_count;
|
| 205 | unsigned int freei, avefreei;
|
| 206 | struct ext4_group_desc *desc, *best_desc = NULL;
|
| 207 | struct buffer_head *bh;
|
| 208 | int group, best_group = -1;
|
| 209 |
|
| 210 | freei = percpu_counter_read_positive(&EXT4_SB(sb)->s_freeinodes_counter);
|
| 211 | avefreei = freei / ngroups;
|
| 212 |
|
| 213 | for (group = 0; group < ngroups; group++) {
|
| 214 | desc = ext4_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 = EXT4_I(parent)->i_block_group;
|
| 260 | struct ext4_sb_info *sbi = EXT4_SB(sb);
|
| 261 | struct ext4_super_block *es = sbi->s_es;
|
| 262 | int ngroups = sbi->s_groups_count;
|
| 263 | int inodes_per_group = EXT4_INODES_PER_GROUP(sb);
|
| 264 | unsigned int freei, avefreei;
|
| 265 | ext4_fsblk_t freeb, avefreeb;
|
| 266 | ext4_fsblk_t blocks_per_dir;
|
| 267 | unsigned int ndirs;
|
| 268 | int max_debt, max_dirs, min_inodes;
|
| 269 | ext4_grpblk_t min_blocks;
|
| 270 | int group = -1, i;
|
| 271 | struct ext4_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;
|
| 278 | do_div(avefreeb, ngroups);
|
| 279 | ndirs = percpu_counter_read_positive(&sbi->s_dirs_counter);
|
| 280 |
|
| 281 | if ((parent == sb->s_root->d_inode) ||
|
| 282 | (EXT4_I(parent)->i_flags & EXT4_TOPDIR_FL)) {
|
| 283 | int best_ndir = inodes_per_group;
|
| 284 | int best_group = -1;
|
| 285 |
|
| 286 | get_random_bytes(&group, sizeof(group));
|
| 287 | parent_group = (unsigned)group % ngroups;
|
| 288 | for (i = 0; i < ngroups; i++) {
|
| 289 | group = (parent_group + i) % ngroups;
|
| 290 | desc = ext4_get_group_desc (sb, group, &bh);
|
| 291 | if (!desc || !desc->bg_free_inodes_count)
|
| 292 | continue;
|
| 293 | if (le16_to_cpu(desc->bg_used_dirs_count) >= best_ndir)
|
| 294 | continue;
|
| 295 | if (le16_to_cpu(desc->bg_free_inodes_count) < avefreei)
|
| 296 | continue;
|
| 297 | if (le16_to_cpu(desc->bg_free_blocks_count) < avefreeb)
|
| 298 | continue;
|
| 299 | best_group = group;
|
| 300 | best_ndir = le16_to_cpu(desc->bg_used_dirs_count);
|
| 301 | }
|
| 302 | if (best_group >= 0)
|
| 303 | return best_group;
|
| 304 | goto fallback;
|
| 305 | }
|
| 306 |
|
| 307 | blocks_per_dir = ext4_blocks_count(es) - freeb;
|
| 308 | do_div(blocks_per_dir, ndirs);
|
| 309 |
|
| 310 | max_dirs = ndirs / ngroups + inodes_per_group / 16;
|
| 311 | min_inodes = avefreei - inodes_per_group / 4;
|
| 312 | min_blocks = avefreeb - EXT4_BLOCKS_PER_GROUP(sb) / 4;
|
| 313 |
|
| 314 | max_debt = EXT4_BLOCKS_PER_GROUP(sb);
|
| 315 | max_debt /= max_t(int, blocks_per_dir, BLOCK_COST);
|
| 316 | if (max_debt * INODE_COST > inodes_per_group)
|
| 317 | max_debt = inodes_per_group / INODE_COST;
|
| 318 | if (max_debt > 255)
|
| 319 | max_debt = 255;
|
| 320 | if (max_debt == 0)
|
| 321 | max_debt = 1;
|
| 322 |
|
| 323 | for (i = 0; i < ngroups; i++) {
|
| 324 | group = (parent_group + i) % ngroups;
|
| 325 | desc = ext4_get_group_desc (sb, group, &bh);
|
| 326 | if (!desc || !desc->bg_free_inodes_count)
|
| 327 | continue;
|
| 328 | if (le16_to_cpu(desc->bg_used_dirs_count) >= max_dirs)
|
| 329 | continue;
|
| 330 | if (le16_to_cpu(desc->bg_free_inodes_count) < min_inodes)
|
| 331 | continue;
|
| 332 | if (le16_to_cpu(desc->bg_free_blocks_count) < min_blocks)
|
| 333 | continue;
|
| 334 | return group;
|
| 335 | }
|
| 336 |
|
| 337 | fallback:
|
| 338 | for (i = 0; i < ngroups; i++) {
|
| 339 | group = (parent_group + i) % ngroups;
|
| 340 | desc = ext4_get_group_desc (sb, group, &bh);
|
| 341 | if (!desc || !desc->bg_free_inodes_count)
|
| 342 | continue;
|
| 343 | if (le16_to_cpu(desc->bg_free_inodes_count) >= avefreei)
|
| 344 | return group;
|
| 345 | }
|
| 346 |
|
| 347 | if (avefreei) {
|
| 348 | |
| 349 | * The free-inodes counter is approximate, and for really small
|
| 350 | * filesystems the above test can fail to find any blockgroups
|
| 351 |
|
| 352 | avefreei = 0;
|
| 353 | goto fallback;
|
| 354 | }
|
| 355 |
|
| 356 | return -1;
|
| 357 | }
|
| 358 |
|
| 359 | static int find_group_other(struct super_block *sb, struct inode *parent)
|
| 360 | {
|
| 361 | int parent_group = EXT4_I(parent)->i_block_group;
|
| 362 | int ngroups = EXT4_SB(sb)->s_groups_count;
|
| 363 | struct ext4_group_desc *desc;
|
| 364 | struct buffer_head *bh;
|
| 365 | int group, i;
|
| 366 |
|
| 367 | |
| 368 | * Try to place the inode in its parent directory
|
| 369 |
|
| 370 | group = parent_group;
|
| 371 | desc = ext4_get_group_desc (sb, group, &bh);
|
| 372 | if (desc && le16_to_cpu(desc->bg_free_inodes_count) &&
|
| 373 | le16_to_cpu(desc->bg_free_blocks_count))
|
| 374 | return group;
|
| 375 |
|
| 376 | |
| 377 | * We're going to place this inode in a different blockgroup from its
|
| 378 | * parent. We want to cause files in a common directory to all land in
|
| 379 | * the same blockgroup. But we want files which are in a different
|
| 380 | * directory which shares a blockgroup with our parent to land in a
|
| 381 | * different blockgroup.
|
| 382 | *
|
| 383 | * So add our directory's i_ino into the starting point for the hash.
|
| 384 |
|
| 385 | group = (group + parent->i_ino) % ngroups;
|
| 386 |
|
| 387 | |
| 388 | * Use a quadratic hash to find a group with a free inode and some free
|
| 389 | * blocks.
|
| 390 |
|
| 391 | for (i = 1; i < ngroups; i <<= 1) {
|
| 392 | group += i;
|
| 393 | if (group >= ngroups)
|
| 394 | group -= ngroups;
|
| 395 | desc = ext4_get_group_desc (sb, group, &bh);
|
| 396 | if (desc && le16_to_cpu(desc->bg_free_inodes_count) &&
|
| 397 | le16_to_cpu(desc->bg_free_blocks_count))
|
| 398 | return group;
|
| 399 | }
|
| 400 |
|
| 401 | |
| 402 | * That failed: try linear search for a free inode, even if that group
|
| 403 | * has no free blocks.
|
| 404 |
|
| 405 | group = parent_group;
|
| 406 | for (i = 0; i < ngroups; i++) {
|
| 407 | if (++group >= ngroups)
|
| 408 | group = 0;
|
| 409 | desc = ext4_get_group_desc (sb, group, &bh);
|
| 410 | if (desc && le16_to_cpu(desc->bg_free_inodes_count))
|
| 411 | return group;
|
| 412 | }
|
| 413 |
|
| 414 | return -1;
|
| 415 | }
|
| 416 |
|
| 417 | |
| 418 | * There are two policies for allocating an inode. If the new inode is
|
| 419 | * a directory, then a forward search is made for a block group with both
|
| 420 | * free space and a low directory-to-inode ratio; if that fails, then of
|
| 421 | * the groups with above-average free space, that group with the fewest
|
| 422 | * directories already is chosen.
|
| 423 | *
|
| 424 | * For other inodes, search forward from the parent directory's block
|
| 425 | * group to find a free inode.
|
| 426 |
|
| 427 | struct inode *ext4_new_inode(handle_t *handle, struct inode * dir, int mode)
|
| 428 | {
|
| 429 | struct super_block *sb;
|
| 430 | struct buffer_head *bitmap_bh = NULL;
|
| 431 | struct buffer_head *bh2;
|
| 432 | int group;
|
| 433 | unsigned long ino = 0;
|
| 434 | struct inode * inode;
|
| 435 | struct ext4_group_desc * gdp = NULL;
|
| 436 | struct ext4_super_block * es;
|
| 437 | struct ext4_inode_info *ei;
|
| 438 | struct ext4_sb_info *sbi;
|
| 439 | int err = 0;
|
| 440 | struct inode *ret;
|
| 441 | int i;
|
| 442 |
|
| 443 |
|
| 444 | if (!dir || !dir->i_nlink)
|
| 445 | return ERR_PTR(-EPERM);
|
| 446 |
|
| 447 | sb = dir->i_sb;
|
| 448 | inode = new_inode(sb);
|
| 449 | if (!inode)
|
| 450 | return ERR_PTR(-ENOMEM);
|
| 451 | ei = EXT4_I(inode);
|
| 452 |
|
| 453 | sbi = EXT4_SB(sb);
|
| 454 | es = sbi->s_es;
|
| 455 | if (S_ISDIR(mode)) {
|
| 456 | if (test_opt (sb, OLDALLOC))
|
| 457 | group = find_group_dir(sb, dir);
|
| 458 | else
|
| 459 | group = find_group_orlov(sb, dir);
|
| 460 | } else
|
| 461 | group = find_group_other(sb, dir);
|
| 462 |
|
| 463 | err = -ENOSPC;
|
| 464 | if (group == -1)
|
| 465 | goto out;
|
| 466 |
|
| 467 | for (i = 0; i < sbi->s_groups_count; i++) {
|
| 468 | err = -EIO;
|
| 469 |
|
| 470 | gdp = ext4_get_group_desc(sb, group, &bh2);
|
| 471 | if (!gdp)
|
| 472 | goto fail;
|
| 473 |
|
| 474 | brelse(bitmap_bh);
|
| 475 | bitmap_bh = read_inode_bitmap(sb, group);
|
| 476 | if (!bitmap_bh)
|
| 477 | goto fail;
|
| 478 |
|
| 479 | ino = 0;
|
| 480 |
|
| 481 | repeat_in_this_group:
|
| 482 | ino = ext4_find_next_zero_bit((unsigned long *)
|
| 483 | bitmap_bh->b_data, EXT4_INODES_PER_GROUP(sb), ino);
|
| 484 | if (ino < EXT4_INODES_PER_GROUP(sb)) {
|
| 485 |
|
| 486 | BUFFER_TRACE(bitmap_bh, "get_write_access");
|
| 487 | err = ext4_journal_get_write_access(handle, bitmap_bh);
|
| 488 | if (err)
|
| 489 | goto fail;
|
| 490 |
|
| 491 | if (!ext4_set_bit_atomic(sb_bgl_lock(sbi, group),
|
| 492 | ino, bitmap_bh->b_data)) {
|
| 493 |
|
| 494 | BUFFER_TRACE(bitmap_bh,
|
| 495 | "call ext4_journal_dirty_metadata");
|
| 496 | err = ext4_journal_dirty_metadata(handle,
|
| 497 | bitmap_bh);
|
| 498 | if (err)
|
| 499 | goto fail;
|
| 500 | goto got;
|
| 501 | }
|
| 502 |
|
| 503 | jbd2_journal_release_buffer(handle, bitmap_bh);
|
| 504 |
|
| 505 | if (++ino < EXT4_INODES_PER_GROUP(sb))
|
| 506 | goto repeat_in_this_group;
|
| 507 | }
|
| 508 |
|
| 509 | |
| 510 | * This case is possible in concurrent environment. It is very
|
| 511 | * rare. We cannot repeat the find_group_xxx() call because
|
| 512 | * that will simply return the same blockgroup, because the
|
| 513 | * group descriptor metadata has not yet been updated.
|
| 514 | * So we just go onto the next blockgroup.
|
| 515 |
|
| 516 | if (++group == sbi->s_groups_count)
|
| 517 | group = 0;
|
| 518 | }
|
| 519 | err = -ENOSPC;
|
| 520 | goto out;
|
| 521 |
|
| 522 | got:
|
| 523 | ino += group * EXT4_INODES_PER_GROUP(sb) + 1;
|
| 524 | if (ino < EXT4_FIRST_INO(sb) || ino > le32_to_cpu(es->s_inodes_count)) {
|
| 525 | ext4_error (sb, "ext4_new_inode",
|
| 526 | "reserved inode or inode > inodes count - "
|
| 527 | "block_group = %d, inode=%lu", group, ino);
|
| 528 | err = -EIO;
|
| 529 | goto fail;
|
| 530 | }
|
| 531 |
|
| 532 | BUFFER_TRACE(bh2, "get_write_access");
|
| 533 | err = ext4_journal_get_write_access(handle, bh2);
|
| 534 | if (err) goto fail;
|
| 535 | spin_lock(sb_bgl_lock(sbi, group));
|
| 536 | gdp->bg_free_inodes_count =
|
| 537 | cpu_to_le16(le16_to_cpu(gdp->bg_free_inodes_count) - 1);
|
| 538 | if (S_ISDIR(mode)) {
|
| 539 | gdp->bg_used_dirs_count =
|
| 540 | cpu_to_le16(le16_to_cpu(gdp->bg_used_dirs_count) + 1);
|
| 541 | }
|
| 542 | spin_unlock(sb_bgl_lock(sbi, group));
|
| 543 | BUFFER_TRACE(bh2, "call ext4_journal_dirty_metadata");
|
| 544 | err = ext4_journal_dirty_metadata(handle, bh2);
|
| 545 | if (err) goto fail;
|
| 546 |
|
| 547 | percpu_counter_dec(&sbi->s_freeinodes_counter);
|
| 548 | if (S_ISDIR(mode))
|
| 549 | percpu_counter_inc(&sbi->s_dirs_counter);
|
| 550 | sb->s_dirt = 1;
|
| 551 |
|
| 552 | inode->i_uid = current->fsuid;
|
| 553 | if (test_opt (sb, GRPID))
|
| 554 | inode->i_gid = dir->i_gid;
|
| 555 | else if (dir->i_mode & S_ISGID) {
|
| 556 | inode->i_gid = dir->i_gid;
|
| 557 | if (S_ISDIR(mode))
|
| 558 | mode |= S_ISGID;
|
| 559 | } else
|
| 560 | inode->i_gid = current->fsgid;
|
| 561 | inode->i_mode = mode;
|
| 562 |
|
| 563 | inode->i_ino = ino;
|
| 564 |
|
| 565 | inode->i_blocks = 0;
|
| 566 | inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME_SEC;
|
| 567 |
|
| 568 | memset(ei->i_data, 0, sizeof(ei->i_data));
|
| 569 | ei->i_dir_start_lookup = 0;
|
| 570 | ei->i_disksize = 0;
|
| 571 |
|
| 572 | ei->i_flags = EXT4_I(dir)->i_flags & ~EXT4_INDEX_FL;
|
| 573 | if (S_ISLNK(mode))
|
| 574 | ei->i_flags &= ~(EXT4_IMMUTABLE_FL|EXT4_APPEND_FL);
|
| 575 |
|
| 576 | if (!S_ISDIR(mode))
|
| 577 | ei->i_flags &= ~EXT4_DIRSYNC_FL;
|
| 578 | #ifdef EXT4_FRAGMENTS
|
| 579 | ei->i_faddr = 0;
|
| 580 | ei->i_frag_no = 0;
|
| 581 | ei->i_frag_size = 0;
|
| 582 | #endif
|
| 583 | ei->i_file_acl = 0;
|
| 584 | ei->i_dir_acl = 0;
|
| 585 | ei->i_dtime = 0;
|
| 586 | ei->i_block_alloc_info = NULL;
|
| 587 | ei->i_block_group = group;
|
| 588 |
|
| 589 | ext4_set_inode_flags(inode);
|
| 590 | if (IS_DIRSYNC(inode))
|
| 591 | handle->h_sync = 1;
|
| 592 | insert_inode_hash(inode);
|
| 593 | spin_lock(&sbi->s_next_gen_lock);
|
| 594 | inode->i_generation = sbi->s_next_generation++;
|
| 595 | spin_unlock(&sbi->s_next_gen_lock);
|
| 596 |
|
| 597 | ei->i_state = EXT4_STATE_NEW;
|
| 598 | ei->i_extra_isize =
|
| 599 | (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE) ?
|
| 600 | sizeof(struct ext4_inode) - EXT4_GOOD_OLD_INODE_SIZE : 0;
|
| 601 |
|
| 602 | ret = inode;
|
| 603 | if(DQUOT_ALLOC_INODE(inode)) {
|
| 604 | err = -EDQUOT;
|
| 605 | goto fail_drop;
|
| 606 | }
|
| 607 |
|
| 608 | err = ext4_init_acl(handle, inode, dir);
|
| 609 | if (err)
|
| 610 | goto fail_free_drop;
|
| 611 |
|
| 612 | err = ext4_init_security(handle,inode, dir);
|
| 613 | if (err)
|
| 614 | goto fail_free_drop;
|
| 615 |
|
| 616 | err = ext4_mark_inode_dirty(handle, inode);
|
| 617 | if (err) {
|
| 618 | ext4_std_error(sb, err);
|
| 619 | goto fail_free_drop;
|
| 620 | }
|
| 621 | if (test_opt(sb, EXTENTS)) {
|
| 622 | EXT4_I(inode)->i_flags |= EXT4_EXTENTS_FL;
|
| 623 | ext4_ext_tree_init(handle, inode);
|
| 624 | if (!EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_EXTENTS)) {
|
| 625 | err = ext4_journal_get_write_access(handle, EXT4_SB(sb)->s_sbh);
|
| 626 | if (err) goto fail;
|
| 627 | EXT4_SET_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_EXTENTS);
|
| 628 | BUFFER_TRACE(EXT4_SB(sb)->s_sbh, "call ext4_journal_dirty_metadata");
|
| 629 | err = ext4_journal_dirty_metadata(handle, EXT4_SB(sb)->s_sbh);
|
| 630 | }
|
| 631 | }
|
| 632 |
|
| 633 | ext4_debug("allocating inode %lu\n", inode->i_ino);
|
| 634 | goto really_out;
|
| 635 | fail:
|
| 636 | ext4_std_error(sb, err);
|
| 637 | out:
|
| 638 | iput(inode);
|
| 639 | ret = ERR_PTR(err);
|
| 640 | really_out:
|
| 641 | brelse(bitmap_bh);
|
| 642 | return ret;
|
| 643 |
|
| 644 | fail_free_drop:
|
| 645 | DQUOT_FREE_INODE(inode);
|
| 646 |
|
| 647 | fail_drop:
|
| 648 | DQUOT_DROP(inode);
|
| 649 | inode->i_flags |= S_NOQUOTA;
|
| 650 | inode->i_nlink = 0;
|
| 651 | iput(inode);
|
| 652 | brelse(bitmap_bh);
|
| 653 | return ERR_PTR(err);
|
| 654 | }
|
| 655 |
|
| 656 |
|
| 657 | struct inode *ext4_orphan_get(struct super_block *sb, unsigned long ino)
|
| 658 | {
|
| 659 | unsigned long max_ino = le32_to_cpu(EXT4_SB(sb)->s_es->s_inodes_count);
|
| 660 | unsigned long block_group;
|
| 661 | int bit;
|
| 662 | struct buffer_head *bitmap_bh = NULL;
|
| 663 | struct inode *inode = NULL;
|
| 664 |
|
| 665 |
|
| 666 | if (ino > max_ino) {
|
| 667 | ext4_warning(sb, __FUNCTION__,
|
| 668 | "bad orphan ino %lu! e2fsck was run?", ino);
|
| 669 | goto out;
|
| 670 | }
|
| 671 |
|
| 672 | block_group = (ino - 1) / EXT4_INODES_PER_GROUP(sb);
|
| 673 | bit = (ino - 1) % EXT4_INODES_PER_GROUP(sb);
|
| 674 | bitmap_bh = read_inode_bitmap(sb, block_group);
|
| 675 | if (!bitmap_bh) {
|
| 676 | ext4_warning(sb, __FUNCTION__,
|
| 677 | "inode bitmap error for orphan %lu", ino);
|
| 678 | goto out;
|
| 679 | }
|
| 680 |
|
| 681 | |
| 682 | * is a valid orphan (no e2fsck run on fs). Orphans also include
|
| 683 | * inodes that were being truncated, so we can't check i_nlink==0.
|
| 684 |
|
| 685 | if (!ext4_test_bit(bit, bitmap_bh->b_data) ||
|
| 686 | !(inode = iget(sb, ino)) || is_bad_inode(inode) ||
|
| 687 | NEXT_ORPHAN(inode) > max_ino) {
|
| 688 | ext4_warning(sb, __FUNCTION__,
|
| 689 | "bad orphan inode %lu! e2fsck was run?", ino);
|
| 690 | printk(KERN_NOTICE "ext4_test_bit(bit=%d, block=%llu) = %d\n",
|
| 691 | bit, (unsigned long long)bitmap_bh->b_blocknr,
|
| 692 | ext4_test_bit(bit, bitmap_bh->b_data));
|
| 693 | printk(KERN_NOTICE "inode=%p\n", inode);
|
| 694 | if (inode) {
|
| 695 | printk(KERN_NOTICE "is_bad_inode(inode)=%d\n",
|
| 696 | is_bad_inode(inode));
|
| 697 | printk(KERN_NOTICE "NEXT_ORPHAN(inode)=%u\n",
|
| 698 | NEXT_ORPHAN(inode));
|
| 699 | printk(KERN_NOTICE "max_ino=%lu\n", max_ino);
|
| 700 | }
|
| 701 |
|
| 702 | if (inode && inode->i_nlink == 0)
|
| 703 | inode->i_blocks = 0;
|
| 704 | iput(inode);
|
| 705 | inode = NULL;
|
| 706 | }
|
| 707 | out:
|
| 708 | brelse(bitmap_bh);
|
| 709 | return inode;
|
| 710 | }
|
| 711 |
|
| 712 | unsigned long ext4_count_free_inodes (struct super_block * sb)
|
| 713 | {
|
| 714 | unsigned long desc_count;
|
| 715 | struct ext4_group_desc *gdp;
|
| 716 | int i;
|
| 717 | #ifdef EXT4FS_DEBUG
|
| 718 | struct ext4_super_block *es;
|
| 719 | unsigned long bitmap_count, x;
|
| 720 | struct buffer_head *bitmap_bh = NULL;
|
| 721 |
|
| 722 | es = EXT4_SB(sb)->s_es;
|
| 723 | desc_count = 0;
|
| 724 | bitmap_count = 0;
|
| 725 | gdp = NULL;
|
| 726 | for (i = 0; i < EXT4_SB(sb)->s_groups_count; i++) {
|
| 727 | gdp = ext4_get_group_desc (sb, i, NULL);
|
| 728 | if (!gdp)
|
| 729 | continue;
|
| 730 | desc_count += le16_to_cpu(gdp->bg_free_inodes_count);
|
| 731 | brelse(bitmap_bh);
|
| 732 | bitmap_bh = read_inode_bitmap(sb, i);
|
| 733 | if (!bitmap_bh)
|
| 734 | continue;
|
| 735 |
|
| 736 | x = ext4_count_free(bitmap_bh, EXT4_INODES_PER_GROUP(sb) / 8);
|
| 737 | printk("group %d: stored = %d, counted = %lu\n",
|
| 738 | i, le16_to_cpu(gdp->bg_free_inodes_count), x);
|
| 739 | bitmap_count += x;
|
| 740 | }
|
| 741 | brelse(bitmap_bh);
|
| 742 | printk("ext4_count_free_inodes: stored = %u, computed = %lu, %lu\n",
|
| 743 | le32_to_cpu(es->s_free_inodes_count), desc_count, bitmap_count);
|
| 744 | return desc_count;
|
| 745 | #else
|
| 746 | desc_count = 0;
|
| 747 | for (i = 0; i < EXT4_SB(sb)->s_groups_count; i++) {
|
| 748 | gdp = ext4_get_group_desc (sb, i, NULL);
|
| 749 | if (!gdp)
|
| 750 | continue;
|
| 751 | desc_count += le16_to_cpu(gdp->bg_free_inodes_count);
|
| 752 | cond_resched();
|
| 753 | }
|
| 754 | return desc_count;
|
| 755 | #endif
|
| 756 | }
|
| 757 |
|
| 758 |
|
| 759 | unsigned long ext4_count_dirs (struct super_block * sb)
|
| 760 | {
|
| 761 | unsigned long count = 0;
|
| 762 | int i;
|
| 763 |
|
| 764 | for (i = 0; i < EXT4_SB(sb)->s_groups_count; i++) {
|
| 765 | struct ext4_group_desc *gdp = ext4_get_group_desc (sb, i, NULL);
|
| 766 | if (!gdp)
|
| 767 | continue;
|
| 768 | count += le16_to_cpu(gdp->bg_used_dirs_count);
|
| 769 | }
|
| 770 | return count;
|
| 771 | }
|
| 772 |
|