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 dquot_free_inode(inode);
298 dquot_drop(inode);
299
300 is_directory = S_ISDIR(inode->i_mode);
301
302
303 ext4_clear_inode(inode);
304
305 es = EXT4_SB(sb)->s_es;
306 if (ino < EXT4_FIRST_INO(sb) || ino > le32_to_cpu(es->s_inodes_count)) {
307 ext4_error(sb, "reserved or nonexistent inode %lu", ino);
308 goto error_return;
309 }
310 block_group = (ino - 1) / EXT4_INODES_PER_GROUP(sb);
311 bit = (ino - 1) % EXT4_INODES_PER_GROUP(sb);
312 bitmap_bh = ext4_read_inode_bitmap(sb, block_group);
313
314 grp = ext4_get_group_info(sb, block_group);
315 if (IS_ERR(bitmap_bh)) {
316 fatal = PTR_ERR(bitmap_bh);
317 bitmap_bh = NULL;
318 goto error_return;
319 }
320 if (unlikely(EXT4_MB_GRP_IBITMAP_CORRUPT(grp))) {
321 fatal = -EFSCORRUPTED;
322 goto error_return;
323 }
324
325 BUFFER_TRACE(bitmap_bh, "get_write_access");
326 fatal = ext4_journal_get_write_access(handle, bitmap_bh);
327 if (fatal)
328 goto error_return;
329
330 fatal = -ESRCH;
331 gdp = ext4_get_group_desc(sb, block_group, &bh2);
332 if (gdp) {
333 BUFFER_TRACE(bh2, "get_write_access");
334 fatal = ext4_journal_get_write_access(handle, bh2);
335 }
336 ext4_lock_group(sb, block_group);
337 cleared = ext4_test_and_clear_bit(bit, bitmap_bh->b_data);
338 if (fatal || !cleared) {
339 ext4_unlock_group(sb, block_group);
340 goto out;
341 }
342
343 count = ext4_free_inodes_count(sb, gdp) + 1;
344 ext4_free_inodes_set(sb, gdp, count);
345 if (is_directory) {
346 count = ext4_used_dirs_count(sb, gdp) - 1;
347 ext4_used_dirs_set(sb, gdp, count);
348 percpu_counter_dec(&sbi->s_dirs_counter);
349 }
350 ext4_inode_bitmap_csum_set(sb, block_group, gdp, bitmap_bh,
351 EXT4_INODES_PER_GROUP(sb) / 8);
352 ext4_group_desc_csum_set(sb, block_group, gdp);
353 ext4_unlock_group(sb, block_group);
354
355 percpu_counter_inc(&sbi->s_freeinodes_counter);
356 if (sbi->s_log_groups_per_flex) {
357 ext4_group_t f = ext4_flex_group(sbi, block_group);
358
359 atomic_inc(&sbi->s_flex_groups[f].free_inodes);
360 if (is_directory)
361 atomic_dec(&sbi->s_flex_groups[f].used_dirs);
362 }
363 BUFFER_TRACE(bh2, "call ext4_handle_dirty_metadata");
364 fatal = ext4_handle_dirty_metadata(handle, NULL, bh2);
365out:
366 if (cleared) {
367 BUFFER_TRACE(bitmap_bh, "call ext4_handle_dirty_metadata");
368 err = ext4_handle_dirty_metadata(handle, NULL, bitmap_bh);
369 if (!fatal)
370 fatal = err;
371 } else {
372 ext4_error(sb, "bit already cleared for inode %lu", ino);
373 if (gdp && !EXT4_MB_GRP_IBITMAP_CORRUPT(grp)) {
374 int count;
375 count = ext4_free_inodes_count(sb, gdp);
376 percpu_counter_sub(&sbi->s_freeinodes_counter,
377 count);
378 }
379 set_bit(EXT4_GROUP_INFO_IBITMAP_CORRUPT_BIT, &grp->bb_state);
380 }
381
382error_return:
383 brelse(bitmap_bh);
384 ext4_std_error(sb, fatal);
385}
386
387struct orlov_stats {
388 __u64 free_clusters;
389 __u32 free_inodes;
390 __u32 used_dirs;
391};
392
393
394
395
396
397
398static void get_orlov_stats(struct super_block *sb, ext4_group_t g,
399 int flex_size, struct orlov_stats *stats)
400{
401 struct ext4_group_desc *desc;
402 struct flex_groups *flex_group = EXT4_SB(sb)->s_flex_groups;
403
404 if (flex_size > 1) {
405 stats->free_inodes = atomic_read(&flex_group[g].free_inodes);
406 stats->free_clusters = atomic64_read(&flex_group[g].free_clusters);
407 stats->used_dirs = atomic_read(&flex_group[g].used_dirs);
408 return;
409 }
410
411 desc = ext4_get_group_desc(sb, g, NULL);
412 if (desc) {
413 stats->free_inodes = ext4_free_inodes_count(sb, desc);
414 stats->free_clusters = ext4_free_group_clusters(sb, desc);
415 stats->used_dirs = ext4_used_dirs_count(sb, desc);
416 } else {
417 stats->free_inodes = 0;
418 stats->free_clusters = 0;
419 stats->used_dirs = 0;
420 }
421}
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444static int find_group_orlov(struct super_block *sb, struct inode *parent,
445 ext4_group_t *group, umode_t mode,
446 const struct qstr *qstr)
447{
448 ext4_group_t parent_group = EXT4_I(parent)->i_block_group;
449 struct ext4_sb_info *sbi = EXT4_SB(sb);
450 ext4_group_t real_ngroups = ext4_get_groups_count(sb);
451 int inodes_per_group = EXT4_INODES_PER_GROUP(sb);
452 unsigned int freei, avefreei, grp_free;
453 ext4_fsblk_t freeb, avefreec;
454 unsigned int ndirs;
455 int max_dirs, min_inodes;
456 ext4_grpblk_t min_clusters;
457 ext4_group_t i, grp, g, ngroups;
458 struct ext4_group_desc *desc;
459 struct orlov_stats stats;
460 int flex_size = ext4_flex_bg_size(sbi);
461 struct dx_hash_info hinfo;
462
463 ngroups = real_ngroups;
464 if (flex_size > 1) {
465 ngroups = (real_ngroups + flex_size - 1) >>
466 sbi->s_log_groups_per_flex;
467 parent_group >>= sbi->s_log_groups_per_flex;
468 }
469
470 freei = percpu_counter_read_positive(&sbi->s_freeinodes_counter);
471 avefreei = freei / ngroups;
472 freeb = EXT4_C2B(sbi,
473 percpu_counter_read_positive(&sbi->s_freeclusters_counter));
474 avefreec = freeb;
475 do_div(avefreec, ngroups);
476 ndirs = percpu_counter_read_positive(&sbi->s_dirs_counter);
477
478 if (S_ISDIR(mode) &&
479 ((parent == d_inode(sb->s_root)) ||
480 (ext4_test_inode_flag(parent, EXT4_INODE_TOPDIR)))) {
481 int best_ndir = inodes_per_group;
482 int ret = -1;
483
484 if (qstr) {
485 hinfo.hash_version = DX_HASH_HALF_MD4;
486 hinfo.seed = sbi->s_hash_seed;
487 ext4fs_dirhash(qstr->name, qstr->len, &hinfo);
488 grp = hinfo.hash;
489 } else
490 grp = prandom_u32();
491 parent_group = (unsigned)grp % ngroups;
492 for (i = 0; i < ngroups; i++) {
493 g = (parent_group + i) % ngroups;
494 get_orlov_stats(sb, g, flex_size, &stats);
495 if (!stats.free_inodes)
496 continue;
497 if (stats.used_dirs >= best_ndir)
498 continue;
499 if (stats.free_inodes < avefreei)
500 continue;
501 if (stats.free_clusters < avefreec)
502 continue;
503 grp = g;
504 ret = 0;
505 best_ndir = stats.used_dirs;
506 }
507 if (ret)
508 goto fallback;
509 found_flex_bg:
510 if (flex_size == 1) {
511 *group = grp;
512 return 0;
513 }
514
515
516
517
518
519
520
521
522 grp *= flex_size;
523 for (i = 0; i < flex_size; i++) {
524 if (grp+i >= real_ngroups)
525 break;
526 desc = ext4_get_group_desc(sb, grp+i, NULL);
527 if (desc && ext4_free_inodes_count(sb, desc)) {
528 *group = grp+i;
529 return 0;
530 }
531 }
532 goto fallback;
533 }
534
535 max_dirs = ndirs / ngroups + inodes_per_group / 16;
536 min_inodes = avefreei - inodes_per_group*flex_size / 4;
537 if (min_inodes < 1)
538 min_inodes = 1;
539 min_clusters = avefreec - EXT4_CLUSTERS_PER_GROUP(sb)*flex_size / 4;
540
541
542
543
544
545 if (EXT4_I(parent)->i_last_alloc_group != ~0) {
546 parent_group = EXT4_I(parent)->i_last_alloc_group;
547 if (flex_size > 1)
548 parent_group >>= sbi->s_log_groups_per_flex;
549 }
550
551 for (i = 0; i < ngroups; i++) {
552 grp = (parent_group + i) % ngroups;
553 get_orlov_stats(sb, grp, flex_size, &stats);
554 if (stats.used_dirs >= max_dirs)
555 continue;
556 if (stats.free_inodes < min_inodes)
557 continue;
558 if (stats.free_clusters < min_clusters)
559 continue;
560 goto found_flex_bg;
561 }
562
563fallback:
564 ngroups = real_ngroups;
565 avefreei = freei / ngroups;
566fallback_retry:
567 parent_group = EXT4_I(parent)->i_block_group;
568 for (i = 0; i < ngroups; i++) {
569 grp = (parent_group + i) % ngroups;
570 desc = ext4_get_group_desc(sb, grp, NULL);
571 if (desc) {
572 grp_free = ext4_free_inodes_count(sb, desc);
573 if (grp_free && grp_free >= avefreei) {
574 *group = grp;
575 return 0;
576 }
577 }
578 }
579
580 if (avefreei) {
581
582
583
584
585 avefreei = 0;
586 goto fallback_retry;
587 }
588
589 return -1;
590}
591
592static int find_group_other(struct super_block *sb, struct inode *parent,
593 ext4_group_t *group, umode_t mode)
594{
595 ext4_group_t parent_group = EXT4_I(parent)->i_block_group;
596 ext4_group_t i, last, ngroups = ext4_get_groups_count(sb);
597 struct ext4_group_desc *desc;
598 int flex_size = ext4_flex_bg_size(EXT4_SB(sb));
599
600
601
602
603
604
605
606
607 if (flex_size > 1) {
608 int retry = 0;
609
610 try_again:
611 parent_group &= ~(flex_size-1);
612 last = parent_group + flex_size;
613 if (last > ngroups)
614 last = ngroups;
615 for (i = parent_group; i < last; i++) {
616 desc = ext4_get_group_desc(sb, i, NULL);
617 if (desc && ext4_free_inodes_count(sb, desc)) {
618 *group = i;
619 return 0;
620 }
621 }
622 if (!retry && EXT4_I(parent)->i_last_alloc_group != ~0) {
623 retry = 1;
624 parent_group = EXT4_I(parent)->i_last_alloc_group;
625 goto try_again;
626 }
627
628
629
630
631
632 *group = parent_group + flex_size;
633 if (*group > ngroups)
634 *group = 0;
635 return find_group_orlov(sb, parent, group, mode, NULL);
636 }
637
638
639
640
641 *group = parent_group;
642 desc = ext4_get_group_desc(sb, *group, NULL);
643 if (desc && ext4_free_inodes_count(sb, desc) &&
644 ext4_free_group_clusters(sb, desc))
645 return 0;
646
647
648
649
650
651
652
653
654
655
656 *group = (*group + parent->i_ino) % ngroups;
657
658
659
660
661
662 for (i = 1; i < ngroups; i <<= 1) {
663 *group += i;
664 if (*group >= ngroups)
665 *group -= ngroups;
666 desc = ext4_get_group_desc(sb, *group, NULL);
667 if (desc && ext4_free_inodes_count(sb, desc) &&
668 ext4_free_group_clusters(sb, desc))
669 return 0;
670 }
671
672
673
674
675
676 *group = parent_group;
677 for (i = 0; i < ngroups; i++) {
678 if (++*group >= ngroups)
679 *group = 0;
680 desc = ext4_get_group_desc(sb, *group, NULL);
681 if (desc && ext4_free_inodes_count(sb, desc))
682 return 0;
683 }
684
685 return -1;
686}
687
688
689
690
691
692
693
694#define RECENTCY_MIN 5
695#define RECENTCY_DIRTY 30
696
697static int recently_deleted(struct super_block *sb, ext4_group_t group, int ino)
698{
699 struct ext4_group_desc *gdp;
700 struct ext4_inode *raw_inode;
701 struct buffer_head *bh;
702 unsigned long dtime, now;
703 int inodes_per_block = EXT4_SB(sb)->s_inodes_per_block;
704 int offset, ret = 0, recentcy = RECENTCY_MIN;
705
706 gdp = ext4_get_group_desc(sb, group, NULL);
707 if (unlikely(!gdp))
708 return 0;
709
710 bh = sb_getblk(sb, ext4_inode_table(sb, gdp) +
711 (ino / inodes_per_block));
712 if (unlikely(!bh) || !buffer_uptodate(bh))
713
714
715
716
717 goto out;
718
719 offset = (ino % inodes_per_block) * EXT4_INODE_SIZE(sb);
720 raw_inode = (struct ext4_inode *) (bh->b_data + offset);
721 dtime = le32_to_cpu(raw_inode->i_dtime);
722 now = get_seconds();
723 if (buffer_dirty(bh))
724 recentcy += RECENTCY_DIRTY;
725
726 if (dtime && (dtime < now) && (now < dtime + recentcy))
727 ret = 1;
728out:
729 brelse(bh);
730 return ret;
731}
732
733
734
735
736
737
738
739
740
741
742
743struct inode *__ext4_new_inode(handle_t *handle, struct inode *dir,
744 umode_t mode, const struct qstr *qstr,
745 __u32 goal, uid_t *owner, __u32 i_flags,
746 int handle_type, unsigned int line_no,
747 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 sb = dir->i_sb;
770 sbi = EXT4_SB(sb);
771
772 if (unlikely(ext4_forced_shutdown(sbi)))
773 return ERR_PTR(-EIO);
774
775 if ((ext4_encrypted_inode(dir) || DUMMY_ENCRYPTION_ENABLED(sbi)) &&
776 (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)) &&
777 !(i_flags & EXT4_EA_INODE_FL)) {
778 err = fscrypt_get_encryption_info(dir);
779 if (err)
780 return ERR_PTR(err);
781 if (!fscrypt_has_encryption_key(dir))
782 return ERR_PTR(-ENOKEY);
783 encrypt = 1;
784 }
785
786 if (!handle && sbi->s_journal && !(i_flags & EXT4_EA_INODE_FL)) {
787#ifdef CONFIG_EXT4_FS_POSIX_ACL
788 struct posix_acl *p = get_acl(dir, ACL_TYPE_DEFAULT);
789
790 if (p) {
791 int acl_size = p->a_count * sizeof(ext4_acl_entry);
792
793 nblocks += (S_ISDIR(mode) ? 2 : 1) *
794 __ext4_xattr_set_credits(sb, NULL ,
795 NULL , acl_size,
796 true );
797 posix_acl_release(p);
798 }
799#endif
800
801#ifdef CONFIG_SECURITY
802 {
803 int num_security_xattrs = 1;
804
805#ifdef CONFIG_INTEGRITY
806 num_security_xattrs++;
807#endif
808
809
810
811
812
813 nblocks += num_security_xattrs *
814 __ext4_xattr_set_credits(sb, NULL ,
815 NULL , 1024,
816 true );
817 }
818#endif
819 if (encrypt)
820 nblocks += __ext4_xattr_set_credits(sb,
821 NULL , NULL ,
822 FSCRYPT_SET_CONTEXT_MAX_SIZE,
823 true );
824 }
825
826 ngroups = ext4_get_groups_count(sb);
827 trace_ext4_request_inode(dir, mode);
828 inode = new_inode(sb);
829 if (!inode)
830 return ERR_PTR(-ENOMEM);
831 ei = EXT4_I(inode);
832
833
834
835
836
837
838 if (owner) {
839 inode->i_mode = mode;
840 i_uid_write(inode, owner[0]);
841 i_gid_write(inode, owner[1]);
842 } else if (test_opt(sb, GRPID)) {
843 inode->i_mode = mode;
844 inode->i_uid = current_fsuid();
845 inode->i_gid = dir->i_gid;
846 } else
847 inode_init_owner(inode, dir, mode);
848
849 if (ext4_has_feature_project(sb) &&
850 ext4_test_inode_flag(dir, EXT4_INODE_PROJINHERIT))
851 ei->i_projid = EXT4_I(dir)->i_projid;
852 else
853 ei->i_projid = make_kprojid(&init_user_ns, EXT4_DEF_PROJID);
854
855 err = dquot_initialize(inode);
856 if (err)
857 goto out;
858
859 if (!goal)
860 goal = sbi->s_inode_goal;
861
862 if (goal && goal <= le32_to_cpu(sbi->s_es->s_inodes_count)) {
863 group = (goal - 1) / EXT4_INODES_PER_GROUP(sb);
864 ino = (goal - 1) % EXT4_INODES_PER_GROUP(sb);
865 ret2 = 0;
866 goto got_group;
867 }
868
869 if (S_ISDIR(mode))
870 ret2 = find_group_orlov(sb, dir, &group, mode, qstr);
871 else
872 ret2 = find_group_other(sb, dir, &group, mode);
873
874got_group:
875 EXT4_I(dir)->i_last_alloc_group = group;
876 err = -ENOSPC;
877 if (ret2 == -1)
878 goto out;
879
880
881
882
883
884
885 for (i = 0; i < ngroups; i++, ino = 0) {
886 err = -EIO;
887
888 gdp = ext4_get_group_desc(sb, group, &group_desc_bh);
889 if (!gdp)
890 goto out;
891
892
893
894
895 if (ext4_free_inodes_count(sb, gdp) == 0) {
896 if (++group == ngroups)
897 group = 0;
898 continue;
899 }
900
901 grp = ext4_get_group_info(sb, group);
902
903 if (EXT4_MB_GRP_IBITMAP_CORRUPT(grp)) {
904 if (++group == ngroups)
905 group = 0;
906 continue;
907 }
908
909 brelse(inode_bitmap_bh);
910 inode_bitmap_bh = ext4_read_inode_bitmap(sb, group);
911
912 if (EXT4_MB_GRP_IBITMAP_CORRUPT(grp) ||
913 IS_ERR(inode_bitmap_bh)) {
914 inode_bitmap_bh = NULL;
915 if (++group == ngroups)
916 group = 0;
917 continue;
918 }
919
920repeat_in_this_group:
921 ino = ext4_find_next_zero_bit((unsigned long *)
922 inode_bitmap_bh->b_data,
923 EXT4_INODES_PER_GROUP(sb), ino);
924 if (ino >= EXT4_INODES_PER_GROUP(sb))
925 goto next_group;
926 if (group == 0 && (ino+1) < EXT4_FIRST_INO(sb)) {
927 ext4_error(sb, "reserved inode found cleared - "
928 "inode=%lu", ino + 1);
929 continue;
930 }
931 if ((EXT4_SB(sb)->s_journal == NULL) &&
932 recently_deleted(sb, group, ino)) {
933 ino++;
934 goto next_inode;
935 }
936 if (!handle) {
937 BUG_ON(nblocks <= 0);
938 handle = __ext4_journal_start_sb(dir->i_sb, line_no,
939 handle_type, nblocks,
940 0);
941 if (IS_ERR(handle)) {
942 err = PTR_ERR(handle);
943 ext4_std_error(sb, err);
944 goto out;
945 }
946 }
947 BUFFER_TRACE(inode_bitmap_bh, "get_write_access");
948 err = ext4_journal_get_write_access(handle, inode_bitmap_bh);
949 if (err) {
950 ext4_std_error(sb, err);
951 goto out;
952 }
953 ext4_lock_group(sb, group);
954 ret2 = ext4_test_and_set_bit(ino, inode_bitmap_bh->b_data);
955 ext4_unlock_group(sb, group);
956 ino++;
957 if (!ret2)
958 goto got;
959next_inode:
960 if (ino < EXT4_INODES_PER_GROUP(sb))
961 goto repeat_in_this_group;
962next_group:
963 if (++group == ngroups)
964 group = 0;
965 }
966 err = -ENOSPC;
967 goto out;
968
969got:
970 BUFFER_TRACE(inode_bitmap_bh, "call ext4_handle_dirty_metadata");
971 err = ext4_handle_dirty_metadata(handle, NULL, inode_bitmap_bh);
972 if (err) {
973 ext4_std_error(sb, err);
974 goto out;
975 }
976
977 BUFFER_TRACE(group_desc_bh, "get_write_access");
978 err = ext4_journal_get_write_access(handle, group_desc_bh);
979 if (err) {
980 ext4_std_error(sb, err);
981 goto out;
982 }
983
984
985 if (ext4_has_group_desc_csum(sb) &&
986 gdp->bg_flags & cpu_to_le16(EXT4_BG_BLOCK_UNINIT)) {
987 struct buffer_head *block_bitmap_bh;
988
989 block_bitmap_bh = ext4_read_block_bitmap(sb, group);
990 if (IS_ERR(block_bitmap_bh)) {
991 err = PTR_ERR(block_bitmap_bh);
992 goto out;
993 }
994 BUFFER_TRACE(block_bitmap_bh, "get block bitmap access");
995 err = ext4_journal_get_write_access(handle, block_bitmap_bh);
996 if (err) {
997 brelse(block_bitmap_bh);
998 ext4_std_error(sb, err);
999 goto out;
1000 }
1001
1002 BUFFER_TRACE(block_bitmap_bh, "dirty block bitmap");
1003 err = ext4_handle_dirty_metadata(handle, NULL, block_bitmap_bh);
1004
1005
1006 ext4_lock_group(sb, group);
1007 if (gdp->bg_flags & cpu_to_le16(EXT4_BG_BLOCK_UNINIT)) {
1008 gdp->bg_flags &= cpu_to_le16(~EXT4_BG_BLOCK_UNINIT);
1009 ext4_free_group_clusters_set(sb, gdp,
1010 ext4_free_clusters_after_init(sb, group, gdp));
1011 ext4_block_bitmap_csum_set(sb, group, gdp,
1012 block_bitmap_bh);
1013 ext4_group_desc_csum_set(sb, group, gdp);
1014 }
1015 ext4_unlock_group(sb, group);
1016 brelse(block_bitmap_bh);
1017
1018 if (err) {
1019 ext4_std_error(sb, err);
1020 goto out;
1021 }
1022 }
1023
1024
1025 if (ext4_has_group_desc_csum(sb)) {
1026 int free;
1027 struct ext4_group_info *grp = ext4_get_group_info(sb, group);
1028
1029 down_read(&grp->alloc_sem);
1030 ext4_lock_group(sb, group);
1031 free = EXT4_INODES_PER_GROUP(sb) -
1032 ext4_itable_unused_count(sb, gdp);
1033 if (gdp->bg_flags & cpu_to_le16(EXT4_BG_INODE_UNINIT)) {
1034 gdp->bg_flags &= cpu_to_le16(~EXT4_BG_INODE_UNINIT);
1035 free = 0;
1036 }
1037
1038
1039
1040
1041
1042 if (ino > free)
1043 ext4_itable_unused_set(sb, gdp,
1044 (EXT4_INODES_PER_GROUP(sb) - ino));
1045 up_read(&grp->alloc_sem);
1046 } else {
1047 ext4_lock_group(sb, group);
1048 }
1049
1050 ext4_free_inodes_set(sb, gdp, ext4_free_inodes_count(sb, gdp) - 1);
1051 if (S_ISDIR(mode)) {
1052 ext4_used_dirs_set(sb, gdp, ext4_used_dirs_count(sb, gdp) + 1);
1053 if (sbi->s_log_groups_per_flex) {
1054 ext4_group_t f = ext4_flex_group(sbi, group);
1055
1056 atomic_inc(&sbi->s_flex_groups[f].used_dirs);
1057 }
1058 }
1059 if (ext4_has_group_desc_csum(sb)) {
1060 ext4_inode_bitmap_csum_set(sb, group, gdp, inode_bitmap_bh,
1061 EXT4_INODES_PER_GROUP(sb) / 8);
1062 ext4_group_desc_csum_set(sb, group, gdp);
1063 }
1064 ext4_unlock_group(sb, group);
1065
1066 BUFFER_TRACE(group_desc_bh, "call ext4_handle_dirty_metadata");
1067 err = ext4_handle_dirty_metadata(handle, NULL, group_desc_bh);
1068 if (err) {
1069 ext4_std_error(sb, err);
1070 goto out;
1071 }
1072
1073 percpu_counter_dec(&sbi->s_freeinodes_counter);
1074 if (S_ISDIR(mode))
1075 percpu_counter_inc(&sbi->s_dirs_counter);
1076
1077 if (sbi->s_log_groups_per_flex) {
1078 flex_group = ext4_flex_group(sbi, group);
1079 atomic_dec(&sbi->s_flex_groups[flex_group].free_inodes);
1080 }
1081
1082 inode->i_ino = ino + group * EXT4_INODES_PER_GROUP(sb);
1083
1084 inode->i_blocks = 0;
1085 inode->i_mtime = inode->i_atime = inode->i_ctime = ei->i_crtime =
1086 current_time(inode);
1087
1088 memset(ei->i_data, 0, sizeof(ei->i_data));
1089 ei->i_dir_start_lookup = 0;
1090 ei->i_disksize = 0;
1091
1092
1093 ei->i_flags =
1094 ext4_mask_flags(mode, EXT4_I(dir)->i_flags & EXT4_FL_INHERITED);
1095 ei->i_flags |= i_flags;
1096 ei->i_file_acl = 0;
1097 ei->i_dtime = 0;
1098 ei->i_block_group = group;
1099 ei->i_last_alloc_group = ~0;
1100
1101 ext4_set_inode_flags(inode);
1102 if (IS_DIRSYNC(inode))
1103 ext4_handle_sync(handle);
1104 if (insert_inode_locked(inode) < 0) {
1105
1106
1107
1108
1109 err = -EIO;
1110 ext4_error(sb, "failed to insert inode %lu: doubly allocated?",
1111 inode->i_ino);
1112 goto out;
1113 }
1114 spin_lock(&sbi->s_next_gen_lock);
1115 inode->i_generation = sbi->s_next_generation++;
1116 spin_unlock(&sbi->s_next_gen_lock);
1117
1118
1119 if (ext4_has_metadata_csum(sb)) {
1120 __u32 csum;
1121 __le32 inum = cpu_to_le32(inode->i_ino);
1122 __le32 gen = cpu_to_le32(inode->i_generation);
1123 csum = ext4_chksum(sbi, sbi->s_csum_seed, (__u8 *)&inum,
1124 sizeof(inum));
1125 ei->i_csum_seed = ext4_chksum(sbi, csum, (__u8 *)&gen,
1126 sizeof(gen));
1127 }
1128
1129 ext4_clear_state_flags(ei);
1130 ext4_set_inode_state(inode, EXT4_STATE_NEW);
1131
1132 ei->i_extra_isize = EXT4_SB(sb)->s_want_extra_isize;
1133 ei->i_inline_off = 0;
1134 if (ext4_has_feature_inline_data(sb))
1135 ext4_set_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA);
1136 ret = inode;
1137 err = dquot_alloc_inode(inode);
1138 if (err)
1139 goto fail_drop;
1140
1141
1142
1143
1144
1145
1146 if (encrypt) {
1147 err = fscrypt_inherit_context(dir, inode, handle, true);
1148 if (err)
1149 goto fail_free_drop;
1150 }
1151
1152 if (!(ei->i_flags & EXT4_EA_INODE_FL)) {
1153 err = ext4_init_acl(handle, inode, dir);
1154 if (err)
1155 goto fail_free_drop;
1156
1157 err = ext4_init_security(handle, inode, dir, qstr);
1158 if (err)
1159 goto fail_free_drop;
1160 }
1161
1162 if (ext4_has_feature_extents(sb)) {
1163
1164 if (S_ISDIR(mode) || S_ISREG(mode) || S_ISLNK(mode)) {
1165 ext4_set_inode_flag(inode, EXT4_INODE_EXTENTS);
1166 ext4_ext_tree_init(handle, inode);
1167 }
1168 }
1169
1170 if (ext4_handle_valid(handle)) {
1171 ei->i_sync_tid = handle->h_transaction->t_tid;
1172 ei->i_datasync_tid = handle->h_transaction->t_tid;
1173 }
1174
1175 err = ext4_mark_inode_dirty(handle, inode);
1176 if (err) {
1177 ext4_std_error(sb, err);
1178 goto fail_free_drop;
1179 }
1180
1181 ext4_debug("allocating inode %lu\n", inode->i_ino);
1182 trace_ext4_allocate_inode(inode, dir, mode);
1183 brelse(inode_bitmap_bh);
1184 return ret;
1185
1186fail_free_drop:
1187 dquot_free_inode(inode);
1188fail_drop:
1189 clear_nlink(inode);
1190 unlock_new_inode(inode);
1191out:
1192 dquot_drop(inode);
1193 inode->i_flags |= S_NOQUOTA;
1194 iput(inode);
1195 brelse(inode_bitmap_bh);
1196 return ERR_PTR(err);
1197}
1198
1199
1200struct inode *ext4_orphan_get(struct super_block *sb, unsigned long ino)
1201{
1202 unsigned long max_ino = le32_to_cpu(EXT4_SB(sb)->s_es->s_inodes_count);
1203 ext4_group_t block_group;
1204 int bit;
1205 struct buffer_head *bitmap_bh = NULL;
1206 struct inode *inode = NULL;
1207 int err = -EFSCORRUPTED;
1208
1209 if (ino < EXT4_FIRST_INO(sb) || ino > max_ino)
1210 goto bad_orphan;
1211
1212 block_group = (ino - 1) / EXT4_INODES_PER_GROUP(sb);
1213 bit = (ino - 1) % EXT4_INODES_PER_GROUP(sb);
1214 bitmap_bh = ext4_read_inode_bitmap(sb, block_group);
1215 if (IS_ERR(bitmap_bh)) {
1216 ext4_error(sb, "inode bitmap error %ld for orphan %lu",
1217 ino, PTR_ERR(bitmap_bh));
1218 return (struct inode *) bitmap_bh;
1219 }
1220
1221
1222
1223
1224
1225 if (!ext4_test_bit(bit, bitmap_bh->b_data))
1226 goto bad_orphan;
1227
1228 inode = ext4_iget(sb, ino);
1229 if (IS_ERR(inode)) {
1230 err = PTR_ERR(inode);
1231 ext4_error(sb, "couldn't read orphan inode %lu (err %d)",
1232 ino, err);
1233 return inode;
1234 }
1235
1236
1237
1238
1239
1240
1241
1242 if ((inode->i_nlink && !ext4_can_truncate(inode)) ||
1243 is_bad_inode(inode))
1244 goto bad_orphan;
1245
1246 if (NEXT_ORPHAN(inode) > max_ino)
1247 goto bad_orphan;
1248 brelse(bitmap_bh);
1249 return inode;
1250
1251bad_orphan:
1252 ext4_error(sb, "bad orphan inode %lu", ino);
1253 if (bitmap_bh)
1254 printk(KERN_ERR "ext4_test_bit(bit=%d, block=%llu) = %d\n",
1255 bit, (unsigned long long)bitmap_bh->b_blocknr,
1256 ext4_test_bit(bit, bitmap_bh->b_data));
1257 if (inode) {
1258 printk(KERN_ERR "is_bad_inode(inode)=%d\n",
1259 is_bad_inode(inode));
1260 printk(KERN_ERR "NEXT_ORPHAN(inode)=%u\n",
1261 NEXT_ORPHAN(inode));
1262 printk(KERN_ERR "max_ino=%lu\n", max_ino);
1263 printk(KERN_ERR "i_nlink=%u\n", inode->i_nlink);
1264
1265 if (inode->i_nlink == 0)
1266 inode->i_blocks = 0;
1267 iput(inode);
1268 }
1269 brelse(bitmap_bh);
1270 return ERR_PTR(err);
1271}
1272
1273unsigned long ext4_count_free_inodes(struct super_block *sb)
1274{
1275 unsigned long desc_count;
1276 struct ext4_group_desc *gdp;
1277 ext4_group_t i, ngroups = ext4_get_groups_count(sb);
1278#ifdef EXT4FS_DEBUG
1279 struct ext4_super_block *es;
1280 unsigned long bitmap_count, x;
1281 struct buffer_head *bitmap_bh = NULL;
1282
1283 es = EXT4_SB(sb)->s_es;
1284 desc_count = 0;
1285 bitmap_count = 0;
1286 gdp = NULL;
1287 for (i = 0; i < ngroups; i++) {
1288 gdp = ext4_get_group_desc(sb, i, NULL);
1289 if (!gdp)
1290 continue;
1291 desc_count += ext4_free_inodes_count(sb, gdp);
1292 brelse(bitmap_bh);
1293 bitmap_bh = ext4_read_inode_bitmap(sb, i);
1294 if (IS_ERR(bitmap_bh)) {
1295 bitmap_bh = NULL;
1296 continue;
1297 }
1298
1299 x = ext4_count_free(bitmap_bh->b_data,
1300 EXT4_INODES_PER_GROUP(sb) / 8);
1301 printk(KERN_DEBUG "group %lu: stored = %d, counted = %lu\n",
1302 (unsigned long) i, ext4_free_inodes_count(sb, gdp), x);
1303 bitmap_count += x;
1304 }
1305 brelse(bitmap_bh);
1306 printk(KERN_DEBUG "ext4_count_free_inodes: "
1307 "stored = %u, computed = %lu, %lu\n",
1308 le32_to_cpu(es->s_free_inodes_count), desc_count, bitmap_count);
1309 return desc_count;
1310#else
1311 desc_count = 0;
1312 for (i = 0; i < ngroups; i++) {
1313 gdp = ext4_get_group_desc(sb, i, NULL);
1314 if (!gdp)
1315 continue;
1316 desc_count += ext4_free_inodes_count(sb, gdp);
1317 cond_resched();
1318 }
1319 return desc_count;
1320#endif
1321}
1322
1323
1324unsigned long ext4_count_dirs(struct super_block * sb)
1325{
1326 unsigned long count = 0;
1327 ext4_group_t i, ngroups = ext4_get_groups_count(sb);
1328
1329 for (i = 0; i < ngroups; i++) {
1330 struct ext4_group_desc *gdp = ext4_get_group_desc(sb, i, NULL);
1331 if (!gdp)
1332 continue;
1333 count += ext4_used_dirs_count(sb, gdp);
1334 }
1335 return count;
1336}
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346int ext4_init_inode_table(struct super_block *sb, ext4_group_t group,
1347 int barrier)
1348{
1349 struct ext4_group_info *grp = ext4_get_group_info(sb, group);
1350 struct ext4_sb_info *sbi = EXT4_SB(sb);
1351 struct ext4_group_desc *gdp = NULL;
1352 struct buffer_head *group_desc_bh;
1353 handle_t *handle;
1354 ext4_fsblk_t blk;
1355 int num, ret = 0, used_blks = 0;
1356
1357
1358 if (sb->s_flags & MS_RDONLY) {
1359 ret = 1;
1360 goto out;
1361 }
1362
1363 gdp = ext4_get_group_desc(sb, group, &group_desc_bh);
1364 if (!gdp)
1365 goto out;
1366
1367
1368
1369
1370
1371 if (gdp->bg_flags & cpu_to_le16(EXT4_BG_INODE_ZEROED))
1372 goto out;
1373
1374 handle = ext4_journal_start_sb(sb, EXT4_HT_MISC, 1);
1375 if (IS_ERR(handle)) {
1376 ret = PTR_ERR(handle);
1377 goto out;
1378 }
1379
1380 down_write(&grp->alloc_sem);
1381
1382
1383
1384
1385
1386 if (!(gdp->bg_flags & cpu_to_le16(EXT4_BG_INODE_UNINIT)))
1387 used_blks = DIV_ROUND_UP((EXT4_INODES_PER_GROUP(sb) -
1388 ext4_itable_unused_count(sb, gdp)),
1389 sbi->s_inodes_per_block);
1390
1391 if ((used_blks < 0) || (used_blks > sbi->s_itb_per_group)) {
1392 ext4_error(sb, "Something is wrong with group %u: "
1393 "used itable blocks: %d; "
1394 "itable unused count: %u",
1395 group, used_blks,
1396 ext4_itable_unused_count(sb, gdp));
1397 ret = 1;
1398 goto err_out;
1399 }
1400
1401 blk = ext4_inode_table(sb, gdp) + used_blks;
1402 num = sbi->s_itb_per_group - used_blks;
1403
1404 BUFFER_TRACE(group_desc_bh, "get_write_access");
1405 ret = ext4_journal_get_write_access(handle,
1406 group_desc_bh);
1407 if (ret)
1408 goto err_out;
1409
1410
1411
1412
1413
1414
1415 if (unlikely(num == 0))
1416 goto skip_zeroout;
1417
1418 ext4_debug("going to zero out inode table in group %d\n",
1419 group);
1420 ret = sb_issue_zeroout(sb, blk, num, GFP_NOFS);
1421 if (ret < 0)
1422 goto err_out;
1423 if (barrier)
1424 blkdev_issue_flush(sb->s_bdev, GFP_NOFS, NULL);
1425
1426skip_zeroout:
1427 ext4_lock_group(sb, group);
1428 gdp->bg_flags |= cpu_to_le16(EXT4_BG_INODE_ZEROED);
1429 ext4_group_desc_csum_set(sb, group, gdp);
1430 ext4_unlock_group(sb, group);
1431
1432 BUFFER_TRACE(group_desc_bh,
1433 "call ext4_handle_dirty_metadata");
1434 ret = ext4_handle_dirty_metadata(handle, NULL,
1435 group_desc_bh);
1436
1437err_out:
1438 up_write(&grp->alloc_sem);
1439 ext4_journal_stop(handle);
1440out:
1441 return ret;
1442}
1443