| 1 |
// SPDX-License-Identifier: GPL-2.0 |
| 2 |
/* |
| 3 |
* linux/fs/ext4/ialloc.c |
| 4 |
* |
| 5 |
* Copyright (C) 1992, 1993, 1994, 1995 |
| 6 |
* Remy Card ([email protected]) |
| 7 |
* Laboratoire MASI - Institut Blaise Pascal |
| 8 |
* Universite Pierre et Marie Curie (Paris VI) |
| 9 |
* |
| 10 |
* BSD ufs-inspired inode and directory allocation by |
| 11 |
* Stephen Tweedie ([email protected]), 1993 |
| 12 |
* Big-endian to little-endian byte-swapping/bitmaps by |
| 13 |
* David S. Miller ([email protected]), 1995 |
| 14 |
*/ |
| 15 |
|
| 16 |
#include <linux/time.h> |
| 17 |
#include <linux/fs.h> |
| 18 |
#include <linux/stat.h> |
| 19 |
#include <linux/string.h> |
| 20 |
#include <linux/quotaops.h> |
| 21 |
#include <linux/buffer_head.h> |
| 22 |
#include <linux/random.h> |
| 23 |
#include <linux/bitops.h> |
| 24 |
#include <linux/blkdev.h> |
| 25 |
#include <linux/cred.h> |
| 26 |
|
| 27 |
#include <asm/byteorder.h> |
| 28 |
|
| 29 |
#include "ext4.h" |
| 30 |
#include "ext4_jbd2.h" |
| 31 |
#include "xattr.h" |
| 32 |
#include "acl.h" |
| 33 |
|
| 34 |
#include <trace/events/ext4.h> |
| 35 |
|
| 36 |
/* |
| 37 |
* ialloc.c contains the inodes allocation and deallocation routines |
| 38 |
*/ |
| 39 |
|
| 40 |
/* |
| 41 |
* The free inodes are managed by bitmaps. A file system contains several |
| 42 |
* blocks groups. Each group contains 1 bitmap block for blocks, 1 bitmap |
| 43 |
* block for inodes, N blocks for the inode table and data blocks. |
| 44 |
* |
| 45 |
* The file system contains group descriptors which are located after the |
| 46 |
* super block. Each descriptor contains the number of the bitmap block and |
| 47 |
* the free blocks count in the block. |
| 48 |
*/ |
| 49 |
|
| 50 |
/* |
| 51 |
* To avoid calling the atomic setbit hundreds or thousands of times, we only |
| 52 |
* need to use it within a single byte (to ensure we get endianness right). |
| 53 |
* We can use memset for the rest of the bitmap as there are no other users. |
| 54 |
*/ |
| 55 |
void ext4_mark_bitmap_end(int start_bit, int end_bit, char *bitmap) |
| 56 |
{ |
| 57 |
int i; |
| 58 |
|
| 59 |
if (start_bit >= end_bit) |
| 60 |
return; |
| 61 |
|
| 62 |
ext4_debug("mark end bits +%d through +%d used\n", start_bit, end_bit); |
| 63 |
for (i = start_bit; i < ((start_bit + 7) & ~7UL); i++) |
| 64 |
ext4_set_bit(i, bitmap); |
| 65 |
if (i < end_bit) |
| 66 |
memset(bitmap + (i >> 3), 0xff, (end_bit - i) >> 3); |
| 67 |
} |
| 68 |
|
| 69 |
void ext4_end_bitmap_read(struct buffer_head *bh, int uptodate) |
| 70 |
{ |
| 71 |
if (uptodate) { |
| 72 |
set_buffer_uptodate(bh); |
| 73 |
set_bitmap_uptodate(bh); |
| 74 |
} |
| 75 |
unlock_buffer(bh); |
| 76 |
put_bh(bh); |
| 77 |
} |
| 78 |
|
| 79 |
static int ext4_validate_inode_bitmap(struct super_block *sb, |
| 80 |
struct ext4_group_desc *desc, |
| 81 |
ext4_group_t block_group, |
| 82 |
struct buffer_head *bh) |
| 83 |
{ |
| 84 |
ext4_fsblk_t blk; |
| 85 |
struct ext4_group_info *grp; |
| 86 |
|
| 87 |
if (EXT4_SB(sb)->s_mount_state & EXT4_FC_REPLAY) |
| 88 |
return 0; |
| 89 |
|
| 90 |
if (buffer_verified(bh)) |
| 91 |
return 0; |
| 92 |
|
| 93 |
grp = ext4_get_group_info(sb, block_group); |
| 94 |
if (!grp || EXT4_MB_GRP_IBITMAP_CORRUPT(grp)) |
| 95 |
return -EFSCORRUPTED; |
| 96 |
|
| 97 |
ext4_lock_group(sb, block_group); |
| 98 |
if (buffer_verified(bh)) |
| 99 |
goto verified; |
| 100 |
blk = ext4_inode_bitmap(sb, desc); |
| 101 |
if (!ext4_inode_bitmap_csum_verify(sb, desc, bh) || |
| 102 |
ext4_simulate_fail(sb, EXT4_SIM_IBITMAP_CRC)) { |
| 103 |
ext4_unlock_group(sb, block_group); |
| 104 |
ext4_error(sb, "Corrupt inode bitmap - block_group = %u, " |
| 105 |
"inode_bitmap = %llu", block_group, blk); |
| 106 |
ext4_mark_group_bitmap_corrupted(sb, block_group, |
| 107 |
EXT4_GROUP_INFO_IBITMAP_CORRUPT); |
| 108 |
return -EFSBADCRC; |
| 109 |
} |
| 110 |
set_buffer_verified(bh); |
| 111 |
verified: |
| 112 |
ext4_unlock_group(sb, block_group); |
| 113 |
return 0; |
| 114 |
} |
| 115 |
|
| 116 |
/* |
| 117 |
* Read the inode allocation bitmap for a given block_group, reading |
| 118 |
* into the specified slot in the superblock's bitmap cache. |
| 119 |
* |
| 120 |
* Return buffer_head of bitmap on success, or an ERR_PTR on error. |
| 121 |
*/ |
| 122 |
static struct buffer_head * |
| 123 |
ext4_read_inode_bitmap(struct super_block *sb, ext4_group_t block_group) |
| 124 |
{ |
| 125 |
struct ext4_group_desc *desc; |
| 126 |
struct ext4_sb_info *sbi = EXT4_SB(sb); |
| 127 |
struct buffer_head *bh = NULL; |
| 128 |
ext4_fsblk_t bitmap_blk; |
| 129 |
int err; |
| 130 |
|
| 131 |
desc = ext4_get_group_desc(sb, block_group, NULL); |
| 132 |
if (!desc) |
| 133 |
return ERR_PTR(-EFSCORRUPTED); |
| 134 |
|
| 135 |
bitmap_blk = ext4_inode_bitmap(sb, desc); |
| 136 |
if ((bitmap_blk <= le32_to_cpu(sbi->s_es->s_first_data_block)) || |
| 137 |
(bitmap_blk >= ext4_blocks_count(sbi->s_es))) { |
| 138 |
ext4_error(sb, "Invalid inode bitmap blk %llu in " |
| 139 |
"block_group %u", bitmap_blk, block_group); |
| 140 |
ext4_mark_group_bitmap_corrupted(sb, block_group, |
| 141 |
EXT4_GROUP_INFO_IBITMAP_CORRUPT); |
| 142 |
return ERR_PTR(-EFSCORRUPTED); |
| 143 |
} |
| 144 |
bh = sb_getblk(sb, bitmap_blk); |
| 145 |
if (unlikely(!bh)) { |
| 146 |
ext4_warning(sb, "Cannot read inode bitmap - " |
| 147 |
"block_group = %u, inode_bitmap = %llu", |
| 148 |
block_group, bitmap_blk); |
| 149 |
return ERR_PTR(-ENOMEM); |
| 150 |
} |
| 151 |
if (bitmap_uptodate(bh)) |
| 152 |
goto verify; |
| 153 |
|
| 154 |
lock_buffer(bh); |
| 155 |
if (bitmap_uptodate(bh)) { |
| 156 |
unlock_buffer(bh); |
| 157 |
goto verify; |
| 158 |
} |
| 159 |
|
| 160 |
ext4_lock_group(sb, block_group); |
| 161 |
if (ext4_has_group_desc_csum(sb) && |
| 162 |
(desc->bg_flags & cpu_to_le16(EXT4_BG_INODE_UNINIT))) { |
| 163 |
if (block_group == 0) { |
| 164 |
ext4_unlock_group(sb, block_group); |
| 165 |
unlock_buffer(bh); |
| 166 |
ext4_error(sb, "Inode bitmap for bg 0 marked " |
| 167 |
"uninitialized"); |
| 168 |
err = -EFSCORRUPTED; |
| 169 |
goto out; |
| 170 |
} |
| 171 |
memset(bh->b_data, 0, (EXT4_INODES_PER_GROUP(sb) + 7) / 8); |
| 172 |
ext4_mark_bitmap_end(EXT4_INODES_PER_GROUP(sb), |
| 173 |
sb->s_blocksize * 8, bh->b_data); |
| 174 |
set_bitmap_uptodate(bh); |
| 175 |
set_buffer_uptodate(bh); |
| 176 |
set_buffer_verified(bh); |
| 177 |
ext4_unlock_group(sb, block_group); |
| 178 |
unlock_buffer(bh); |
| 179 |
return bh; |
| 180 |
} |
| 181 |
ext4_unlock_group(sb, block_group); |
| 182 |
|
| 183 |
if (buffer_uptodate(bh)) { |
| 184 |
/* |
| 185 |
* if not uninit if bh is uptodate, |
| 186 |
* bitmap is also uptodate |
| 187 |
*/ |
| 188 |
set_bitmap_uptodate(bh); |
| 189 |
unlock_buffer(bh); |
| 190 |
goto verify; |
| 191 |
} |
| 192 |
/* |
| 193 |
* submit the buffer_head for reading |
| 194 |
*/ |
| 195 |
trace_ext4_load_inode_bitmap(sb, block_group); |
| 196 |
ext4_read_bh(bh, REQ_META | REQ_PRIO, |
| 197 |
ext4_end_bitmap_read, |
| 198 |
ext4_simulate_fail(sb, EXT4_SIM_IBITMAP_EIO)); |
| 199 |
if (!buffer_uptodate(bh)) { |
| 200 |
put_bh(bh); |
| 201 |
ext4_error_err(sb, EIO, "Cannot read inode bitmap - " |
| 202 |
"block_group = %u, inode_bitmap = %llu", |
| 203 |
block_group, bitmap_blk); |
| 204 |
ext4_mark_group_bitmap_corrupted(sb, block_group, |
| 205 |
EXT4_GROUP_INFO_IBITMAP_CORRUPT); |
| 206 |
return ERR_PTR(-EIO); |
| 207 |
} |
| 208 |
|
| 209 |
verify: |
| 210 |
err = ext4_validate_inode_bitmap(sb, desc, block_group, bh); |
| 211 |
if (err) |
| 212 |
goto out; |
| 213 |
return bh; |
| 214 |
out: |
| 215 |
put_bh(bh); |
| 216 |
return ERR_PTR(err); |
| 217 |
} |
| 218 |
|
| 219 |
/* |
| 220 |
* NOTE! When we get the inode, we're the only people |
| 221 |
* that have access to it, and as such there are no |
| 222 |
* race conditions we have to worry about. The inode |
| 223 |
* is not on the hash-lists, and it cannot be reached |
| 224 |
* through the filesystem because the directory entry |
| 225 |
* has been deleted earlier. |
| 226 |
* |
| 227 |
* HOWEVER: we must make sure that we get no aliases, |
| 228 |
* which means that we have to call "clear_inode()" |
| 229 |
* _before_ we mark the inode not in use in the inode |
| 230 |
* bitmaps. Otherwise a newly created file might use |
| 231 |
* the same inode number (not actually the same pointer |
| 232 |
* though), and then we'd have two inodes sharing the |
| 233 |
* same inode number and space on the harddisk. |
| 234 |
*/ |
| 235 |
void ext4_free_inode(handle_t *handle, struct inode *inode) |
| 236 |
{ |
| 237 |
struct super_block *sb = inode->i_sb; |
| 238 |
int is_directory; |
| 239 |
unsigned long ino; |
| 240 |
struct buffer_head *bitmap_bh = NULL; |
| 241 |
struct buffer_head *bh2; |
| 242 |
ext4_group_t block_group; |
| 243 |
unsigned long bit; |
| 244 |
struct ext4_group_desc *gdp; |
| 245 |
struct ext4_super_block *es; |
| 246 |
struct ext4_sb_info *sbi; |
| 247 |
int fatal = 0, err, count, cleared; |
| 248 |
struct ext4_group_info *grp; |
| 249 |
|
| 250 |
if (!sb) { |
| 251 |
printk(KERN_ERR "EXT4-fs: %s:%d: inode on " |
| 252 |
"nonexistent device\n", __func__, __LINE__); |
| 253 |
return; |
| 254 |
} |
| 255 |
if (icount_read(inode) > 1) { |
| 256 |
ext4_msg(sb, KERN_ERR, "%s:%d: inode #%lu: count=%d", |
| 257 |
__func__, __LINE__, inode->i_ino, |
| 258 |
icount_read(inode)); |
| 259 |
return; |
| 260 |
} |
| 261 |
if (inode->i_nlink) { |
| 262 |
ext4_msg(sb, KERN_ERR, "%s:%d: inode #%lu: nlink=%d\n", |
| 263 |
__func__, __LINE__, inode->i_ino, inode->i_nlink); |
| 264 |
return; |
| 265 |
} |
| 266 |
sbi = EXT4_SB(sb); |
| 267 |
|
| 268 |
ino = inode->i_ino; |
| 269 |
ext4_debug("freeing inode %lu\n", ino); |
| 270 |
trace_ext4_free_inode(inode); |
| 271 |
|
| 272 |
dquot_initialize(inode); |
| 273 |
dquot_free_inode(inode); |
| 274 |
|
| 275 |
is_directory = S_ISDIR(inode->i_mode); |
| 276 |
|
| 277 |
/* Do this BEFORE marking the inode not in use or returning an error */ |
| 278 |
ext4_clear_inode(inode); |
| 279 |
|
| 280 |
es = sbi->s_es; |
| 281 |
if (ino < EXT4_FIRST_INO(sb) || ino > le32_to_cpu(es->s_inodes_count)) { |
| 282 |
ext4_error(sb, "reserved or nonexistent inode %lu", ino); |
| 283 |
goto error_return; |
| 284 |
} |
| 285 |
block_group = (ino - 1) / EXT4_INODES_PER_GROUP(sb); |
| 286 |
bit = (ino - 1) % EXT4_INODES_PER_GROUP(sb); |
| 287 |
bitmap_bh = ext4_read_inode_bitmap(sb, block_group); |
| 288 |
/* Don't bother if the inode bitmap is corrupt. */ |
| 289 |
if (IS_ERR(bitmap_bh)) { |
| 290 |
fatal = PTR_ERR(bitmap_bh); |
| 291 |
bitmap_bh = NULL; |
| 292 |
goto error_return; |
| 293 |
} |
| 294 |
if (!(sbi->s_mount_state & EXT4_FC_REPLAY)) { |
| 295 |
grp = ext4_get_group_info(sb, block_group); |
| 296 |
if (!grp || unlikely(EXT4_MB_GRP_IBITMAP_CORRUPT(grp))) { |
| 297 |
fatal = -EFSCORRUPTED; |
| 298 |
goto error_return; |
| 299 |
} |
| 300 |
} |
| 301 |
|
| 302 |
BUFFER_TRACE(bitmap_bh, "get_write_access"); |
| 303 |
fatal = ext4_journal_get_write_access(handle, sb, bitmap_bh, |
| 304 |
EXT4_JTR_NONE); |
| 305 |
if (fatal) |
| 306 |
goto error_return; |
| 307 |
|
| 308 |
fatal = -ESRCH; |
| 309 |
gdp = ext4_get_group_desc(sb, block_group, &bh2); |
| 310 |
if (gdp) { |
| 311 |
BUFFER_TRACE(bh2, "get_write_access"); |
| 312 |
fatal = ext4_journal_get_write_access(handle, sb, bh2, |
| 313 |
EXT4_JTR_NONE); |
| 314 |
} |
| 315 |
ext4_lock_group(sb, block_group); |
| 316 |
cleared = ext4_test_and_clear_bit(bit, bitmap_bh->b_data); |
| 317 |
if (fatal || !cleared) { |
| 318 |
ext4_unlock_group(sb, block_group); |
| 319 |
goto out; |
| 320 |
} |
| 321 |
|
| 322 |
count = ext4_free_inodes_count(sb, gdp) + 1; |
| 323 |
ext4_free_inodes_set(sb, gdp, count); |
| 324 |
if (is_directory) { |
| 325 |
count = ext4_used_dirs_count(sb, gdp) - 1; |
| 326 |
ext4_used_dirs_set(sb, gdp, count); |
| 327 |
if (percpu_counter_initialized(&sbi->s_dirs_counter)) |
| 328 |
percpu_counter_dec(&sbi->s_dirs_counter); |
| 329 |
} |
| 330 |
ext4_inode_bitmap_csum_set(sb, gdp, bitmap_bh); |
| 331 |
ext4_group_desc_csum_set(sb, block_group, gdp); |
| 332 |
ext4_unlock_group(sb, block_group); |
| 333 |
|
| 334 |
if (percpu_counter_initialized(&sbi->s_freeinodes_counter)) |
| 335 |
percpu_counter_inc(&sbi->s_freeinodes_counter); |
| 336 |
if (sbi->s_log_groups_per_flex) { |
| 337 |
struct flex_groups *fg; |
| 338 |
|
| 339 |
fg = sbi_array_rcu_deref(sbi, s_flex_groups, |
| 340 |
ext4_flex_group(sbi, block_group)); |
| 341 |
atomic_inc(&fg->free_inodes); |
| 342 |
if (is_directory) |
| 343 |
atomic_dec(&fg->used_dirs); |
| 344 |
} |
| 345 |
BUFFER_TRACE(bh2, "call ext4_handle_dirty_metadata"); |
| 346 |
fatal = ext4_handle_dirty_metadata(handle, NULL, bh2); |
| 347 |
out: |
| 348 |
if (cleared) { |
| 349 |
BUFFER_TRACE(bitmap_bh, "call ext4_handle_dirty_metadata"); |
| 350 |
err = ext4_handle_dirty_metadata(handle, NULL, bitmap_bh); |
| 351 |
if (!fatal) |
| 352 |
fatal = err; |
| 353 |
} else { |
| 354 |
ext4_error(sb, "bit already cleared for inode %lu", ino); |
| 355 |
ext4_mark_group_bitmap_corrupted(sb, block_group, |
| 356 |
EXT4_GROUP_INFO_IBITMAP_CORRUPT); |
| 357 |
} |
| 358 |
|
| 359 |
error_return: |
| 360 |
brelse(bitmap_bh); |
| 361 |
ext4_std_error(sb, fatal); |
| 362 |
} |
| 363 |
|
| 364 |
struct orlov_stats { |
| 365 |
__u64 free_clusters; |
| 366 |
__u32 free_inodes; |
| 367 |
__u32 used_dirs; |
| 368 |
}; |
| 369 |
|
| 370 |
/* |
| 371 |
* Helper function for Orlov's allocator; returns critical information |
| 372 |
* for a particular block group or flex_bg. If flex_size is 1, then g |
| 373 |
* is a block group number; otherwise it is flex_bg number. |
| 374 |
*/ |
| 375 |
static void get_orlov_stats(struct super_block *sb, ext4_group_t g, |
| 376 |
int flex_size, struct orlov_stats *stats) |
| 377 |
{ |
| 378 |
struct ext4_group_desc *desc; |
| 379 |
|
| 380 |
if (flex_size > 1) { |
| 381 |
struct flex_groups *fg = sbi_array_rcu_deref(EXT4_SB(sb), |
| 382 |
s_flex_groups, g); |
| 383 |
stats->free_inodes = atomic_read(&fg->free_inodes); |
| 384 |
stats->free_clusters = atomic64_read(&fg->free_clusters); |
| 385 |
stats->used_dirs = atomic_read(&fg->used_dirs); |
| 386 |
return; |
| 387 |
} |
| 388 |
|
| 389 |
desc = ext4_get_group_desc(sb, g, NULL); |
| 390 |
if (desc) { |
| 391 |
stats->free_inodes = ext4_free_inodes_count(sb, desc); |
| 392 |
stats->free_clusters = ext4_free_group_clusters(sb, desc); |
| 393 |
stats->used_dirs = ext4_used_dirs_count(sb, desc); |
| 394 |
} else { |
| 395 |
stats->free_inodes = 0; |
| 396 |
stats->free_clusters = 0; |
| 397 |
stats->used_dirs = 0; |
| 398 |
} |
| 399 |
} |
| 400 |
|
| 401 |
/* |
| 402 |
* Orlov's allocator for directories. |
| 403 |
* |
| 404 |
* We always try to spread first-level directories. |
| 405 |
* |
| 406 |
* If there are blockgroups with both free inodes and free clusters counts |
| 407 |
* not worse than average we return one with smallest directory count. |
| 408 |
* Otherwise we simply return a random group. |
| 409 |
* |
| 410 |
* For the rest rules look so: |
| 411 |
* |
| 412 |
* It's OK to put directory into a group unless |
| 413 |
* it has too many directories already (max_dirs) or |
| 414 |
* it has too few free inodes left (min_inodes) or |
| 415 |
* it has too few free clusters left (min_clusters) or |
| 416 |
* Parent's group is preferred, if it doesn't satisfy these |
| 417 |
* conditions we search cyclically through the rest. If none |
| 418 |
* of the groups look good we just look for a group with more |
| 419 |
* free inodes than average (starting at parent's group). |
| 420 |
*/ |
| 421 |
|
| 422 |
static int find_group_orlov(struct super_block *sb, struct inode *parent, |
| 423 |
ext4_group_t *group, umode_t mode, |
| 424 |
const struct qstr *qstr) |
| 425 |
{ |
| 426 |
ext4_group_t parent_group = EXT4_I(parent)->i_block_group; |
| 427 |
struct ext4_sb_info *sbi = EXT4_SB(sb); |
| 428 |
ext4_group_t real_ngroups = ext4_get_groups_count(sb); |
| 429 |
int inodes_per_group = EXT4_INODES_PER_GROUP(sb); |
| 430 |
unsigned int freei, avefreei, grp_free; |
| 431 |
ext4_fsblk_t freec, avefreec; |
| 432 |
unsigned int ndirs; |
| 433 |
int max_dirs, min_inodes; |
| 434 |
ext4_grpblk_t min_clusters; |
| 435 |
ext4_group_t i, grp, g, ngroups; |
| 436 |
struct ext4_group_desc *desc; |
| 437 |
struct orlov_stats stats; |
| 438 |
int flex_size = ext4_flex_bg_size(sbi); |
| 439 |
struct dx_hash_info hinfo; |
| 440 |
|
| 441 |
ngroups = real_ngroups; |
| 442 |
if (flex_size > 1) { |
| 443 |
ngroups = (real_ngroups + flex_size - 1) >> |
| 444 |
sbi->s_log_groups_per_flex; |
| 445 |
parent_group >>= sbi->s_log_groups_per_flex; |
| 446 |
} |
| 447 |
|
| 448 |
freei = percpu_counter_read_positive(&sbi->s_freeinodes_counter); |
| 449 |
avefreei = freei / ngroups; |
| 450 |
freec = percpu_counter_read_positive(&sbi->s_freeclusters_counter); |
| 451 |
avefreec = freec; |
| 452 |
do_div(avefreec, ngroups); |
| 453 |
ndirs = percpu_counter_read_positive(&sbi->s_dirs_counter); |
| 454 |
|
| 455 |
if (S_ISDIR(mode) && |
| 456 |
((parent == d_inode(sb->s_root)) || |
| 457 |
(ext4_test_inode_flag(parent, EXT4_INODE_TOPDIR)))) { |
| 458 |
int best_ndir = inodes_per_group; |
| 459 |
int ret = -1; |
| 460 |
|
| 461 |
if (qstr) { |
| 462 |
hinfo.hash_version = DX_HASH_HALF_MD4; |
| 463 |
hinfo.seed = sbi->s_hash_seed; |
| 464 |
ext4fs_dirhash(parent, qstr->name, qstr->len, &hinfo); |
| 465 |
parent_group = hinfo.hash % ngroups; |
| 466 |
} else |
| 467 |
parent_group = get_random_u32_below(ngroups); |
| 468 |
for (i = 0; i < ngroups; i++) { |
| 469 |
g = (parent_group + i) % ngroups; |
| 470 |
get_orlov_stats(sb, g, flex_size, &stats); |
| 471 |
if (!stats.free_inodes) |
| 472 |
continue; |
| 473 |
if (stats.used_dirs >= best_ndir) |
| 474 |
continue; |
| 475 |
if (stats.free_inodes < avefreei) |
| 476 |
continue; |
| 477 |
if (stats.free_clusters < avefreec) |
| 478 |
continue; |
| 479 |
grp = g; |
| 480 |
ret = 0; |
| 481 |
best_ndir = stats.used_dirs; |
| 482 |
} |
| 483 |
if (ret) |
| 484 |
goto fallback; |
| 485 |
found_flex_bg: |
| 486 |
if (flex_size == 1) { |
| 487 |
*group = grp; |
| 488 |
return 0; |
| 489 |
} |
| 490 |
|
| 491 |
/* |
| 492 |
* We pack inodes at the beginning of the flexgroup's |
| 493 |
* inode tables. Block allocation decisions will do |
| 494 |
* something similar, although regular files will |
| 495 |
* start at 2nd block group of the flexgroup. See |
| 496 |
* ext4_ext_find_goal() and ext4_find_near(). |
| 497 |
*/ |
| 498 |
grp *= flex_size; |
| 499 |
for (i = 0; i < flex_size; i++) { |
| 500 |
if (grp+i >= real_ngroups) |
| 501 |
break; |
| 502 |
desc = ext4_get_group_desc(sb, grp+i, NULL); |
| 503 |
if (desc && ext4_free_inodes_count(sb, desc)) { |
| 504 |
*group = grp+i; |
| 505 |
return 0; |
| 506 |
} |
| 507 |
} |
| 508 |
goto fallback; |
| 509 |
} |
| 510 |
|
| 511 |
max_dirs = ndirs / ngroups + inodes_per_group*flex_size / 16; |
| 512 |
min_inodes = avefreei - inodes_per_group*flex_size / 4; |
| 513 |
if (min_inodes < 1) |
| 514 |
min_inodes = 1; |
| 515 |
min_clusters = avefreec - EXT4_CLUSTERS_PER_GROUP(sb)*flex_size / 4; |
| 516 |
if (min_clusters < 0) |
| 517 |
min_clusters = 0; |
| 518 |
|
| 519 |
/* |
| 520 |
* Start looking in the flex group where we last allocated an |
| 521 |
* inode for this parent directory |
| 522 |
*/ |
| 523 |
if (EXT4_I(parent)->i_last_alloc_group != ~0) { |
| 524 |
parent_group = EXT4_I(parent)->i_last_alloc_group; |
| 525 |
if (flex_size > 1) |
| 526 |
parent_group >>= sbi->s_log_groups_per_flex; |
| 527 |
} |
| 528 |
|
| 529 |
for (i = 0; i < ngroups; i++) { |
| 530 |
grp = (parent_group + i) % ngroups; |
| 531 |
get_orlov_stats(sb, grp, flex_size, &stats); |
| 532 |
if (stats.used_dirs >= max_dirs) |
| 533 |
continue; |
| 534 |
if (stats.free_inodes < min_inodes) |
| 535 |
continue; |
| 536 |
if (stats.free_clusters < min_clusters) |
| 537 |
continue; |
| 538 |
goto found_flex_bg; |
| 539 |
} |
| 540 |
|
| 541 |
fallback: |
| 542 |
ngroups = real_ngroups; |
| 543 |
avefreei = freei / ngroups; |
| 544 |
fallback_retry: |
| 545 |
parent_group = EXT4_I(parent)->i_block_group; |
| 546 |
for (i = 0; i < ngroups; i++) { |
| 547 |
grp = (parent_group + i) % ngroups; |
| 548 |
desc = ext4_get_group_desc(sb, grp, NULL); |
| 549 |
if (desc) { |
| 550 |
grp_free = ext4_free_inodes_count(sb, desc); |
| 551 |
if (grp_free && grp_free >= avefreei) { |
| 552 |
*group = grp; |
| 553 |
return 0; |
| 554 |
} |
| 555 |
} |
| 556 |
} |
| 557 |
|
| 558 |
if (avefreei) { |
| 559 |
/* |
| 560 |
* The free-inodes counter is approximate, and for really small |
| 561 |
* filesystems the above test can fail to find any blockgroups |
| 562 |
*/ |
| 563 |
avefreei = 0; |
| 564 |
goto fallback_retry; |
| 565 |
} |
| 566 |
|
| 567 |
return -1; |
| 568 |
} |
| 569 |
|
| 570 |
static int find_group_other(struct super_block *sb, struct inode *parent, |
| 571 |
ext4_group_t *group, umode_t mode) |
| 572 |
{ |
| 573 |
ext4_group_t parent_group = EXT4_I(parent)->i_block_group; |
| 574 |
ext4_group_t i, last, ngroups = ext4_get_groups_count(sb); |
| 575 |
struct ext4_group_desc *desc; |
| 576 |
int flex_size = ext4_flex_bg_size(EXT4_SB(sb)); |
| 577 |
|
| 578 |
/* |
| 579 |
* Try to place the inode is the same flex group as its |
| 580 |
* parent. If we can't find space, use the Orlov algorithm to |
| 581 |
* find another flex group, and store that information in the |
| 582 |
* parent directory's inode information so that use that flex |
| 583 |
* group for future allocations. |
| 584 |
*/ |
| 585 |
if (flex_size > 1) { |
| 586 |
int retry = 0; |
| 587 |
|
| 588 |
try_again: |
| 589 |
parent_group &= ~(flex_size-1); |
| 590 |
last = parent_group + flex_size; |
| 591 |
if (last > ngroups) |
| 592 |
last = ngroups; |
| 593 |
for (i = parent_group; i < last; i++) { |
| 594 |
desc = ext4_get_group_desc(sb, i, NULL); |
| 595 |
if (desc && ext4_free_inodes_count(sb, desc)) { |
| 596 |
*group = i; |
| 597 |
return 0; |
| 598 |
} |
| 599 |
} |
| 600 |
if (!retry && EXT4_I(parent)->i_last_alloc_group != ~0) { |
| 601 |
retry = 1; |
| 602 |
parent_group = EXT4_I(parent)->i_last_alloc_group; |
| 603 |
goto try_again; |
| 604 |
} |
| 605 |
/* |
| 606 |
* If this didn't work, use the Orlov search algorithm |
| 607 |
* to find a new flex group; we pass in the mode to |
| 608 |
* avoid the topdir algorithms. |
| 609 |
*/ |
| 610 |
*group = parent_group + flex_size; |
| 611 |
if (*group > ngroups) |
| 612 |
*group = 0; |
| 613 |
return find_group_orlov(sb, parent, group, mode, NULL); |
| 614 |
} |
| 615 |
|
| 616 |
/* |
| 617 |
* Try to place the inode in its parent directory |
| 618 |
*/ |
| 619 |
*group = parent_group; |
| 620 |
desc = ext4_get_group_desc(sb, *group, NULL); |
| 621 |
if (desc && ext4_free_inodes_count(sb, desc) && |
| 622 |
ext4_free_group_clusters(sb, desc)) |
| 623 |
return 0; |
| 624 |
|
| 625 |
/* |
| 626 |
* We're going to place this inode in a different blockgroup from its |
| 627 |
* parent. We want to cause files in a common directory to all land in |
| 628 |
* the same blockgroup. But we want files which are in a different |
| 629 |
* directory which shares a blockgroup with our parent to land in a |
| 630 |
* different blockgroup. |
| 631 |
* |
| 632 |
* So add our directory's i_ino into the starting point for the hash. |
| 633 |
*/ |
| 634 |
*group = (*group + parent->i_ino) % ngroups; |
| 635 |
|
| 636 |
/* |
| 637 |
* Use a quadratic hash to find a group with a free inode and some free |
| 638 |
* blocks. |
| 639 |
*/ |
| 640 |
for (i = 1; i < ngroups; i <<= 1) { |
| 641 |
*group += i; |
| 642 |
if (*group >= ngroups) |
| 643 |
*group -= ngroups; |
| 644 |
desc = ext4_get_group_desc(sb, *group, NULL); |
| 645 |
if (desc && ext4_free_inodes_count(sb, desc) && |
| 646 |
ext4_free_group_clusters(sb, desc)) |
| 647 |
return 0; |
| 648 |
} |
| 649 |
|
| 650 |
/* |
| 651 |
* That failed: try linear search for a free inode, even if that group |
| 652 |
* has no free blocks. |
| 653 |
*/ |
| 654 |
*group = parent_group; |
| 655 |
for (i = 0; i < ngroups; i++) { |
| 656 |
if (++*group >= ngroups) |
| 657 |
*group = 0; |
| 658 |
desc = ext4_get_group_desc(sb, *group, NULL); |
| 659 |
if (desc && ext4_free_inodes_count(sb, desc)) |
| 660 |
return 0; |
| 661 |
} |
| 662 |
|
| 663 |
return -1; |
| 664 |
} |
| 665 |
|
| 666 |
/* |
| 667 |
* In no journal mode, if an inode has recently been deleted, we want |
| 668 |
* to avoid reusing it until we're reasonably sure the inode table |
| 669 |
* block has been written back to disk. (Yes, these values are |
| 670 |
* somewhat arbitrary...) |
| 671 |
*/ |
| 672 |
#define RECENTCY_MIN 60 |
| 673 |
#define RECENTCY_DIRTY 300 |
| 674 |
|
| 675 |
static int recently_deleted(struct super_block *sb, ext4_group_t group, int ino) |
| 676 |
{ |
| 677 |
struct ext4_group_desc *gdp; |
| 678 |
struct ext4_inode *raw_inode; |
| 679 |
struct buffer_head *bh; |
| 680 |
int inodes_per_block = EXT4_SB(sb)->s_inodes_per_block; |
| 681 |
int offset, ret = 0; |
| 682 |
int recentcy = RECENTCY_MIN; |
| 683 |
u32 dtime, now; |
| 684 |
|
| 685 |
gdp = ext4_get_group_desc(sb, group, NULL); |
| 686 |
if (unlikely(!gdp)) |
| 687 |
return 0; |
| 688 |
|
| 689 |
/* Inode was never used in this filesystem? */ |
| 690 |
if (ext4_has_group_desc_csum(sb) && |
| 691 |
(gdp->bg_flags & cpu_to_le16(EXT4_BG_INODE_UNINIT) || |
| 692 |
ino >= EXT4_INODES_PER_GROUP(sb) - ext4_itable_unused_count(sb, gdp))) |
| 693 |
return 0; |
| 694 |
|
| 695 |
bh = sb_find_get_block(sb, ext4_inode_table(sb, gdp) + |
| 696 |
(ino / inodes_per_block)); |
| 697 |
if (!bh || !buffer_uptodate(bh)) |
| 698 |
/* |
| 699 |
* If the block is not in the buffer cache, then it |
| 700 |
* must have been written out, or, most unlikely, is |
| 701 |
* being migrated - false failure should be OK here. |
| 702 |
*/ |
| 703 |
goto out; |
| 704 |
|
| 705 |
offset = (ino % inodes_per_block) * EXT4_INODE_SIZE(sb); |
| 706 |
raw_inode = (struct ext4_inode *) (bh->b_data + offset); |
| 707 |
|
| 708 |
/* i_dtime is only 32 bits on disk, but we only care about relative |
| 709 |
* times in the range of a few minutes (i.e. long enough to sync a |
| 710 |
* recently-deleted inode to disk), so using the low 32 bits of the |
| 711 |
* clock (a 68 year range) is enough, see time_before32() */ |
| 712 |
dtime = le32_to_cpu(raw_inode->i_dtime); |
| 713 |
now = ktime_get_real_seconds(); |
| 714 |
if (buffer_dirty(bh)) |
| 715 |
recentcy += RECENTCY_DIRTY; |
| 716 |
|
| 717 |
if (dtime && time_before32(dtime, now) && |
| 718 |
time_before32(now, dtime + recentcy)) |
| 719 |
ret = 1; |
| 720 |
out: |
| 721 |
brelse(bh); |
| 722 |
return ret; |
| 723 |
} |
| 724 |
|
| 725 |
static int find_inode_bit(struct super_block *sb, ext4_group_t group, |
| 726 |
struct buffer_head *bitmap, unsigned long *ino) |
| 727 |
{ |
| 728 |
bool check_recently_deleted = EXT4_SB(sb)->s_journal == NULL; |
| 729 |
unsigned long recently_deleted_ino = EXT4_INODES_PER_GROUP(sb); |
| 730 |
|
| 731 |
next: |
| 732 |
*ino = ext4_find_next_zero_bit((unsigned long *) |
| 733 |
bitmap->b_data, |
| 734 |
EXT4_INODES_PER_GROUP(sb), *ino); |
| 735 |
if (*ino >= EXT4_INODES_PER_GROUP(sb)) |
| 736 |
goto not_found; |
| 737 |
|
| 738 |
if (check_recently_deleted && recently_deleted(sb, group, *ino)) { |
| 739 |
recently_deleted_ino = *ino; |
| 740 |
*ino = *ino + 1; |
| 741 |
if (*ino < EXT4_INODES_PER_GROUP(sb)) |
| 742 |
goto next; |
| 743 |
goto not_found; |
| 744 |
} |
| 745 |
return 1; |
| 746 |
not_found: |
| 747 |
if (recently_deleted_ino >= EXT4_INODES_PER_GROUP(sb)) |
| 748 |
return 0; |
| 749 |
/* |
| 750 |
* Not reusing recently deleted inodes is mostly a preference. We don't |
| 751 |
* want to report ENOSPC or skew allocation patterns because of that. |
| 752 |
* So return even recently deleted inode if we could find better in the |
| 753 |
* given range. |
| 754 |
*/ |
| 755 |
*ino = recently_deleted_ino; |
| 756 |
return 1; |
| 757 |
} |
| 758 |
|
| 759 |
int ext4_mark_inode_used(struct super_block *sb, int ino) |
| 760 |
{ |
| 761 |
unsigned long max_ino = le32_to_cpu(EXT4_SB(sb)->s_es->s_inodes_count); |
| 762 |
struct buffer_head *inode_bitmap_bh = NULL, *group_desc_bh = NULL; |
| 763 |
struct ext4_group_desc *gdp; |
| 764 |
ext4_group_t group; |
| 765 |
int bit; |
| 766 |
int err; |
| 767 |
|
| 768 |
if (ino < EXT4_FIRST_INO(sb) || ino > max_ino) |
| 769 |
return -EFSCORRUPTED; |
| 770 |
|
| 771 |
group = (ino - 1) / EXT4_INODES_PER_GROUP(sb); |
| 772 |
bit = (ino - 1) % EXT4_INODES_PER_GROUP(sb); |
| 773 |
inode_bitmap_bh = ext4_read_inode_bitmap(sb, group); |
| 774 |
if (IS_ERR(inode_bitmap_bh)) |
| 775 |
return PTR_ERR(inode_bitmap_bh); |
| 776 |
|
| 777 |
if (ext4_test_bit(bit, inode_bitmap_bh->b_data)) { |
| 778 |
err = 0; |
| 779 |
goto out; |
| 780 |
} |
| 781 |
|
| 782 |
gdp = ext4_get_group_desc(sb, group, &group_desc_bh); |
| 783 |
if (!gdp) { |
| 784 |
err = -EINVAL; |
| 785 |
goto out; |
| 786 |
} |
| 787 |
|
| 788 |
ext4_set_bit(bit, inode_bitmap_bh->b_data); |
| 789 |
|
| 790 |
BUFFER_TRACE(inode_bitmap_bh, "call ext4_handle_dirty_metadata"); |
| 791 |
err = ext4_handle_dirty_metadata(NULL, NULL, inode_bitmap_bh); |
| 792 |
if (err) { |
| 793 |
ext4_std_error(sb, err); |
| 794 |
goto out; |
| 795 |
} |
| 796 |
err = sync_dirty_buffer(inode_bitmap_bh); |
| 797 |
if (err) { |
| 798 |
ext4_std_error(sb, err); |
| 799 |
goto out; |
| 800 |
} |
| 801 |
|
| 802 |
/* We may have to initialize the block bitmap if it isn't already */ |
| 803 |
if (ext4_has_group_desc_csum(sb) && |
| 804 |
gdp->bg_flags & cpu_to_le16(EXT4_BG_BLOCK_UNINIT)) { |
| 805 |
struct buffer_head *block_bitmap_bh; |
| 806 |
|
| 807 |
block_bitmap_bh = ext4_read_block_bitmap(sb, group); |
| 808 |
if (IS_ERR(block_bitmap_bh)) { |
| 809 |
err = PTR_ERR(block_bitmap_bh); |
| 810 |
goto out; |
| 811 |
} |
| 812 |
|
| 813 |
BUFFER_TRACE(block_bitmap_bh, "dirty block bitmap"); |
| 814 |
err = ext4_handle_dirty_metadata(NULL, NULL, block_bitmap_bh); |
| 815 |
sync_dirty_buffer(block_bitmap_bh); |
| 816 |
|
| 817 |
/* recheck and clear flag under lock if we still need to */ |
| 818 |
ext4_lock_group(sb, group); |
| 819 |
if (ext4_has_group_desc_csum(sb) && |
| 820 |
(gdp->bg_flags & cpu_to_le16(EXT4_BG_BLOCK_UNINIT))) { |
| 821 |
gdp->bg_flags &= cpu_to_le16(~EXT4_BG_BLOCK_UNINIT); |
| 822 |
ext4_free_group_clusters_set(sb, gdp, |
| 823 |
ext4_free_clusters_after_init(sb, group, gdp)); |
| 824 |
ext4_block_bitmap_csum_set(sb, gdp, block_bitmap_bh); |
| 825 |
ext4_group_desc_csum_set(sb, group, gdp); |
| 826 |
} |
| 827 |
ext4_unlock_group(sb, group); |
| 828 |
brelse(block_bitmap_bh); |
| 829 |
|
| 830 |
if (err) { |
| 831 |
ext4_std_error(sb, err); |
| 832 |
goto out; |
| 833 |
} |
| 834 |
} |
| 835 |
|
| 836 |
/* Update the relevant bg descriptor fields */ |
| 837 |
if (ext4_has_group_desc_csum(sb)) { |
| 838 |
int free; |
| 839 |
|
| 840 |
ext4_lock_group(sb, group); /* while we modify the bg desc */ |
| 841 |
free = EXT4_INODES_PER_GROUP(sb) - |
| 842 |
ext4_itable_unused_count(sb, gdp); |
| 843 |
if (gdp->bg_flags & cpu_to_le16(EXT4_BG_INODE_UNINIT)) { |
| 844 |
gdp->bg_flags &= cpu_to_le16(~EXT4_BG_INODE_UNINIT); |
| 845 |
free = 0; |
| 846 |
} |
| 847 |
|
| 848 |
/* |
| 849 |
* Check the relative inode number against the last used |
| 850 |
* relative inode number in this group. if it is greater |
| 851 |
* we need to update the bg_itable_unused count |
| 852 |
*/ |
| 853 |
if (bit >= free) |
| 854 |
ext4_itable_unused_set(sb, gdp, |
| 855 |
(EXT4_INODES_PER_GROUP(sb) - bit - 1)); |
| 856 |
} else { |
| 857 |
ext4_lock_group(sb, group); |
| 858 |
} |
| 859 |
|
| 860 |
ext4_free_inodes_set(sb, gdp, ext4_free_inodes_count(sb, gdp) - 1); |
| 861 |
if (ext4_has_group_desc_csum(sb)) { |
| 862 |
ext4_inode_bitmap_csum_set(sb, gdp, inode_bitmap_bh); |
| 863 |
ext4_group_desc_csum_set(sb, group, gdp); |
| 864 |
} |
| 865 |
|
| 866 |
ext4_unlock_group(sb, group); |
| 867 |
err = ext4_handle_dirty_metadata(NULL, NULL, group_desc_bh); |
| 868 |
sync_dirty_buffer(group_desc_bh); |
| 869 |
out: |
| 870 |
brelse(inode_bitmap_bh); |
| 871 |
return err; |
| 872 |
} |
| 873 |
|
| 874 |
static int ext4_xattr_credits_for_new_inode(struct inode *dir, mode_t mode, |
| 875 |
bool encrypt) |
| 876 |
{ |
| 877 |
struct super_block *sb = dir->i_sb; |
| 878 |
int nblocks = 0; |
| 879 |
#ifdef CONFIG_EXT4_FS_POSIX_ACL |
| 880 |
struct posix_acl *p = get_inode_acl(dir, ACL_TYPE_DEFAULT); |
| 881 |
|
| 882 |
if (IS_ERR(p)) |
| 883 |
return PTR_ERR(p); |
| 884 |
if (p) { |
| 885 |
int acl_size = p->a_count * sizeof(ext4_acl_entry); |
| 886 |
|
| 887 |
nblocks += (S_ISDIR(mode) ? 2 : 1) * |
| 888 |
__ext4_xattr_set_credits(sb, NULL /* inode */, |
| 889 |
NULL /* block_bh */, acl_size, |
| 890 |
true /* is_create */); |
| 891 |
posix_acl_release(p); |
| 892 |
} |
| 893 |
#endif |
| 894 |
|
| 895 |
#ifdef CONFIG_SECURITY |
| 896 |
{ |
| 897 |
int num_security_xattrs = 1; |
| 898 |
|
| 899 |
#ifdef CONFIG_INTEGRITY |
| 900 |
num_security_xattrs++; |
| 901 |
#endif |
| 902 |
/* |
| 903 |
* We assume that security xattrs are never more than 1k. |
| 904 |
* In practice they are under 128 bytes. |
| 905 |
*/ |
| 906 |
nblocks += num_security_xattrs * |
| 907 |
__ext4_xattr_set_credits(sb, NULL /* inode */, |
| 908 |
NULL /* block_bh */, 1024, |
| 909 |
true /* is_create */); |
| 910 |
} |
| 911 |
#endif |
| 912 |
if (encrypt) |
| 913 |
nblocks += __ext4_xattr_set_credits(sb, |
| 914 |
NULL /* inode */, |
| 915 |
NULL /* block_bh */, |
| 916 |
FSCRYPT_SET_CONTEXT_MAX_SIZE, |
| 917 |
true /* is_create */); |
| 918 |
return nblocks; |
| 919 |
} |
| 920 |
|
| 921 |
/* |
| 922 |
* There are two policies for allocating an inode. If the new inode is |
| 923 |
* a directory, then a forward search is made for a block group with both |
| 924 |
* free space and a low directory-to-inode ratio; if that fails, then of |
| 925 |
* the groups with above-average free space, that group with the fewest |
| 926 |
* directories already is chosen. |
| 927 |
* |
| 928 |
* For other inodes, search forward from the parent directory's block |
| 929 |
* group to find a free inode. |
| 930 |
*/ |
| 931 |
struct inode *__ext4_new_inode(struct mnt_idmap *idmap, |
| 932 |
handle_t *handle, struct inode *dir, |
| 933 |
umode_t mode, const struct qstr *qstr, |
| 934 |
__u32 goal, uid_t *owner, __u32 i_flags, |
| 935 |
int handle_type, unsigned int line_no, |
| 936 |
int nblocks) |
| 937 |
{ |
| 938 |
struct super_block *sb; |
| 939 |
struct buffer_head *inode_bitmap_bh = NULL; |
| 940 |
struct buffer_head *group_desc_bh; |
| 941 |
ext4_group_t ngroups, group = 0; |
| 942 |
unsigned long ino = 0; |
| 943 |
struct inode *inode; |
| 944 |
struct ext4_group_desc *gdp = NULL; |
| 945 |
struct ext4_inode_info *ei; |
| 946 |
struct ext4_sb_info *sbi; |
| 947 |
int ret2, err; |
| 948 |
struct inode *ret; |
| 949 |
ext4_group_t i; |
| 950 |
ext4_group_t flex_group; |
| 951 |
struct ext4_group_info *grp = NULL; |
| 952 |
bool encrypt = false; |
| 953 |
|
| 954 |
/* Cannot create files in a deleted directory */ |
| 955 |
if (!dir || !dir->i_nlink) |
| 956 |
return ERR_PTR(-EPERM); |
| 957 |
|
| 958 |
sb = dir->i_sb; |
| 959 |
sbi = EXT4_SB(sb); |
| 960 |
|
| 961 |
ret2 = ext4_emergency_state(sb); |
| 962 |
if (unlikely(ret2)) |
| 963 |
return ERR_PTR(ret2); |
| 964 |
|
| 965 |
ngroups = ext4_get_groups_count(sb); |
| 966 |
trace_ext4_request_inode(dir, mode); |
| 967 |
inode = new_inode(sb); |
| 968 |
if (!inode) |
| 969 |
return ERR_PTR(-ENOMEM); |
| 970 |
ei = EXT4_I(inode); |
| 971 |
|
| 972 |
/* |
| 973 |
* Initialize owners and quota early so that we don't have to account |
| 974 |
* for quota initialization worst case in standard inode creating |
| 975 |
* transaction |
| 976 |
*/ |
| 977 |
if (owner) { |
| 978 |
inode->i_mode = mode; |
| 979 |
i_uid_write(inode, owner[0]); |
| 980 |
i_gid_write(inode, owner[1]); |
| 981 |
} else if (test_opt(sb, GRPID)) { |
| 982 |
inode->i_mode = mode; |
| 983 |
inode_fsuid_set(inode, idmap); |
| 984 |
inode->i_gid = dir->i_gid; |
| 985 |
} else |
| 986 |
inode_init_owner(idmap, inode, dir, mode); |
| 987 |
|
| 988 |
if (ext4_has_feature_project(sb) && |
| 989 |
ext4_test_inode_flag(dir, EXT4_INODE_PROJINHERIT)) |
| 990 |
ei->i_projid = EXT4_I(dir)->i_projid; |
| 991 |
else |
| 992 |
ei->i_projid = make_kprojid(&init_user_ns, EXT4_DEF_PROJID); |
| 993 |
|
| 994 |
if (!(i_flags & EXT4_EA_INODE_FL)) { |
| 995 |
err = fscrypt_prepare_new_inode(dir, inode, &encrypt); |
| 996 |
if (err) |
| 997 |
goto out; |
| 998 |
} |
| 999 |
|
| 1000 |
err = dquot_initialize(inode); |
| 1001 |
if (err) |
| 1002 |
goto out; |
| 1003 |
|
| 1004 |
if (!handle && sbi->s_journal && !(i_flags & EXT4_EA_INODE_FL)) { |
| 1005 |
ret2 = ext4_xattr_credits_for_new_inode(dir, mode, encrypt); |
| 1006 |
if (ret2 < 0) { |
| 1007 |
err = ret2; |
| 1008 |
goto out; |
| 1009 |
} |
| 1010 |
nblocks += ret2; |
| 1011 |
} |
| 1012 |
|
| 1013 |
if (!goal) |
| 1014 |
goal = sbi->s_inode_goal; |
| 1015 |
|
| 1016 |
if (goal && goal <= le32_to_cpu(sbi->s_es->s_inodes_count)) { |
| 1017 |
group = (goal - 1) / EXT4_INODES_PER_GROUP(sb); |
| 1018 |
ino = (goal - 1) % EXT4_INODES_PER_GROUP(sb); |
| 1019 |
ret2 = 0; |
| 1020 |
goto got_group; |
| 1021 |
} |
| 1022 |
|
| 1023 |
if (S_ISDIR(mode)) |
| 1024 |
ret2 = find_group_orlov(sb, dir, &group, mode, qstr); |
| 1025 |
else |
| 1026 |
ret2 = find_group_other(sb, dir, &group, mode); |
| 1027 |
|
| 1028 |
got_group: |
| 1029 |
EXT4_I(dir)->i_last_alloc_group = group; |
| 1030 |
err = -ENOSPC; |
| 1031 |
if (ret2 == -1) |
| 1032 |
goto out; |
| 1033 |
|
| 1034 |
/* |
| 1035 |
* Normally we will only go through one pass of this loop, |
| 1036 |
* unless we get unlucky and it turns out the group we selected |
| 1037 |
* had its last inode grabbed by someone else. |
| 1038 |
*/ |
| 1039 |
for (i = 0; i < ngroups; i++, ino = 0) { |
| 1040 |
err = -EIO; |
| 1041 |
|
| 1042 |
gdp = ext4_get_group_desc(sb, group, &group_desc_bh); |
| 1043 |
if (!gdp) |
| 1044 |
goto out; |
| 1045 |
|
| 1046 |
/* |
| 1047 |
* Check free inodes count before loading bitmap. |
| 1048 |
*/ |
| 1049 |
if (ext4_free_inodes_count(sb, gdp) == 0) |
| 1050 |
goto next_group; |
| 1051 |
|
| 1052 |
if (!(sbi->s_mount_state & EXT4_FC_REPLAY)) { |
| 1053 |
grp = ext4_get_group_info(sb, group); |
| 1054 |
/* |
| 1055 |
* Skip groups with already-known suspicious inode |
| 1056 |
* tables |
| 1057 |
*/ |
| 1058 |
if (!grp || EXT4_MB_GRP_IBITMAP_CORRUPT(grp)) |
| 1059 |
goto next_group; |
| 1060 |
} |
| 1061 |
|
| 1062 |
brelse(inode_bitmap_bh); |
| 1063 |
inode_bitmap_bh = ext4_read_inode_bitmap(sb, group); |
| 1064 |
/* Skip groups with suspicious inode tables */ |
| 1065 |
if (IS_ERR(inode_bitmap_bh)) { |
| 1066 |
inode_bitmap_bh = NULL; |
| 1067 |
goto next_group; |
| 1068 |
} |
| 1069 |
if (!(sbi->s_mount_state & EXT4_FC_REPLAY) && |
| 1070 |
EXT4_MB_GRP_IBITMAP_CORRUPT(grp)) |
| 1071 |
goto next_group; |
| 1072 |
|
| 1073 |
ret2 = find_inode_bit(sb, group, inode_bitmap_bh, &ino); |
| 1074 |
if (!ret2) |
| 1075 |
goto next_group; |
| 1076 |
|
| 1077 |
if (group == 0 && (ino + 1) < EXT4_FIRST_INO(sb)) { |
| 1078 |
ext4_error(sb, "reserved inode found cleared - " |
| 1079 |
"inode=%lu", ino + 1); |
| 1080 |
ext4_mark_group_bitmap_corrupted(sb, group, |
| 1081 |
EXT4_GROUP_INFO_IBITMAP_CORRUPT); |
| 1082 |
goto next_group; |
| 1083 |
} |
| 1084 |
|
| 1085 |
if ((!(sbi->s_mount_state & EXT4_FC_REPLAY)) && !handle) { |
| 1086 |
BUG_ON(nblocks <= 0); |
| 1087 |
handle = __ext4_journal_start_sb(NULL, dir->i_sb, |
| 1088 |
line_no, handle_type, nblocks, 0, |
| 1089 |
ext4_trans_default_revoke_credits(sb)); |
| 1090 |
if (IS_ERR(handle)) { |
| 1091 |
err = PTR_ERR(handle); |
| 1092 |
ext4_std_error(sb, err); |
| 1093 |
goto out; |
| 1094 |
} |
| 1095 |
} |
| 1096 |
BUFFER_TRACE(inode_bitmap_bh, "get_write_access"); |
| 1097 |
err = ext4_journal_get_write_access(handle, sb, inode_bitmap_bh, |
| 1098 |
EXT4_JTR_NONE); |
| 1099 |
if (err) { |
| 1100 |
ext4_std_error(sb, err); |
| 1101 |
goto out; |
| 1102 |
} |
| 1103 |
ext4_lock_group(sb, group); |
| 1104 |
ret2 = ext4_test_and_set_bit(ino, inode_bitmap_bh->b_data); |
| 1105 |
if (ret2) { |
| 1106 |
/* Someone already took the bit. Repeat the search |
| 1107 |
* with lock held. |
| 1108 |
*/ |
| 1109 |
ret2 = find_inode_bit(sb, group, inode_bitmap_bh, &ino); |
| 1110 |
if (ret2) { |
| 1111 |
ext4_set_bit(ino, inode_bitmap_bh->b_data); |
| 1112 |
ret2 = 0; |
| 1113 |
} else { |
| 1114 |
ret2 = 1; /* we didn't grab the inode */ |
| 1115 |
} |
| 1116 |
} |
| 1117 |
ext4_unlock_group(sb, group); |
| 1118 |
ino++; /* the inode bitmap is zero-based */ |
| 1119 |
if (!ret2) |
| 1120 |
goto got; /* we grabbed the inode! */ |
| 1121 |
|
| 1122 |
next_group: |
| 1123 |
if (++group == ngroups) |
| 1124 |
group = 0; |
| 1125 |
} |
| 1126 |
err = -ENOSPC; |
| 1127 |
goto out; |
| 1128 |
|
| 1129 |
got: |
| 1130 |
BUFFER_TRACE(inode_bitmap_bh, "call ext4_handle_dirty_metadata"); |
| 1131 |
err = ext4_handle_dirty_metadata(handle, NULL, inode_bitmap_bh); |
| 1132 |
if (err) { |
| 1133 |
ext4_std_error(sb, err); |
| 1134 |
goto out; |
| 1135 |
} |
| 1136 |
|
| 1137 |
BUFFER_TRACE(group_desc_bh, "get_write_access"); |
| 1138 |
err = ext4_journal_get_write_access(handle, sb, group_desc_bh, |
| 1139 |
EXT4_JTR_NONE); |
| 1140 |
if (err) { |
| 1141 |
ext4_std_error(sb, err); |
| 1142 |
goto out; |
| 1143 |
} |
| 1144 |
|
| 1145 |
/* We may have to initialize the block bitmap if it isn't already */ |
| 1146 |
if (ext4_has_group_desc_csum(sb) && |
| 1147 |
gdp->bg_flags & cpu_to_le16(EXT4_BG_BLOCK_UNINIT)) { |
| 1148 |
struct buffer_head *block_bitmap_bh; |
| 1149 |
|
| 1150 |
block_bitmap_bh = ext4_read_block_bitmap(sb, group); |
| 1151 |
if (IS_ERR(block_bitmap_bh)) { |
| 1152 |
err = PTR_ERR(block_bitmap_bh); |
| 1153 |
goto out; |
| 1154 |
} |
| 1155 |
BUFFER_TRACE(block_bitmap_bh, "get block bitmap access"); |
| 1156 |
err = ext4_journal_get_write_access(handle, sb, block_bitmap_bh, |
| 1157 |
EXT4_JTR_NONE); |
| 1158 |
if (err) { |
| 1159 |
brelse(block_bitmap_bh); |
| 1160 |
ext4_std_error(sb, err); |
| 1161 |
goto out; |
| 1162 |
} |
| 1163 |
|
| 1164 |
BUFFER_TRACE(block_bitmap_bh, "dirty block bitmap"); |
| 1165 |
err = ext4_handle_dirty_metadata(handle, NULL, block_bitmap_bh); |
| 1166 |
|
| 1167 |
/* recheck and clear flag under lock if we still need to */ |
| 1168 |
ext4_lock_group(sb, group); |
| 1169 |
if (ext4_has_group_desc_csum(sb) && |
| 1170 |
(gdp->bg_flags & cpu_to_le16(EXT4_BG_BLOCK_UNINIT))) { |
| 1171 |
gdp->bg_flags &= cpu_to_le16(~EXT4_BG_BLOCK_UNINIT); |
| 1172 |
ext4_free_group_clusters_set(sb, gdp, |
| 1173 |
ext4_free_clusters_after_init(sb, group, gdp)); |
| 1174 |
ext4_block_bitmap_csum_set(sb, gdp, block_bitmap_bh); |
| 1175 |
ext4_group_desc_csum_set(sb, group, gdp); |
| 1176 |
} |
| 1177 |
ext4_unlock_group(sb, group); |
| 1178 |
brelse(block_bitmap_bh); |
| 1179 |
|
| 1180 |
if (err) { |
| 1181 |
ext4_std_error(sb, err); |
| 1182 |
goto out; |
| 1183 |
} |
| 1184 |
} |
| 1185 |
|
| 1186 |
/* Update the relevant bg descriptor fields */ |
| 1187 |
if (ext4_has_group_desc_csum(sb)) { |
| 1188 |
int free; |
| 1189 |
struct ext4_group_info *grp = NULL; |
| 1190 |
|
| 1191 |
if (!(sbi->s_mount_state & EXT4_FC_REPLAY)) { |
| 1192 |
grp = ext4_get_group_info(sb, group); |
| 1193 |
if (!grp) { |
| 1194 |
err = -EFSCORRUPTED; |
| 1195 |
goto out; |
| 1196 |
} |
| 1197 |
down_read(&grp->alloc_sem); /* |
| 1198 |
* protect vs itable |
| 1199 |
* lazyinit |
| 1200 |
*/ |
| 1201 |
} |
| 1202 |
ext4_lock_group(sb, group); /* while we modify the bg desc */ |
| 1203 |
free = EXT4_INODES_PER_GROUP(sb) - |
| 1204 |
ext4_itable_unused_count(sb, gdp); |
| 1205 |
if (gdp->bg_flags & cpu_to_le16(EXT4_BG_INODE_UNINIT)) { |
| 1206 |
gdp->bg_flags &= cpu_to_le16(~EXT4_BG_INODE_UNINIT); |
| 1207 |
free = 0; |
| 1208 |
} |
| 1209 |
/* |
| 1210 |
* Check the relative inode number against the last used |
| 1211 |
* relative inode number in this group. if it is greater |
| 1212 |
* we need to update the bg_itable_unused count |
| 1213 |
*/ |
| 1214 |
if (ino > free) |
| 1215 |
ext4_itable_unused_set(sb, gdp, |
| 1216 |
(EXT4_INODES_PER_GROUP(sb) - ino)); |
| 1217 |
if (!(sbi->s_mount_state & EXT4_FC_REPLAY)) |
| 1218 |
up_read(&grp->alloc_sem); |
| 1219 |
} else { |
| 1220 |
ext4_lock_group(sb, group); |
| 1221 |
} |
| 1222 |
|
| 1223 |
ext4_free_inodes_set(sb, gdp, ext4_free_inodes_count(sb, gdp) - 1); |
| 1224 |
if (S_ISDIR(mode)) { |
| 1225 |
ext4_used_dirs_set(sb, gdp, ext4_used_dirs_count(sb, gdp) + 1); |
| 1226 |
if (sbi->s_log_groups_per_flex) { |
| 1227 |
ext4_group_t f = ext4_flex_group(sbi, group); |
| 1228 |
|
| 1229 |
atomic_inc(&sbi_array_rcu_deref(sbi, s_flex_groups, |
| 1230 |
f)->used_dirs); |
| 1231 |
} |
| 1232 |
} |
| 1233 |
if (ext4_has_group_desc_csum(sb)) { |
| 1234 |
ext4_inode_bitmap_csum_set(sb, gdp, inode_bitmap_bh); |
| 1235 |
ext4_group_desc_csum_set(sb, group, gdp); |
| 1236 |
} |
| 1237 |
ext4_unlock_group(sb, group); |
| 1238 |
|
| 1239 |
BUFFER_TRACE(group_desc_bh, "call ext4_handle_dirty_metadata"); |
| 1240 |
err = ext4_handle_dirty_metadata(handle, NULL, group_desc_bh); |
| 1241 |
if (err) { |
| 1242 |
ext4_std_error(sb, err); |
| 1243 |
goto out; |
| 1244 |
} |
| 1245 |
|
| 1246 |
percpu_counter_dec(&sbi->s_freeinodes_counter); |
| 1247 |
if (S_ISDIR(mode)) |
| 1248 |
percpu_counter_inc(&sbi->s_dirs_counter); |
| 1249 |
|
| 1250 |
if (sbi->s_log_groups_per_flex) { |
| 1251 |
flex_group = ext4_flex_group(sbi, group); |
| 1252 |
atomic_dec(&sbi_array_rcu_deref(sbi, s_flex_groups, |
| 1253 |
flex_group)->free_inodes); |
| 1254 |
} |
| 1255 |
|
| 1256 |
inode->i_ino = ino + group * EXT4_INODES_PER_GROUP(sb); |
| 1257 |
/* This is the optimal IO size (for stat), not the fs block size */ |
| 1258 |
inode->i_blocks = 0; |
| 1259 |
simple_inode_init_ts(inode); |
| 1260 |
ei->i_crtime = inode_get_mtime(inode); |
| 1261 |
|
| 1262 |
memset(ei->i_data, 0, sizeof(ei->i_data)); |
| 1263 |
ei->i_dir_start_lookup = 0; |
| 1264 |
ei->i_disksize = 0; |
| 1265 |
|
| 1266 |
/* Don't inherit extent flag from directory, amongst others. */ |
| 1267 |
ei->i_flags = |
| 1268 |
ext4_mask_flags(mode, EXT4_I(dir)->i_flags & EXT4_FL_INHERITED); |
| 1269 |
ei->i_flags |= i_flags; |
| 1270 |
ei->i_file_acl = 0; |
| 1271 |
ei->i_dtime = 0; |
| 1272 |
ei->i_block_group = group; |
| 1273 |
ei->i_last_alloc_group = ~0; |
| 1274 |
|
| 1275 |
ext4_set_inode_flags(inode, true); |
| 1276 |
if (IS_DIRSYNC(inode)) |
| 1277 |
ext4_handle_sync(handle); |
| 1278 |
if (insert_inode_locked(inode) < 0) { |
| 1279 |
/* |
| 1280 |
* Likely a bitmap corruption causing inode to be allocated |
| 1281 |
* twice. |
| 1282 |
*/ |
| 1283 |
err = -EIO; |
| 1284 |
ext4_error(sb, "failed to insert inode %lu: doubly allocated?", |
| 1285 |
inode->i_ino); |
| 1286 |
ext4_mark_group_bitmap_corrupted(sb, group, |
| 1287 |
EXT4_GROUP_INFO_IBITMAP_CORRUPT); |
| 1288 |
goto out; |
| 1289 |
} |
| 1290 |
inode->i_generation = get_random_u32(); |
| 1291 |
|
| 1292 |
/* Precompute checksum seed for inode metadata */ |
| 1293 |
if (ext4_has_feature_metadata_csum(sb)) { |
| 1294 |
__u32 csum; |
| 1295 |
__le32 inum = cpu_to_le32(inode->i_ino); |
| 1296 |
__le32 gen = cpu_to_le32(inode->i_generation); |
| 1297 |
csum = ext4_chksum(sbi->s_csum_seed, (__u8 *)&inum, |
| 1298 |
sizeof(inum)); |
| 1299 |
ei->i_csum_seed = ext4_chksum(csum, (__u8 *)&gen, sizeof(gen)); |
| 1300 |
} |
| 1301 |
|
| 1302 |
ext4_set_inode_state(inode, EXT4_STATE_NEW); |
| 1303 |
|
| 1304 |
ei->i_extra_isize = sbi->s_want_extra_isize; |
| 1305 |
ei->i_inline_off = 0; |
| 1306 |
if (ext4_has_feature_inline_data(sb) && |
| 1307 |
(!(ei->i_flags & (EXT4_DAX_FL|EXT4_EA_INODE_FL)) || S_ISDIR(mode))) |
| 1308 |
ext4_set_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA); |
| 1309 |
ret = inode; |
| 1310 |
err = dquot_alloc_inode(inode); |
| 1311 |
if (err) |
| 1312 |
goto fail_drop; |
| 1313 |
|
| 1314 |
/* |
| 1315 |
* Since the encryption xattr will always be unique, create it first so |
| 1316 |
* that it's less likely to end up in an external xattr block and |
| 1317 |
* prevent its deduplication. |
| 1318 |
*/ |
| 1319 |
if (encrypt) { |
| 1320 |
err = fscrypt_set_context(inode, handle); |
| 1321 |
if (err) |
| 1322 |
goto fail_free_drop; |
| 1323 |
} |
| 1324 |
|
| 1325 |
if (!(ei->i_flags & EXT4_EA_INODE_FL)) { |
| 1326 |
err = ext4_init_acl(handle, inode, dir); |
| 1327 |
if (err) |
| 1328 |
goto fail_free_drop; |
| 1329 |
|
| 1330 |
err = ext4_init_security(handle, inode, dir, qstr); |
| 1331 |
if (err) |
| 1332 |
goto fail_free_drop; |
| 1333 |
} |
| 1334 |
|
| 1335 |
if (ext4_has_feature_extents(sb)) { |
| 1336 |
/* set extent flag only for directory, file and normal symlink*/ |
| 1337 |
if (S_ISDIR(mode) || S_ISREG(mode) || S_ISLNK(mode)) { |
| 1338 |
ext4_set_inode_flag(inode, EXT4_INODE_EXTENTS); |
| 1339 |
ext4_ext_tree_init(handle, inode); |
| 1340 |
} |
| 1341 |
} |
| 1342 |
|
| 1343 |
ext4_set_inode_mapping_order(inode); |
| 1344 |
|
| 1345 |
ext4_update_inode_fsync_trans(handle, inode, 1); |
| 1346 |
|
| 1347 |
err = ext4_mark_inode_dirty(handle, inode); |
| 1348 |
if (err) { |
| 1349 |
ext4_std_error(sb, err); |
| 1350 |
goto fail_free_drop; |
| 1351 |
} |
| 1352 |
|
| 1353 |
ext4_debug("allocating inode %lu\n", inode->i_ino); |
| 1354 |
trace_ext4_allocate_inode(inode, dir, mode); |
| 1355 |
brelse(inode_bitmap_bh); |
| 1356 |
return ret; |
| 1357 |
|
| 1358 |
fail_free_drop: |
| 1359 |
dquot_free_inode(inode); |
| 1360 |
fail_drop: |
| 1361 |
clear_nlink(inode); |
| 1362 |
unlock_new_inode(inode); |
| 1363 |
out: |
| 1364 |
dquot_drop(inode); |
| 1365 |
inode->i_flags |= S_NOQUOTA; |
| 1366 |
iput(inode); |
| 1367 |
brelse(inode_bitmap_bh); |
| 1368 |
return ERR_PTR(err); |
| 1369 |
} |
| 1370 |
|
| 1371 |
/* Verify that we are loading a valid orphan from disk */ |
| 1372 |
struct inode *ext4_orphan_get(struct super_block *sb, unsigned long ino) |
| 1373 |
{ |
| 1374 |
unsigned long max_ino = le32_to_cpu(EXT4_SB(sb)->s_es->s_inodes_count); |
| 1375 |
ext4_group_t block_group; |
| 1376 |
int bit; |
| 1377 |
struct buffer_head *bitmap_bh = NULL; |
| 1378 |
struct inode *inode = NULL; |
| 1379 |
int err = -EFSCORRUPTED; |
| 1380 |
|
| 1381 |
if (ino < EXT4_FIRST_INO(sb) || ino > max_ino) |
| 1382 |
goto bad_orphan; |
| 1383 |
|
| 1384 |
block_group = (ino - 1) / EXT4_INODES_PER_GROUP(sb); |
| 1385 |
bit = (ino - 1) % EXT4_INODES_PER_GROUP(sb); |
| 1386 |
bitmap_bh = ext4_read_inode_bitmap(sb, block_group); |
| 1387 |
if (IS_ERR(bitmap_bh)) |
| 1388 |
return ERR_CAST(bitmap_bh); |
| 1389 |
|
| 1390 |
/* Having the inode bit set should be a 100% indicator that this |
| 1391 |
* is a valid orphan (no e2fsck run on fs). Orphans also include |
| 1392 |
* inodes that were being truncated, so we can't check i_nlink==0. |
| 1393 |
*/ |
| 1394 |
if (!ext4_test_bit(bit, bitmap_bh->b_data)) |
| 1395 |
goto bad_orphan; |
| 1396 |
|
| 1397 |
inode = ext4_iget(sb, ino, EXT4_IGET_NORMAL); |
| 1398 |
if (IS_ERR(inode)) { |
| 1399 |
err = PTR_ERR(inode); |
| 1400 |
ext4_error_err(sb, -err, |
| 1401 |
"couldn't read orphan inode %lu (err %d)", |
| 1402 |
ino, err); |
| 1403 |
brelse(bitmap_bh); |
| 1404 |
return inode; |
| 1405 |
} |
| 1406 |
|
| 1407 |
/* |
| 1408 |
* If the orphans has i_nlinks > 0 then it should be able to |
| 1409 |
* be truncated, otherwise it won't be removed from the orphan |
| 1410 |
* list during processing and an infinite loop will result. |
| 1411 |
* Similarly, it must not be a bad inode. |
| 1412 |
*/ |
| 1413 |
if ((inode->i_nlink && !ext4_can_truncate(inode)) || |
| 1414 |
is_bad_inode(inode)) |
| 1415 |
goto bad_orphan; |
| 1416 |
|
| 1417 |
if (NEXT_ORPHAN(inode) > max_ino) |
| 1418 |
goto bad_orphan; |
| 1419 |
brelse(bitmap_bh); |
| 1420 |
return inode; |
| 1421 |
|
| 1422 |
bad_orphan: |
| 1423 |
ext4_error(sb, "bad orphan inode %lu", ino); |
| 1424 |
if (bitmap_bh) |
| 1425 |
printk(KERN_ERR "ext4_test_bit(bit=%d, block=%llu) = %d\n", |
| 1426 |
bit, (unsigned long long)bitmap_bh->b_blocknr, |
| 1427 |
ext4_test_bit(bit, bitmap_bh->b_data)); |
| 1428 |
if (inode) { |
| 1429 |
printk(KERN_ERR "is_bad_inode(inode)=%d\n", |
| 1430 |
is_bad_inode(inode)); |
| 1431 |
printk(KERN_ERR "NEXT_ORPHAN(inode)=%u\n", |
| 1432 |
NEXT_ORPHAN(inode)); |
| 1433 |
printk(KERN_ERR "max_ino=%lu\n", max_ino); |
| 1434 |
printk(KERN_ERR "i_nlink=%u\n", inode->i_nlink); |
| 1435 |
/* Avoid freeing blocks if we got a bad deleted inode */ |
| 1436 |
if (inode->i_nlink == 0) |
| 1437 |
inode->i_blocks = 0; |
| 1438 |
iput(inode); |
| 1439 |
} |
| 1440 |
brelse(bitmap_bh); |
| 1441 |
return ERR_PTR(err); |
| 1442 |
} |
| 1443 |
|
| 1444 |
unsigned long ext4_count_free_inodes(struct super_block *sb) |
| 1445 |
{ |
| 1446 |
unsigned long desc_count; |
| 1447 |
struct ext4_group_desc *gdp; |
| 1448 |
ext4_group_t i, ngroups = ext4_get_groups_count(sb); |
| 1449 |
#ifdef EXT4FS_DEBUG |
| 1450 |
struct ext4_super_block *es; |
| 1451 |
unsigned long bitmap_count, x; |
| 1452 |
struct buffer_head *bitmap_bh = NULL; |
| 1453 |
|
| 1454 |
es = EXT4_SB(sb)->s_es; |
| 1455 |
desc_count = 0; |
| 1456 |
bitmap_count = 0; |
| 1457 |
gdp = NULL; |
| 1458 |
for (i = 0; i < ngroups; i++) { |
| 1459 |
gdp = ext4_get_group_desc(sb, i, NULL); |
| 1460 |
if (!gdp) |
| 1461 |
continue; |
| 1462 |
desc_count += ext4_free_inodes_count(sb, gdp); |
| 1463 |
brelse(bitmap_bh); |
| 1464 |
bitmap_bh = ext4_read_inode_bitmap(sb, i); |
| 1465 |
if (IS_ERR(bitmap_bh)) { |
| 1466 |
bitmap_bh = NULL; |
| 1467 |
continue; |
| 1468 |
} |
| 1469 |
|
| 1470 |
x = ext4_count_free(bitmap_bh->b_data, |
| 1471 |
EXT4_INODES_PER_GROUP(sb) / 8); |
| 1472 |
printk(KERN_DEBUG "group %lu: stored = %d, counted = %lu\n", |
| 1473 |
(unsigned long) i, ext4_free_inodes_count(sb, gdp), x); |
| 1474 |
bitmap_count += x; |
| 1475 |
} |
| 1476 |
brelse(bitmap_bh); |
| 1477 |
printk(KERN_DEBUG "ext4_count_free_inodes: " |
| 1478 |
"stored = %u, computed = %lu, %lu\n", |
| 1479 |
le32_to_cpu(es->s_free_inodes_count), desc_count, bitmap_count); |
| 1480 |
return desc_count; |
| 1481 |
#else |
| 1482 |
desc_count = 0; |
| 1483 |
for (i = 0; i < ngroups; i++) { |
| 1484 |
gdp = ext4_get_group_desc(sb, i, NULL); |
| 1485 |
if (!gdp) |
| 1486 |
continue; |
| 1487 |
desc_count += ext4_free_inodes_count(sb, gdp); |
| 1488 |
cond_resched(); |
| 1489 |
} |
| 1490 |
return desc_count; |
| 1491 |
#endif |
| 1492 |
} |
| 1493 |
|
| 1494 |
/* Called at mount-time, super-block is locked */ |
| 1495 |
unsigned long ext4_count_dirs(struct super_block * sb) |
| 1496 |
{ |
| 1497 |
unsigned long count = 0; |
| 1498 |
ext4_group_t i, ngroups = ext4_get_groups_count(sb); |
| 1499 |
|
| 1500 |
for (i = 0; i < ngroups; i++) { |
| 1501 |
struct ext4_group_desc *gdp = ext4_get_group_desc(sb, i, NULL); |
| 1502 |
if (!gdp) |
| 1503 |
continue; |
| 1504 |
count += ext4_used_dirs_count(sb, gdp); |
| 1505 |
} |
| 1506 |
return count; |
| 1507 |
} |
| 1508 |
|
| 1509 |
/* |
| 1510 |
* Zeroes not yet zeroed inode table - just write zeroes through the whole |
| 1511 |
* inode table. Must be called without any spinlock held. The only place |
| 1512 |
* where it is called from on active part of filesystem is ext4lazyinit |
| 1513 |
* thread, so we do not need any special locks, however we have to prevent |
| 1514 |
* inode allocation from the current group, so we take alloc_sem lock, to |
| 1515 |
* block ext4_new_inode() until we are finished. |
| 1516 |
*/ |
| 1517 |
int ext4_init_inode_table(struct super_block *sb, ext4_group_t group, |
| 1518 |
int barrier) |
| 1519 |
{ |
| 1520 |
struct ext4_group_info *grp = ext4_get_group_info(sb, group); |
| 1521 |
struct ext4_sb_info *sbi = EXT4_SB(sb); |
| 1522 |
struct ext4_group_desc *gdp = NULL; |
| 1523 |
struct buffer_head *group_desc_bh; |
| 1524 |
handle_t *handle; |
| 1525 |
ext4_fsblk_t blk; |
| 1526 |
int num, ret = 0, used_blks = 0; |
| 1527 |
unsigned long used_inos = 0; |
| 1528 |
|
| 1529 |
gdp = ext4_get_group_desc(sb, group, &group_desc_bh); |
| 1530 |
if (!gdp || !grp) |
| 1531 |
goto out; |
| 1532 |
|
| 1533 |
/* |
| 1534 |
* We do not need to lock this, because we are the only one |
| 1535 |
* handling this flag. |
| 1536 |
*/ |
| 1537 |
if (gdp->bg_flags & cpu_to_le16(EXT4_BG_INODE_ZEROED)) |
| 1538 |
goto out; |
| 1539 |
|
| 1540 |
handle = ext4_journal_start_sb(sb, EXT4_HT_MISC, 1); |
| 1541 |
if (IS_ERR(handle)) { |
| 1542 |
ret = PTR_ERR(handle); |
| 1543 |
goto out; |
| 1544 |
} |
| 1545 |
|
| 1546 |
down_write(&grp->alloc_sem); |
| 1547 |
/* |
| 1548 |
* If inode bitmap was already initialized there may be some |
| 1549 |
* used inodes so we need to skip blocks with used inodes in |
| 1550 |
* inode table. |
| 1551 |
*/ |
| 1552 |
if (!(gdp->bg_flags & cpu_to_le16(EXT4_BG_INODE_UNINIT))) { |
| 1553 |
used_inos = EXT4_INODES_PER_GROUP(sb) - |
| 1554 |
ext4_itable_unused_count(sb, gdp); |
| 1555 |
used_blks = DIV_ROUND_UP(used_inos, sbi->s_inodes_per_block); |
| 1556 |
|
| 1557 |
/* Bogus inode unused count? */ |
| 1558 |
if (used_blks < 0 || used_blks > sbi->s_itb_per_group) { |
| 1559 |
ext4_error(sb, "Something is wrong with group %u: " |
| 1560 |
"used itable blocks: %d; " |
| 1561 |
"itable unused count: %u", |
| 1562 |
group, used_blks, |
| 1563 |
ext4_itable_unused_count(sb, gdp)); |
| 1564 |
ret = 1; |
| 1565 |
goto err_out; |
| 1566 |
} |
| 1567 |
|
| 1568 |
used_inos += group * EXT4_INODES_PER_GROUP(sb); |
| 1569 |
/* |
| 1570 |
* Are there some uninitialized inodes in the inode table |
| 1571 |
* before the first normal inode? |
| 1572 |
*/ |
| 1573 |
if ((used_blks != sbi->s_itb_per_group) && |
| 1574 |
(used_inos < EXT4_FIRST_INO(sb))) { |
| 1575 |
ext4_error(sb, "Something is wrong with group %u: " |
| 1576 |
"itable unused count: %u; " |
| 1577 |
"itables initialized count: %ld", |
| 1578 |
group, ext4_itable_unused_count(sb, gdp), |
| 1579 |
used_inos); |
| 1580 |
ret = 1; |
| 1581 |
goto err_out; |
| 1582 |
} |
| 1583 |
} |
| 1584 |
|
| 1585 |
blk = ext4_inode_table(sb, gdp) + used_blks; |
| 1586 |
num = sbi->s_itb_per_group - used_blks; |
| 1587 |
|
| 1588 |
BUFFER_TRACE(group_desc_bh, "get_write_access"); |
| 1589 |
ret = ext4_journal_get_write_access(handle, sb, group_desc_bh, |
| 1590 |
EXT4_JTR_NONE); |
| 1591 |
if (ret) |
| 1592 |
goto err_out; |
| 1593 |
|
| 1594 |
/* |
| 1595 |
* Skip zeroout if the inode table is full. But we set the ZEROED |
| 1596 |
* flag anyway, because obviously, when it is full it does not need |
| 1597 |
* further zeroing. |
| 1598 |
*/ |
| 1599 |
if (unlikely(num == 0)) |
| 1600 |
goto skip_zeroout; |
| 1601 |
|
| 1602 |
ext4_debug("going to zero out inode table in group %d\n", |
| 1603 |
group); |
| 1604 |
ret = sb_issue_zeroout(sb, blk, num, GFP_NOFS); |
| 1605 |
if (ret < 0) |
| 1606 |
goto err_out; |
| 1607 |
if (barrier) |
| 1608 |
blkdev_issue_flush(sb->s_bdev); |
| 1609 |
|
| 1610 |
skip_zeroout: |
| 1611 |
ext4_lock_group(sb, group); |
| 1612 |
gdp->bg_flags |= cpu_to_le16(EXT4_BG_INODE_ZEROED); |
| 1613 |
ext4_group_desc_csum_set(sb, group, gdp); |
| 1614 |
ext4_unlock_group(sb, group); |
| 1615 |
|
| 1616 |
BUFFER_TRACE(group_desc_bh, |
| 1617 |
"call ext4_handle_dirty_metadata"); |
| 1618 |
ret = ext4_handle_dirty_metadata(handle, NULL, |
| 1619 |
group_desc_bh); |
| 1620 |
|
| 1621 |
err_out: |
| 1622 |
up_write(&grp->alloc_sem); |
| 1623 |
ext4_journal_stop(handle); |
| 1624 |
out: |
| 1625 |
return ret; |
| 1626 |
} |