1
2
3
4
5
6
7
8
9
10
11
12
13
14
15#include <linux/time.h>
16#include <linux/fs.h>
17#include <linux/stat.h>
18#include <linux/string.h>
19#include <linux/quotaops.h>
20#include <linux/buffer_head.h>
21#include <linux/random.h>
22#include <linux/bitops.h>
23#include <linux/blkdev.h>
24#include <linux/cred.h>
25
26#include <asm/byteorder.h>
27
28#include "ext4.h"
29#include "ext4_jbd2.h"
30#include "xattr.h"
31#include "acl.h"
32
33#include <trace/events/ext4.h>
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54void ext4_mark_bitmap_end(int start_bit, int end_bit, char *bitmap)
55{
56 int i;
57
58 if (start_bit >= end_bit)
59 return;
60
61 ext4_debug("mark end bits +%d through +%d used\n", start_bit, end_bit);
62 for (i = start_bit; i < ((start_bit + 7) & ~7UL); i++)
63 ext4_set_bit(i, bitmap);
64 if (i < end_bit)
65 memset(bitmap + (i >> 3), 0xff, (end_bit - i) >> 3);
66}
67
68
69static int ext4_init_inode_bitmap(struct super_block *sb,
70 struct buffer_head *bh,
71 ext4_group_t block_group,
72 struct ext4_group_desc *gdp)
73{
74 struct ext4_group_info *grp;
75 struct ext4_sb_info *sbi = EXT4_SB(sb);
76 J_ASSERT_BH(bh, buffer_locked(bh));
77
78
79
80 if (!ext4_group_desc_csum_verify(sb, block_group, gdp)) {
81 grp = ext4_get_group_info(sb, block_group);
82 if (!EXT4_MB_GRP_BBITMAP_CORRUPT(grp))
83 percpu_counter_sub(&sbi->s_freeclusters_counter,
84 grp->bb_free);
85 set_bit(EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT, &grp->bb_state);
86 if (!EXT4_MB_GRP_IBITMAP_CORRUPT(grp)) {
87 int count;
88 count = ext4_free_inodes_count(sb, gdp);
89 percpu_counter_sub(&sbi->s_freeinodes_counter,
90 count);
91 }
92 set_bit(EXT4_GROUP_INFO_IBITMAP_CORRUPT_BIT, &grp->bb_state);
93 return -EFSBADCRC;
94 }
95
96 memset(bh->b_data, 0, (EXT4_INODES_PER_GROUP(sb) + 7) / 8);
97 ext4_mark_bitmap_end(EXT4_INODES_PER_GROUP(sb), sb->s_blocksize * 8,
98 bh->b_data);
99 ext4_inode_bitmap_csum_set(sb, block_group, gdp, bh,
100 EXT4_INODES_PER_GROUP(sb) / 8);
101 ext4_group_desc_csum_set(sb, block_group, gdp);
102
103 return 0;
104}
105
106void ext4_end_bitmap_read(struct buffer_head *bh, int uptodate)
107{
108 if (uptodate) {
109 set_buffer_uptodate(bh);
110 set_bitmap_uptodate(bh);
111 }
112 unlock_buffer(bh);
113 put_bh(bh);
114}
115
116static int ext4_validate_inode_bitmap(struct super_block *sb,
117 struct ext4_group_desc *desc,
118 ext4_group_t block_group,
119 struct buffer_head *bh)
120{
121 ext4_fsblk_t blk;
122 struct ext4_group_info *grp = ext4_get_group_info(sb, block_group);
123 struct ext4_sb_info *sbi = EXT4_SB(sb);
124
125 if (buffer_verified(bh))
126 return 0;
127 if (EXT4_MB_GRP_IBITMAP_CORRUPT(grp))
128 return -EFSCORRUPTED;
129
130 ext4_lock_group(sb, block_group);
131 blk = ext4_inode_bitmap(sb, desc);
132 if (!ext4_inode_bitmap_csum_verify(sb, block_group, desc, bh,
133 EXT4_INODES_PER_GROUP(sb) / 8)) {
134 ext4_unlock_group(sb, block_group);
135 ext4_error(sb, "Corrupt inode bitmap - block_group = %u, "
136 "inode_bitmap = %llu", block_group, blk);
137 grp = ext4_get_group_info(sb, block_group);
138 if (!EXT4_MB_GRP_IBITMAP_CORRUPT(grp)) {
139 int count;
140 count = ext4_free_inodes_count(sb, desc);
141 percpu_counter_sub(&sbi->s_freeinodes_counter,
142 count);
143 }
144 set_bit(EXT4_GROUP_INFO_IBITMAP_CORRUPT_BIT, &grp->bb_state);
145 return -EFSBADCRC;
146 }
147 set_buffer_verified(bh);
148 ext4_unlock_group(sb, block_group);
149 return 0;
150}
151
152
153
154
155
156
157
158static struct buffer_head *
159ext4_read_inode_bitmap(struct super_block *sb, ext4_group_t block_group)
160{
161 struct ext4_group_desc *desc;
162 struct buffer_head *bh = NULL;
163 ext4_fsblk_t bitmap_blk;
164 int err;
165
166 desc = ext4_get_group_desc(sb, block_group, NULL);
167 if (!desc)
168 return ERR_PTR(-EFSCORRUPTED);
169
170 bitmap_blk = ext4_inode_bitmap(sb, desc);
171 bh = sb_getblk(sb, bitmap_blk);
172 if (unlikely(!bh)) {
173 ext4_error(sb, "Cannot read inode bitmap - "
174 "block_group = %u, inode_bitmap = %llu",
175 block_group, bitmap_blk);
176 return ERR_PTR(-EIO);
177 }
178 if (bitmap_uptodate(bh))
179 goto verify;
180
181 lock_buffer(bh);
182 if (bitmap_uptodate(bh)) {
183 unlock_buffer(bh);
184 goto verify;
185 }
186
187 ext4_lock_group(sb, block_group);
188 if (desc->bg_flags & cpu_to_le16(EXT4_BG_INODE_UNINIT)) {
189 err = ext4_init_inode_bitmap(sb, bh, block_group, desc);
190 set_bitmap_uptodate(bh);
191 set_buffer_uptodate(bh);
192 set_buffer_verified(bh);
193 ext4_unlock_group(sb, block_group);
194 unlock_buffer(bh);
195 if (err) {
196 ext4_error(sb, "Failed to init inode bitmap for group "
197 "%u: %d", block_group, err);
198 goto out;
199 }
200 return bh;
201 }
202 ext4_unlock_group(sb, block_group);
203
204 if (buffer_uptodate(bh)) {
205
206
207
208
209 set_bitmap_uptodate(bh);
210 unlock_buffer(bh);
211 goto verify;
212 }
213
214
215
216 trace_ext4_load_inode_bitmap(sb, block_group);
217 bh->b_end_io = ext4_end_bitmap_read;
218 get_bh(bh);
219 submit_bh(REQ_OP_READ, REQ_META | REQ_PRIO, bh);
220 wait_on_buffer(bh);
221 if (!buffer_uptodate(bh)) {
222 put_bh(bh);
223 ext4_error(sb, "Cannot read inode bitmap - "
224 "block_group = %u, inode_bitmap = %llu",
225 block_group, bitmap_blk);
226 return ERR_PTR(-EIO);
227 }
228
229verify:
230 err = ext4_validate_inode_bitmap(sb, desc, block_group, bh);
231 if (err)
232 goto out;
233 return bh;
234out:
235 put_bh(bh);
236 return ERR_PTR(err);
237}
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255void ext4_free_inode(handle_t *handle, struct inode *inode)
256{
257 struct super_block *sb = inode->i_sb;
258 int is_directory;
259 unsigned long ino;
260 struct buffer_head *bitmap_bh = NULL;
261 struct buffer_head *bh2;
262 ext4_group_t block_group;
263 unsigned long bit;
264 struct ext4_group_desc *gdp;
265 struct ext4_super_block *es;
266 struct ext4_sb_info *sbi;
267 int fatal = 0, err, count, cleared;
268 struct ext4_group_info *grp;
269
270 if (!sb) {
271 printk(KERN_ERR "EXT4-fs: %s:%d: inode on "
272 "nonexistent device\n", __func__, __LINE__);
273 return;
274 }
275 if (atomic_read(&inode->i_count) > 1) {
276 ext4_msg(sb, KERN_ERR, "%s:%d: inode #%lu: count=%d",
277 __func__, __LINE__, inode->i_ino,
278 atomic_read(&inode->i_count));
279 return;
280 }
281 if (inode->i_nlink) {
282 ext4_msg(sb, KERN_ERR, "%s:%d: inode #%lu: nlink=%d\n",
283 __func__, __LINE__, inode->i_ino, inode->i_nlink);
284 return;
285 }
286 sbi = EXT4_SB(sb);
287
288 ino = inode->i_ino;
289 ext4_debug("freeing inode %lu\n", ino);
290 trace_ext4_free_inode(inode);
291
292
293
294
295
296 dquot_initialize(inode);
297 ext4_xattr_delete_inode(handle, inode);
298 dquot_free_inode(inode);
299 dquot_drop(inode);
300
301 is_directory = S_ISDIR(inode->i_mode);
302
303
304 ext4_clear_inode(inode);
305
306 es = EXT4_SB(sb)->s_es;
307 if (ino < EXT4_FIRST_INO(sb) || ino > le32_to_cpu(es->s_inodes_count)) {
308 ext4_error(sb, "reserved or nonexistent inode %lu", ino);
309 goto error_return;
310 }
311 block_group = (ino - 1) / EXT4_INODES_PER_GROUP(sb);
312 bit = (ino - 1) % EXT4_INODES_PER_GROUP(sb);
313 bitmap_bh = ext4_read_inode_bitmap(sb, block_group);
314
315 grp = ext4_get_group_info(sb, block_group);
316 if (IS_ERR(bitmap_bh)) {
317 fatal = PTR_ERR(bitmap_bh);
318 bitmap_bh = NULL;
319 goto error_return;
320 }
321 if (unlikely(EXT4_MB_GRP_IBITMAP_CORRUPT(grp))) {
322 fatal = -EFSCORRUPTED;
323 goto error_return;
324 }
325
326 BUFFER_TRACE(bitmap_bh, "get_write_access");
327 fatal = ext4_journal_get_write_access(handle, bitmap_bh);
328 if (fatal)
329 goto error_return;
330
331 fatal = -ESRCH;
332 gdp = ext4_get_group_desc(sb, block_group, &bh2);
333 if (gdp) {
334 BUFFER_TRACE(bh2, "get_write_access");
335 fatal = ext4_journal_get_write_access(handle, bh2);
336 }
337 ext4_lock_group(sb, block_group);
338 cleared = ext4_test_and_clear_bit(bit, bitmap_bh->b_data);
339 if (fatal || !cleared) {
340 ext4_unlock_group(sb, block_group);
341 goto out;
342 }
343
344 count = ext4_free_inodes_count(sb, gdp) + 1;
345 ext4_free_inodes_set(sb, gdp, count);
346 if (is_directory) {
347 count = ext4_used_dirs_count(sb, gdp) - 1;
348 ext4_used_dirs_set(sb, gdp, count);
349 percpu_counter_dec(&sbi->s_dirs_counter);
350 }
351 ext4_inode_bitmap_csum_set(sb, block_group, gdp, bitmap_bh,
352 EXT4_INODES_PER_GROUP(sb) / 8);
353 ext4_group_desc_csum_set(sb, block_group, gdp);
354 ext4_unlock_group(sb, block_group);
355
356 percpu_counter_inc(&sbi->s_freeinodes_counter);
357 if (sbi->s_log_groups_per_flex) {
358 ext4_group_t f = ext4_flex_group(sbi, block_group);
359
360 atomic_inc(&sbi->s_flex_groups[f].free_inodes);
361 if (is_directory)
362 atomic_dec(&sbi->s_flex_groups[f].used_dirs);
363 }
364 BUFFER_TRACE(bh2, "call ext4_handle_dirty_metadata");
365 fatal = ext4_handle_dirty_metadata(handle, NULL, bh2);
366out:
367 if (cleared) {
368 BUFFER_TRACE(bitmap_bh, "call ext4_handle_dirty_metadata");
369 err = ext4_handle_dirty_metadata(handle, NULL, bitmap_bh);
370 if (!fatal)
371 fatal = err;
372 } else {
373 ext4_error(sb, "bit already cleared for inode %lu", ino);
374 if (gdp && !EXT4_MB_GRP_IBITMAP_CORRUPT(grp)) {
375 int count;
376 count = ext4_free_inodes_count(sb, gdp);
377 percpu_counter_sub(&sbi->s_freeinodes_counter,
378 count);
379 }
380 set_bit(EXT4_GROUP_INFO_IBITMAP_CORRUPT_BIT, &grp->bb_state);
381 }
382
383error_return:
384 brelse(bitmap_bh);
385 ext4_std_error(sb, fatal);
386}
387
388struct orlov_stats {
389 __u64 free_clusters;
390 __u32 free_inodes;
391 __u32 used_dirs;
392};
393
394
395
396
397
398
399static void get_orlov_stats(struct super_block *sb, ext4_group_t g,
400 int flex_size, struct orlov_stats *stats)
401{
402 struct ext4_group_desc *desc;
403 struct flex_groups *flex_group = EXT4_SB(sb)->s_flex_groups;
404
405 if (flex_size > 1) {
406 stats->free_inodes = atomic_read(&flex_group[g].free_inodes);
407 stats->free_clusters = atomic64_read(&flex_group[g].free_clusters);
408 stats->used_dirs = atomic_read(&flex_group[g].used_dirs);
409 return;
410 }
411
412 desc = ext4_get_group_desc(sb, g, NULL);
413 if (desc) {
414 stats->free_inodes = ext4_free_inodes_count(sb, desc);
415 stats->free_clusters = ext4_free_group_clusters(sb, desc);
416 stats->used_dirs = ext4_used_dirs_count(sb, desc);
417 } else {
418 stats->free_inodes = 0;
419 stats->free_clusters = 0;
420 stats->used_dirs = 0;
421 }
422}
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445static int find_group_orlov(struct super_block *sb, struct inode *parent,
446 ext4_group_t *group, umode_t mode,
447 const struct qstr *qstr)
448{
449 ext4_group_t parent_group = EXT4_I(parent)->i_block_group;
450 struct ext4_sb_info *sbi = EXT4_SB(sb);
451 ext4_group_t real_ngroups = ext4_get_groups_count(sb);
452 int inodes_per_group = EXT4_INODES_PER_GROUP(sb);
453 unsigned int freei, avefreei, grp_free;
454 ext4_fsblk_t freeb, avefreec;
455 unsigned int ndirs;
456 int max_dirs, min_inodes;
457 ext4_grpblk_t min_clusters;
458 ext4_group_t i, grp, g, ngroups;
459 struct ext4_group_desc *desc;
460 struct orlov_stats stats;
461 int flex_size = ext4_flex_bg_size(sbi);
462 struct dx_hash_info hinfo;
463
464 ngroups = real_ngroups;
465 if (flex_size > 1) {
466 ngroups = (real_ngroups + flex_size - 1) >>
467 sbi->s_log_groups_per_flex;
468 parent_group >>= sbi->s_log_groups_per_flex;
469 }
470
471 freei = percpu_counter_read_positive(&sbi->s_freeinodes_counter);
472 avefreei = freei / ngroups;
473 freeb = EXT4_C2B(sbi,
474 percpu_counter_read_positive(&sbi->s_freeclusters_counter));
475 avefreec = freeb;
476 do_div(avefreec, ngroups);
477 ndirs = percpu_counter_read_positive(&sbi->s_dirs_counter);
478
479 if (S_ISDIR(mode) &&
480 ((parent == d_inode(sb->s_root)) ||
481 (ext4_test_inode_flag(parent, EXT4_INODE_TOPDIR)))) {
482 int best_ndir = inodes_per_group;
483 int ret = -1;
484
485 if (qstr) {
486 hinfo.hash_version = DX_HASH_HALF_MD4;
487 hinfo.seed = sbi->s_hash_seed;
488 ext4fs_dirhash(qstr->name, qstr->len, &hinfo);
489 grp = hinfo.hash;
490 } else
491 grp = prandom_u32();
492 parent_group = (unsigned)grp % ngroups;
493 for (i = 0; i < ngroups; i++) {
494 g = (parent_group + i) % ngroups;
495 get_orlov_stats(sb, g, flex_size, &stats);
496 if (!stats.free_inodes)
497 continue;
498 if (stats.used_dirs >= best_ndir)
499 continue;
500 if (stats.free_inodes < avefreei)
501 continue;
502 if (stats.free_clusters < avefreec)
503 continue;
504 grp = g;
505 ret = 0;
506 best_ndir = stats.used_dirs;
507 }
508 if (ret)
509 goto fallback;
510 found_flex_bg:
511 if (flex_size == 1) {
512 *group = grp;
513 return 0;
514 }
515
516
517
518
519
520
521
522
523 grp *= flex_size;
524 for (i = 0; i < flex_size; i++) {
525 if (grp+i >= real_ngroups)
526 break;
527 desc = ext4_get_group_desc(sb, grp+i, NULL);
528 if (desc && ext4_free_inodes_count(sb, desc)) {
529 *group = grp+i;
530 return 0;
531 }
532 }
533 goto fallback;
534 }
535
536 max_dirs = ndirs / ngroups + inodes_per_group / 16;
537 min_inodes = avefreei - inodes_per_group*flex_size / 4;
538 if (min_inodes < 1)
539 min_inodes = 1;
540 min_clusters = avefreec - EXT4_CLUSTERS_PER_GROUP(sb)*flex_size / 4;
541
542
543
544
545
546 if (EXT4_I(parent)->i_last_alloc_group != ~0) {
547 parent_group = EXT4_I(parent)->i_last_alloc_group;
548 if (flex_size > 1)
549 parent_group >>= sbi->s_log_groups_per_flex;
550 }
551
552 for (i = 0; i < ngroups; i++) {
553 grp = (parent_group + i) % ngroups;
554 get_orlov_stats(sb, grp, flex_size, &stats);
555 if (stats.used_dirs >= max_dirs)
556 continue;
557 if (stats.free_inodes < min_inodes)
558 continue;
559 if (stats.free_clusters < min_clusters)
560 continue;
561 goto found_flex_bg;
562 }
563
564fallback:
565 ngroups = real_ngroups;
566 avefreei = freei / ngroups;
567fallback_retry:
568 parent_group = EXT4_I(parent)->i_block_group;
569 for (i = 0; i < ngroups; i++) {
570 grp = (parent_group + i) % ngroups;
571 desc = ext4_get_group_desc(sb, grp, NULL);
572 if (desc) {
573 grp_free = ext4_free_inodes_count(sb, desc);
574 if (grp_free && grp_free >= avefreei) {
575 *group = grp;
576 return 0;
577 }
578 }
579 }
580
581 if (avefreei) {
582
583
584
585
586 avefreei = 0;
587 goto fallback_retry;
588 }
589
590 return -1;
591}
592
593static int find_group_other(struct super_block *sb, struct inode *parent,
594 ext4_group_t *group, umode_t mode)
595{
596 ext4_group_t parent_group = EXT4_I(parent)->i_block_group;
597 ext4_group_t i, last, ngroups = ext4_get_groups_count(sb);
598 struct ext4_group_desc *desc;
599 int flex_size = ext4_flex_bg_size(EXT4_SB(sb));
600
601
602
603
604
605
606
607
608 if (flex_size > 1) {
609 int retry = 0;
610
611 try_again:
612 parent_group &= ~(flex_size-1);
613 last = parent_group + flex_size;
614 if (last > ngroups)
615 last = ngroups;
616 for (i = parent_group; i < last; i++) {
617 desc = ext4_get_group_desc(sb, i, NULL);
618 if (desc && ext4_free_inodes_count(sb, desc)) {
619 *group = i;
620 return 0;
621 }
622 }
623 if (!retry && EXT4_I(parent)->i_last_alloc_group != ~0) {
624 retry = 1;
625 parent_group = EXT4_I(parent)->i_last_alloc_group;
626 goto try_again;
627 }
628
629
630
631
632
633 *group = parent_group + flex_size;
634 if (*group > ngroups)
635 *group = 0;
636 return find_group_orlov(sb, parent, group, mode, NULL);
637 }
638
639
640
641
642 *group = parent_group;
643 desc = ext4_get_group_desc(sb, *group, NULL);
644 if (desc && ext4_free_inodes_count(sb, desc) &&
645 ext4_free_group_clusters(sb, desc))
646 return 0;
647
648
649
650
651
652
653
654
655
656
657 *group = (*group + parent->i_ino) % ngroups;
658
659
660
661
662
663 for (i = 1; i < ngroups; i <<= 1) {
664 *group += i;
665 if (*group >= ngroups)
666 *group -= ngroups;
667 desc = ext4_get_group_desc(sb, *group, NULL);
668 if (desc && ext4_free_inodes_count(sb, desc) &&
669 ext4_free_group_clusters(sb, desc))
670 return 0;
671 }
672
673
674
675
676
677 *group = parent_group;
678 for (i = 0; i < ngroups; i++) {
679 if (++*group >= ngroups)
680 *group = 0;
681 desc = ext4_get_group_desc(sb, *group, NULL);
682 if (desc && ext4_free_inodes_count(sb, desc))
683 return 0;
684 }
685
686 return -1;
687}
688
689
690
691
692
693
694
695#define RECENTCY_MIN 5
696#define RECENTCY_DIRTY 30
697
698static int recently_deleted(struct super_block *sb, ext4_group_t group, int ino)
699{
700 struct ext4_group_desc *gdp;
701 struct ext4_inode *raw_inode;
702 struct buffer_head *bh;
703 unsigned long dtime, now;
704 int inodes_per_block = EXT4_SB(sb)->s_inodes_per_block;
705 int offset, ret = 0, recentcy = RECENTCY_MIN;
706
707 gdp = ext4_get_group_desc(sb, group, NULL);
708 if (unlikely(!gdp))
709 return 0;
710
711 bh = sb_getblk(sb, ext4_inode_table(sb, gdp) +
712 (ino / inodes_per_block));
713 if (unlikely(!bh) || !buffer_uptodate(bh))
714
715
716
717
718 goto out;
719
720 offset = (ino % inodes_per_block) * EXT4_INODE_SIZE(sb);
721 raw_inode = (struct ext4_inode *) (bh->b_data + offset);
722 dtime = le32_to_cpu(raw_inode->i_dtime);
723 now = get_seconds();
724 if (buffer_dirty(bh))
725 recentcy += RECENTCY_DIRTY;
726
727 if (dtime && (dtime < now) && (now < dtime + recentcy))
728 ret = 1;
729out:
730 brelse(bh);
731 return ret;
732}
733
734
735
736
737
738
739
740
741
742
743
744struct inode *__ext4_new_inode(handle_t *handle, struct inode *dir,
745 umode_t mode, const struct qstr *qstr,
746 __u32 goal, uid_t *owner, int handle_type,
747 unsigned int line_no, int nblocks)
748{
749 struct super_block *sb;
750 struct buffer_head *inode_bitmap_bh = NULL;
751 struct buffer_head *group_desc_bh;
752 ext4_group_t ngroups, group = 0;
753 unsigned long ino = 0;
754 struct inode *inode;
755 struct ext4_group_desc *gdp = NULL;
756 struct ext4_inode_info *ei;
757 struct ext4_sb_info *sbi;
758 int ret2, err;
759 struct inode *ret;
760 ext4_group_t i;
761 ext4_group_t flex_group;
762 struct ext4_group_info *grp;
763 int encrypt = 0;
764
765
766 if (!dir || !dir->i_nlink)
767 return ERR_PTR(-EPERM);
768
769 if (unlikely(ext4_forced_shutdown(EXT4_SB(dir->i_sb))))
770 return ERR_PTR(-EIO);
771
772 if ((ext4_encrypted_inode(dir) ||
773 DUMMY_ENCRYPTION_ENABLED(EXT4_SB(dir->i_sb))) &&
774 (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode))) {
775 err = fscrypt_get_encryption_info(dir);
776 if (err)
777 return ERR_PTR(err);
778 if (!fscrypt_has_encryption_key(dir))
779 return ERR_PTR(-ENOKEY);
780 if (!handle)
781 nblocks += EXT4_DATA_TRANS_BLOCKS(dir->i_sb);
782 encrypt = 1;
783 }
784
785 sb = dir->i_sb;
786 ngroups = ext4_get_groups_count(sb);
787 trace_ext4_request_inode(dir, mode);
788 inode = new_inode(sb);
789 if (!inode)
790 return ERR_PTR(-ENOMEM);
791 ei = EXT4_I(inode);
792 sbi = EXT4_SB(sb);
793
794
795
796
797
798
799 if (owner) {
800 inode->i_mode = mode;
801 i_uid_write(inode, owner[0]);
802 i_gid_write(inode, owner[1]);
803 } else if (test_opt(sb, GRPID)) {
804 inode->i_mode = mode;
805 inode->i_uid = current_fsuid();
806 inode->i_gid = dir->i_gid;
807 } else
808 inode_init_owner(inode, dir, mode);
809
810 if (ext4_has_feature_project(sb) &&
811 ext4_test_inode_flag(dir, EXT4_INODE_PROJINHERIT))
812 ei->i_projid = EXT4_I(dir)->i_projid;
813 else
814 ei->i_projid = make_kprojid(&init_user_ns, EXT4_DEF_PROJID);
815
816 err = dquot_initialize(inode);
817 if (err)
818 goto out;
819
820 if (!goal)
821 goal = sbi->s_inode_goal;
822
823 if (goal && goal <= le32_to_cpu(sbi->s_es->s_inodes_count)) {
824 group = (goal - 1) / EXT4_INODES_PER_GROUP(sb);
825 ino = (goal - 1) % EXT4_INODES_PER_GROUP(sb);
826 ret2 = 0;
827 goto got_group;
828 }
829
830 if (S_ISDIR(mode))
831 ret2 = find_group_orlov(sb, dir, &group, mode, qstr);
832 else
833 ret2 = find_group_other(sb, dir, &group, mode);
834
835got_group:
836 EXT4_I(dir)->i_last_alloc_group = group;
837 err = -ENOSPC;
838 if (ret2 == -1)
839 goto out;
840
841
842
843
844
845
846 for (i = 0; i < ngroups; i++, ino = 0) {
847 err = -EIO;
848
849 gdp = ext4_get_group_desc(sb, group, &group_desc_bh);
850 if (!gdp)
851 goto out;
852
853
854
855
856 if (ext4_free_inodes_count(sb, gdp) == 0) {
857 if (++group == ngroups)
858 group = 0;
859 continue;
860 }
861
862 grp = ext4_get_group_info(sb, group);
863
864 if (EXT4_MB_GRP_IBITMAP_CORRUPT(grp)) {
865 if (++group == ngroups)
866 group = 0;
867 continue;
868 }
869
870 brelse(inode_bitmap_bh);
871 inode_bitmap_bh = ext4_read_inode_bitmap(sb, group);
872
873 if (EXT4_MB_GRP_IBITMAP_CORRUPT(grp) ||
874 IS_ERR(inode_bitmap_bh)) {
875 inode_bitmap_bh = NULL;
876 if (++group == ngroups)
877 group = 0;
878 continue;
879 }
880
881repeat_in_this_group:
882 ino = ext4_find_next_zero_bit((unsigned long *)
883 inode_bitmap_bh->b_data,
884 EXT4_INODES_PER_GROUP(sb), ino);
885 if (ino >= EXT4_INODES_PER_GROUP(sb))
886 goto next_group;
887 if (group == 0 && (ino+1) < EXT4_FIRST_INO(sb)) {
888 ext4_error(sb, "reserved inode found cleared - "
889 "inode=%lu", ino + 1);
890 continue;
891 }
892 if ((EXT4_SB(sb)->s_journal == NULL) &&
893 recently_deleted(sb, group, ino)) {
894 ino++;
895 goto next_inode;
896 }
897 if (!handle) {
898 BUG_ON(nblocks <= 0);
899 handle = __ext4_journal_start_sb(dir->i_sb, line_no,
900 handle_type, nblocks,
901 0);
902 if (IS_ERR(handle)) {
903 err = PTR_ERR(handle);
904 ext4_std_error(sb, err);
905 goto out;
906 }
907 }
908 BUFFER_TRACE(inode_bitmap_bh, "get_write_access");
909 err = ext4_journal_get_write_access(handle, inode_bitmap_bh);
910 if (err) {
911 ext4_std_error(sb, err);
912 goto out;
913 }
914 ext4_lock_group(sb, group);
915 ret2 = ext4_test_and_set_bit(ino, inode_bitmap_bh->b_data);
916 ext4_unlock_group(sb, group);
917 ino++;
918 if (!ret2)
919 goto got;
920next_inode:
921 if (ino < EXT4_INODES_PER_GROUP(sb))
922 goto repeat_in_this_group;
923next_group:
924 if (++group == ngroups)
925 group = 0;
926 }
927 err = -ENOSPC;
928 goto out;
929
930got:
931 BUFFER_TRACE(inode_bitmap_bh, "call ext4_handle_dirty_metadata");
932 err = ext4_handle_dirty_metadata(handle, NULL, inode_bitmap_bh);
933 if (err) {
934 ext4_std_error(sb, err);
935 goto out;
936 }
937
938 BUFFER_TRACE(group_desc_bh, "get_write_access");
939 err = ext4_journal_get_write_access(handle, group_desc_bh);
940 if (err) {
941 ext4_std_error(sb, err);
942 goto out;
943 }
944
945
946 if (ext4_has_group_desc_csum(sb) &&
947 gdp->bg_flags & cpu_to_le16(EXT4_BG_BLOCK_UNINIT)) {
948 struct buffer_head *block_bitmap_bh;
949
950 block_bitmap_bh = ext4_read_block_bitmap(sb, group);
951 if (IS_ERR(block_bitmap_bh)) {
952 err = PTR_ERR(block_bitmap_bh);
953 goto out;
954 }
955 BUFFER_TRACE(block_bitmap_bh, "get block bitmap access");
956 err = ext4_journal_get_write_access(handle, block_bitmap_bh);
957 if (err) {
958 brelse(block_bitmap_bh);
959 ext4_std_error(sb, err);
960 goto out;
961 }
962
963 BUFFER_TRACE(block_bitmap_bh, "dirty block bitmap");
964 err = ext4_handle_dirty_metadata(handle, NULL, block_bitmap_bh);
965
966
967 ext4_lock_group(sb, group);
968 if (gdp->bg_flags & cpu_to_le16(EXT4_BG_BLOCK_UNINIT)) {
969 gdp->bg_flags &= cpu_to_le16(~EXT4_BG_BLOCK_UNINIT);
970 ext4_free_group_clusters_set(sb, gdp,
971 ext4_free_clusters_after_init(sb, group, gdp));
972 ext4_block_bitmap_csum_set(sb, group, gdp,
973 block_bitmap_bh);
974 ext4_group_desc_csum_set(sb, group, gdp);
975 }
976 ext4_unlock_group(sb, group);
977 brelse(block_bitmap_bh);
978
979 if (err) {
980 ext4_std_error(sb, err);
981 goto out;
982 }
983 }
984
985
986 if (ext4_has_group_desc_csum(sb)) {
987 int free;
988 struct ext4_group_info *grp = ext4_get_group_info(sb, group);
989
990 down_read(&grp->alloc_sem);
991 ext4_lock_group(sb, group);
992 free = EXT4_INODES_PER_GROUP(sb) -
993 ext4_itable_unused_count(sb, gdp);
994 if (gdp->bg_flags & cpu_to_le16(EXT4_BG_INODE_UNINIT)) {
995 gdp->bg_flags &= cpu_to_le16(~EXT4_BG_INODE_UNINIT);
996 free = 0;
997 }
998
999
1000
1001
1002
1003 if (ino > free)
1004 ext4_itable_unused_set(sb, gdp,
1005 (EXT4_INODES_PER_GROUP(sb) - ino));
1006 up_read(&grp->alloc_sem);
1007 } else {
1008 ext4_lock_group(sb, group);
1009 }
1010
1011 ext4_free_inodes_set(sb, gdp, ext4_free_inodes_count(sb, gdp) - 1);
1012 if (S_ISDIR(mode)) {
1013 ext4_used_dirs_set(sb, gdp, ext4_used_dirs_count(sb, gdp) + 1);
1014 if (sbi->s_log_groups_per_flex) {
1015 ext4_group_t f = ext4_flex_group(sbi, group);
1016
1017 atomic_inc(&sbi->s_flex_groups[f].used_dirs);
1018 }
1019 }
1020 if (ext4_has_group_desc_csum(sb)) {
1021 ext4_inode_bitmap_csum_set(sb, group, gdp, inode_bitmap_bh,
1022 EXT4_INODES_PER_GROUP(sb) / 8);
1023 ext4_group_desc_csum_set(sb, group, gdp);
1024 }
1025 ext4_unlock_group(sb, group);
1026
1027 BUFFER_TRACE(group_desc_bh, "call ext4_handle_dirty_metadata");
1028 err = ext4_handle_dirty_metadata(handle, NULL, group_desc_bh);
1029 if (err) {
1030 ext4_std_error(sb, err);
1031 goto out;
1032 }
1033
1034 percpu_counter_dec(&sbi->s_freeinodes_counter);
1035 if (S_ISDIR(mode))
1036 percpu_counter_inc(&sbi->s_dirs_counter);
1037
1038 if (sbi->s_log_groups_per_flex) {
1039 flex_group = ext4_flex_group(sbi, group);
1040 atomic_dec(&sbi->s_flex_groups[flex_group].free_inodes);
1041 }
1042
1043 inode->i_ino = ino + group * EXT4_INODES_PER_GROUP(sb);
1044
1045 inode->i_blocks = 0;
1046 inode->i_mtime = inode->i_atime = inode->i_ctime = ei->i_crtime =
1047 current_time(inode);
1048
1049 memset(ei->i_data, 0, sizeof(ei->i_data));
1050 ei->i_dir_start_lookup = 0;
1051 ei->i_disksize = 0;
1052
1053
1054 ei->i_flags =
1055 ext4_mask_flags(mode, EXT4_I(dir)->i_flags & EXT4_FL_INHERITED);
1056 ei->i_file_acl = 0;
1057 ei->i_dtime = 0;
1058 ei->i_block_group = group;
1059 ei->i_last_alloc_group = ~0;
1060
1061 ext4_set_inode_flags(inode);
1062 if (IS_DIRSYNC(inode))
1063 ext4_handle_sync(handle);
1064 if (insert_inode_locked(inode) < 0) {
1065
1066
1067
1068
1069 err = -EIO;
1070 ext4_error(sb, "failed to insert inode %lu: doubly allocated?",
1071 inode->i_ino);
1072 goto out;
1073 }
1074 spin_lock(&sbi->s_next_gen_lock);
1075 inode->i_generation = sbi->s_next_generation++;
1076 spin_unlock(&sbi->s_next_gen_lock);
1077
1078
1079 if (ext4_has_metadata_csum(sb)) {
1080 __u32 csum;
1081 __le32 inum = cpu_to_le32(inode->i_ino);
1082 __le32 gen = cpu_to_le32(inode->i_generation);
1083 csum = ext4_chksum(sbi, sbi->s_csum_seed, (__u8 *)&inum,
1084 sizeof(inum));
1085 ei->i_csum_seed = ext4_chksum(sbi, csum, (__u8 *)&gen,
1086 sizeof(gen));
1087 }
1088
1089 ext4_clear_state_flags(ei);
1090 ext4_set_inode_state(inode, EXT4_STATE_NEW);
1091
1092 ei->i_extra_isize = EXT4_SB(sb)->s_want_extra_isize;
1093 ei->i_inline_off = 0;
1094 if (ext4_has_feature_inline_data(sb))
1095 ext4_set_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA);
1096 ret = inode;
1097 err = dquot_alloc_inode(inode);
1098 if (err)
1099 goto fail_drop;
1100
1101 err = ext4_init_acl(handle, inode, dir);
1102 if (err)
1103 goto fail_free_drop;
1104
1105 err = ext4_init_security(handle, inode, dir, qstr);
1106 if (err)
1107 goto fail_free_drop;
1108
1109 if (ext4_has_feature_extents(sb)) {
1110
1111 if (S_ISDIR(mode) || S_ISREG(mode) || S_ISLNK(mode)) {
1112 ext4_set_inode_flag(inode, EXT4_INODE_EXTENTS);
1113 ext4_ext_tree_init(handle, inode);
1114 }
1115 }
1116
1117 if (ext4_handle_valid(handle)) {
1118 ei->i_sync_tid = handle->h_transaction->t_tid;
1119 ei->i_datasync_tid = handle->h_transaction->t_tid;
1120 }
1121
1122 if (encrypt) {
1123 err = fscrypt_inherit_context(dir, inode, handle, true);
1124 if (err)
1125 goto fail_free_drop;
1126 }
1127
1128 err = ext4_mark_inode_dirty(handle, inode);
1129 if (err) {
1130 ext4_std_error(sb, err);
1131 goto fail_free_drop;
1132 }
1133
1134 ext4_debug("allocating inode %lu\n", inode->i_ino);
1135 trace_ext4_allocate_inode(inode, dir, mode);
1136 brelse(inode_bitmap_bh);
1137 return ret;
1138
1139fail_free_drop:
1140 dquot_free_inode(inode);
1141fail_drop:
1142 clear_nlink(inode);
1143 unlock_new_inode(inode);
1144out:
1145 dquot_drop(inode);
1146 inode->i_flags |= S_NOQUOTA;
1147 iput(inode);
1148 brelse(inode_bitmap_bh);
1149 return ERR_PTR(err);
1150}
1151
1152
1153struct inode *ext4_orphan_get(struct super_block *sb, unsigned long ino)
1154{
1155 unsigned long max_ino = le32_to_cpu(EXT4_SB(sb)->s_es->s_inodes_count);
1156 ext4_group_t block_group;
1157 int bit;
1158 struct buffer_head *bitmap_bh = NULL;
1159 struct inode *inode = NULL;
1160 int err = -EFSCORRUPTED;
1161
1162 if (ino < EXT4_FIRST_INO(sb) || ino > max_ino)
1163 goto bad_orphan;
1164
1165 block_group = (ino - 1) / EXT4_INODES_PER_GROUP(sb);
1166 bit = (ino - 1) % EXT4_INODES_PER_GROUP(sb);
1167 bitmap_bh = ext4_read_inode_bitmap(sb, block_group);
1168 if (IS_ERR(bitmap_bh)) {
1169 ext4_error(sb, "inode bitmap error %ld for orphan %lu",
1170 ino, PTR_ERR(bitmap_bh));
1171 return (struct inode *) bitmap_bh;
1172 }
1173
1174
1175
1176
1177
1178 if (!ext4_test_bit(bit, bitmap_bh->b_data))
1179 goto bad_orphan;
1180
1181 inode = ext4_iget(sb, ino);
1182 if (IS_ERR(inode)) {
1183 err = PTR_ERR(inode);
1184 ext4_error(sb, "couldn't read orphan inode %lu (err %d)",
1185 ino, err);
1186 return inode;
1187 }
1188
1189
1190
1191
1192
1193
1194
1195 if ((inode->i_nlink && !ext4_can_truncate(inode)) ||
1196 is_bad_inode(inode))
1197 goto bad_orphan;
1198
1199 if (NEXT_ORPHAN(inode) > max_ino)
1200 goto bad_orphan;
1201 brelse(bitmap_bh);
1202 return inode;
1203
1204bad_orphan:
1205 ext4_error(sb, "bad orphan inode %lu", ino);
1206 if (bitmap_bh)
1207 printk(KERN_ERR "ext4_test_bit(bit=%d, block=%llu) = %d\n",
1208 bit, (unsigned long long)bitmap_bh->b_blocknr,
1209 ext4_test_bit(bit, bitmap_bh->b_data));
1210 if (inode) {
1211 printk(KERN_ERR "is_bad_inode(inode)=%d\n",
1212 is_bad_inode(inode));
1213 printk(KERN_ERR "NEXT_ORPHAN(inode)=%u\n",
1214 NEXT_ORPHAN(inode));
1215 printk(KERN_ERR "max_ino=%lu\n", max_ino);
1216 printk(KERN_ERR "i_nlink=%u\n", inode->i_nlink);
1217
1218 if (inode->i_nlink == 0)
1219 inode->i_blocks = 0;
1220 iput(inode);
1221 }
1222 brelse(bitmap_bh);
1223 return ERR_PTR(err);
1224}
1225
1226unsigned long ext4_count_free_inodes(struct super_block *sb)
1227{
1228 unsigned long desc_count;
1229 struct ext4_group_desc *gdp;
1230 ext4_group_t i, ngroups = ext4_get_groups_count(sb);
1231#ifdef EXT4FS_DEBUG
1232 struct ext4_super_block *es;
1233 unsigned long bitmap_count, x;
1234 struct buffer_head *bitmap_bh = NULL;
1235
1236 es = EXT4_SB(sb)->s_es;
1237 desc_count = 0;
1238 bitmap_count = 0;
1239 gdp = NULL;
1240 for (i = 0; i < ngroups; i++) {
1241 gdp = ext4_get_group_desc(sb, i, NULL);
1242 if (!gdp)
1243 continue;
1244 desc_count += ext4_free_inodes_count(sb, gdp);
1245 brelse(bitmap_bh);
1246 bitmap_bh = ext4_read_inode_bitmap(sb, i);
1247 if (IS_ERR(bitmap_bh)) {
1248 bitmap_bh = NULL;
1249 continue;
1250 }
1251
1252 x = ext4_count_free(bitmap_bh->b_data,
1253 EXT4_INODES_PER_GROUP(sb) / 8);
1254 printk(KERN_DEBUG "group %lu: stored = %d, counted = %lu\n",
1255 (unsigned long) i, ext4_free_inodes_count(sb, gdp), x);
1256 bitmap_count += x;
1257 }
1258 brelse(bitmap_bh);
1259 printk(KERN_DEBUG "ext4_count_free_inodes: "
1260 "stored = %u, computed = %lu, %lu\n",
1261 le32_to_cpu(es->s_free_inodes_count), desc_count, bitmap_count);
1262 return desc_count;
1263#else
1264 desc_count = 0;
1265 for (i = 0; i < ngroups; i++) {
1266 gdp = ext4_get_group_desc(sb, i, NULL);
1267 if (!gdp)
1268 continue;
1269 desc_count += ext4_free_inodes_count(sb, gdp);
1270 cond_resched();
1271 }
1272 return desc_count;
1273#endif
1274}
1275
1276
1277unsigned long ext4_count_dirs(struct super_block * sb)
1278{
1279 unsigned long count = 0;
1280 ext4_group_t i, ngroups = ext4_get_groups_count(sb);
1281
1282 for (i = 0; i < ngroups; i++) {
1283 struct ext4_group_desc *gdp = ext4_get_group_desc(sb, i, NULL);
1284 if (!gdp)
1285 continue;
1286 count += ext4_used_dirs_count(sb, gdp);
1287 }
1288 return count;
1289}
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299int ext4_init_inode_table(struct super_block *sb, ext4_group_t group,
1300 int barrier)
1301{
1302 struct ext4_group_info *grp = ext4_get_group_info(sb, group);
1303 struct ext4_sb_info *sbi = EXT4_SB(sb);
1304 struct ext4_group_desc *gdp = NULL;
1305 struct buffer_head *group_desc_bh;
1306 handle_t *handle;
1307 ext4_fsblk_t blk;
1308 int num, ret = 0, used_blks = 0;
1309
1310
1311 if (sb->s_flags & MS_RDONLY) {
1312 ret = 1;
1313 goto out;
1314 }
1315
1316 gdp = ext4_get_group_desc(sb, group, &group_desc_bh);
1317 if (!gdp)
1318 goto out;
1319
1320
1321
1322
1323
1324 if (gdp->bg_flags & cpu_to_le16(EXT4_BG_INODE_ZEROED))
1325 goto out;
1326
1327 handle = ext4_journal_start_sb(sb, EXT4_HT_MISC, 1);
1328 if (IS_ERR(handle)) {
1329 ret = PTR_ERR(handle);
1330 goto out;
1331 }
1332
1333 down_write(&grp->alloc_sem);
1334
1335
1336
1337
1338
1339 if (!(gdp->bg_flags & cpu_to_le16(EXT4_BG_INODE_UNINIT)))
1340 used_blks = DIV_ROUND_UP((EXT4_INODES_PER_GROUP(sb) -
1341 ext4_itable_unused_count(sb, gdp)),
1342 sbi->s_inodes_per_block);
1343
1344 if ((used_blks < 0) || (used_blks > sbi->s_itb_per_group)) {
1345 ext4_error(sb, "Something is wrong with group %u: "
1346 "used itable blocks: %d; "
1347 "itable unused count: %u",
1348 group, used_blks,
1349 ext4_itable_unused_count(sb, gdp));
1350 ret = 1;
1351 goto err_out;
1352 }
1353
1354 blk = ext4_inode_table(sb, gdp) + used_blks;
1355 num = sbi->s_itb_per_group - used_blks;
1356
1357 BUFFER_TRACE(group_desc_bh, "get_write_access");
1358 ret = ext4_journal_get_write_access(handle,
1359 group_desc_bh);
1360 if (ret)
1361 goto err_out;
1362
1363
1364
1365
1366
1367
1368 if (unlikely(num == 0))
1369 goto skip_zeroout;
1370
1371 ext4_debug("going to zero out inode table in group %d\n",
1372 group);
1373 ret = sb_issue_zeroout(sb, blk, num, GFP_NOFS);
1374 if (ret < 0)
1375 goto err_out;
1376 if (barrier)
1377 blkdev_issue_flush(sb->s_bdev, GFP_NOFS, NULL);
1378
1379skip_zeroout:
1380 ext4_lock_group(sb, group);
1381 gdp->bg_flags |= cpu_to_le16(EXT4_BG_INODE_ZEROED);
1382 ext4_group_desc_csum_set(sb, group, gdp);
1383 ext4_unlock_group(sb, group);
1384
1385 BUFFER_TRACE(group_desc_bh,
1386 "call ext4_handle_dirty_metadata");
1387 ret = ext4_handle_dirty_metadata(handle, NULL,
1388 group_desc_bh);
1389
1390err_out:
1391 up_write(&grp->alloc_sem);
1392 ext4_journal_stop(handle);
1393out:
1394 return ret;
1395}
1396