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