1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20#include <linux/module.h>
21#include <linux/string.h>
22#include <linux/fs.h>
23#include <linux/time.h>
24#include <linux/vmalloc.h>
25#include <linux/slab.h>
26#include <linux/init.h>
27#include <linux/blkdev.h>
28#include <linux/backing-dev.h>
29#include <linux/parser.h>
30#include <linux/buffer_head.h>
31#include <linux/exportfs.h>
32#include <linux/vfs.h>
33#include <linux/random.h>
34#include <linux/mount.h>
35#include <linux/namei.h>
36#include <linux/quotaops.h>
37#include <linux/seq_file.h>
38#include <linux/ctype.h>
39#include <linux/log2.h>
40#include <linux/crc16.h>
41#include <linux/dax.h>
42#include <linux/cleancache.h>
43#include <linux/uaccess.h>
44#include <linux/iversion.h>
45#include <linux/unicode.h>
46#include <linux/part_stat.h>
47#include <linux/kthread.h>
48#include <linux/freezer.h>
49
50#include "ext4.h"
51#include "ext4_extents.h"
52#include "ext4_jbd2.h"
53#include "xattr.h"
54#include "acl.h"
55#include "mballoc.h"
56#include "fsmap.h"
57
58#define CREATE_TRACE_POINTS
59#include <trace/events/ext4.h>
60
61static struct ext4_lazy_init *ext4_li_info;
62static DEFINE_MUTEX(ext4_li_mtx);
63static struct ratelimit_state ext4_mount_msg_ratelimit;
64
65static int ext4_load_journal(struct super_block *, struct ext4_super_block *,
66 unsigned long journal_devnum);
67static int ext4_show_options(struct seq_file *seq, struct dentry *root);
68static void ext4_update_super(struct super_block *sb);
69static int ext4_commit_super(struct super_block *sb);
70static int ext4_mark_recovery_complete(struct super_block *sb,
71 struct ext4_super_block *es);
72static int ext4_clear_journal_err(struct super_block *sb,
73 struct ext4_super_block *es);
74static int ext4_sync_fs(struct super_block *sb, int wait);
75static int ext4_remount(struct super_block *sb, int *flags, char *data);
76static int ext4_statfs(struct dentry *dentry, struct kstatfs *buf);
77static int ext4_unfreeze(struct super_block *sb);
78static int ext4_freeze(struct super_block *sb);
79static struct dentry *ext4_mount(struct file_system_type *fs_type, int flags,
80 const char *dev_name, void *data);
81static inline int ext2_feature_set_ok(struct super_block *sb);
82static inline int ext3_feature_set_ok(struct super_block *sb);
83static void ext4_destroy_lazyinit_thread(void);
84static void ext4_unregister_li_request(struct super_block *sb);
85static void ext4_clear_request_list(void);
86static struct inode *ext4_get_journal_inode(struct super_block *sb,
87 unsigned int journal_inum);
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115#if !defined(CONFIG_EXT2_FS) && !defined(CONFIG_EXT2_FS_MODULE) && defined(CONFIG_EXT4_USE_FOR_EXT2)
116static struct file_system_type ext2_fs_type = {
117 .owner = THIS_MODULE,
118 .name = "ext2",
119 .mount = ext4_mount,
120 .kill_sb = kill_block_super,
121 .fs_flags = FS_REQUIRES_DEV,
122};
123MODULE_ALIAS_FS("ext2");
124MODULE_ALIAS("ext2");
125#define IS_EXT2_SB(sb) ((sb)->s_bdev->bd_holder == &ext2_fs_type)
126#else
127#define IS_EXT2_SB(sb) (0)
128#endif
129
130
131static struct file_system_type ext3_fs_type = {
132 .owner = THIS_MODULE,
133 .name = "ext3",
134 .mount = ext4_mount,
135 .kill_sb = kill_block_super,
136 .fs_flags = FS_REQUIRES_DEV,
137};
138MODULE_ALIAS_FS("ext3");
139MODULE_ALIAS("ext3");
140#define IS_EXT3_SB(sb) ((sb)->s_bdev->bd_holder == &ext3_fs_type)
141
142
143static inline void __ext4_read_bh(struct buffer_head *bh, int op_flags,
144 bh_end_io_t *end_io)
145{
146
147
148
149
150
151 clear_buffer_verified(bh);
152
153 bh->b_end_io = end_io ? end_io : end_buffer_read_sync;
154 get_bh(bh);
155 submit_bh(REQ_OP_READ, op_flags, bh);
156}
157
158void ext4_read_bh_nowait(struct buffer_head *bh, int op_flags,
159 bh_end_io_t *end_io)
160{
161 BUG_ON(!buffer_locked(bh));
162
163 if (ext4_buffer_uptodate(bh)) {
164 unlock_buffer(bh);
165 return;
166 }
167 __ext4_read_bh(bh, op_flags, end_io);
168}
169
170int ext4_read_bh(struct buffer_head *bh, int op_flags, bh_end_io_t *end_io)
171{
172 BUG_ON(!buffer_locked(bh));
173
174 if (ext4_buffer_uptodate(bh)) {
175 unlock_buffer(bh);
176 return 0;
177 }
178
179 __ext4_read_bh(bh, op_flags, end_io);
180
181 wait_on_buffer(bh);
182 if (buffer_uptodate(bh))
183 return 0;
184 return -EIO;
185}
186
187int ext4_read_bh_lock(struct buffer_head *bh, int op_flags, bool wait)
188{
189 if (trylock_buffer(bh)) {
190 if (wait)
191 return ext4_read_bh(bh, op_flags, NULL);
192 ext4_read_bh_nowait(bh, op_flags, NULL);
193 return 0;
194 }
195 if (wait) {
196 wait_on_buffer(bh);
197 if (buffer_uptodate(bh))
198 return 0;
199 return -EIO;
200 }
201 return 0;
202}
203
204
205
206
207
208
209
210static struct buffer_head *__ext4_sb_bread_gfp(struct super_block *sb,
211 sector_t block, int op_flags,
212 gfp_t gfp)
213{
214 struct buffer_head *bh;
215 int ret;
216
217 bh = sb_getblk_gfp(sb, block, gfp);
218 if (bh == NULL)
219 return ERR_PTR(-ENOMEM);
220 if (ext4_buffer_uptodate(bh))
221 return bh;
222
223 ret = ext4_read_bh_lock(bh, REQ_META | op_flags, true);
224 if (ret) {
225 put_bh(bh);
226 return ERR_PTR(ret);
227 }
228 return bh;
229}
230
231struct buffer_head *ext4_sb_bread(struct super_block *sb, sector_t block,
232 int op_flags)
233{
234 return __ext4_sb_bread_gfp(sb, block, op_flags, __GFP_MOVABLE);
235}
236
237struct buffer_head *ext4_sb_bread_unmovable(struct super_block *sb,
238 sector_t block)
239{
240 return __ext4_sb_bread_gfp(sb, block, 0, 0);
241}
242
243void ext4_sb_breadahead_unmovable(struct super_block *sb, sector_t block)
244{
245 struct buffer_head *bh = sb_getblk_gfp(sb, block, 0);
246
247 if (likely(bh)) {
248 ext4_read_bh_lock(bh, REQ_RAHEAD, false);
249 brelse(bh);
250 }
251}
252
253static int ext4_verify_csum_type(struct super_block *sb,
254 struct ext4_super_block *es)
255{
256 if (!ext4_has_feature_metadata_csum(sb))
257 return 1;
258
259 return es->s_checksum_type == EXT4_CRC32C_CHKSUM;
260}
261
262static __le32 ext4_superblock_csum(struct super_block *sb,
263 struct ext4_super_block *es)
264{
265 struct ext4_sb_info *sbi = EXT4_SB(sb);
266 int offset = offsetof(struct ext4_super_block, s_checksum);
267 __u32 csum;
268
269 csum = ext4_chksum(sbi, ~0, (char *)es, offset);
270
271 return cpu_to_le32(csum);
272}
273
274static int ext4_superblock_csum_verify(struct super_block *sb,
275 struct ext4_super_block *es)
276{
277 if (!ext4_has_metadata_csum(sb))
278 return 1;
279
280 return es->s_checksum == ext4_superblock_csum(sb, es);
281}
282
283void ext4_superblock_csum_set(struct super_block *sb)
284{
285 struct ext4_super_block *es = EXT4_SB(sb)->s_es;
286
287 if (!ext4_has_metadata_csum(sb))
288 return;
289
290 es->s_checksum = ext4_superblock_csum(sb, es);
291}
292
293ext4_fsblk_t ext4_block_bitmap(struct super_block *sb,
294 struct ext4_group_desc *bg)
295{
296 return le32_to_cpu(bg->bg_block_bitmap_lo) |
297 (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
298 (ext4_fsblk_t)le32_to_cpu(bg->bg_block_bitmap_hi) << 32 : 0);
299}
300
301ext4_fsblk_t ext4_inode_bitmap(struct super_block *sb,
302 struct ext4_group_desc *bg)
303{
304 return le32_to_cpu(bg->bg_inode_bitmap_lo) |
305 (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
306 (ext4_fsblk_t)le32_to_cpu(bg->bg_inode_bitmap_hi) << 32 : 0);
307}
308
309ext4_fsblk_t ext4_inode_table(struct super_block *sb,
310 struct ext4_group_desc *bg)
311{
312 return le32_to_cpu(bg->bg_inode_table_lo) |
313 (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
314 (ext4_fsblk_t)le32_to_cpu(bg->bg_inode_table_hi) << 32 : 0);
315}
316
317__u32 ext4_free_group_clusters(struct super_block *sb,
318 struct ext4_group_desc *bg)
319{
320 return le16_to_cpu(bg->bg_free_blocks_count_lo) |
321 (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
322 (__u32)le16_to_cpu(bg->bg_free_blocks_count_hi) << 16 : 0);
323}
324
325__u32 ext4_free_inodes_count(struct super_block *sb,
326 struct ext4_group_desc *bg)
327{
328 return le16_to_cpu(bg->bg_free_inodes_count_lo) |
329 (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
330 (__u32)le16_to_cpu(bg->bg_free_inodes_count_hi) << 16 : 0);
331}
332
333__u32 ext4_used_dirs_count(struct super_block *sb,
334 struct ext4_group_desc *bg)
335{
336 return le16_to_cpu(bg->bg_used_dirs_count_lo) |
337 (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
338 (__u32)le16_to_cpu(bg->bg_used_dirs_count_hi) << 16 : 0);
339}
340
341__u32 ext4_itable_unused_count(struct super_block *sb,
342 struct ext4_group_desc *bg)
343{
344 return le16_to_cpu(bg->bg_itable_unused_lo) |
345 (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
346 (__u32)le16_to_cpu(bg->bg_itable_unused_hi) << 16 : 0);
347}
348
349void ext4_block_bitmap_set(struct super_block *sb,
350 struct ext4_group_desc *bg, ext4_fsblk_t blk)
351{
352 bg->bg_block_bitmap_lo = cpu_to_le32((u32)blk);
353 if (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT)
354 bg->bg_block_bitmap_hi = cpu_to_le32(blk >> 32);
355}
356
357void ext4_inode_bitmap_set(struct super_block *sb,
358 struct ext4_group_desc *bg, ext4_fsblk_t blk)
359{
360 bg->bg_inode_bitmap_lo = cpu_to_le32((u32)blk);
361 if (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT)
362 bg->bg_inode_bitmap_hi = cpu_to_le32(blk >> 32);
363}
364
365void ext4_inode_table_set(struct super_block *sb,
366 struct ext4_group_desc *bg, ext4_fsblk_t blk)
367{
368 bg->bg_inode_table_lo = cpu_to_le32((u32)blk);
369 if (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT)
370 bg->bg_inode_table_hi = cpu_to_le32(blk >> 32);
371}
372
373void ext4_free_group_clusters_set(struct super_block *sb,
374 struct ext4_group_desc *bg, __u32 count)
375{
376 bg->bg_free_blocks_count_lo = cpu_to_le16((__u16)count);
377 if (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT)
378 bg->bg_free_blocks_count_hi = cpu_to_le16(count >> 16);
379}
380
381void ext4_free_inodes_set(struct super_block *sb,
382 struct ext4_group_desc *bg, __u32 count)
383{
384 bg->bg_free_inodes_count_lo = cpu_to_le16((__u16)count);
385 if (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT)
386 bg->bg_free_inodes_count_hi = cpu_to_le16(count >> 16);
387}
388
389void ext4_used_dirs_set(struct super_block *sb,
390 struct ext4_group_desc *bg, __u32 count)
391{
392 bg->bg_used_dirs_count_lo = cpu_to_le16((__u16)count);
393 if (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT)
394 bg->bg_used_dirs_count_hi = cpu_to_le16(count >> 16);
395}
396
397void ext4_itable_unused_set(struct super_block *sb,
398 struct ext4_group_desc *bg, __u32 count)
399{
400 bg->bg_itable_unused_lo = cpu_to_le16((__u16)count);
401 if (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT)
402 bg->bg_itable_unused_hi = cpu_to_le16(count >> 16);
403}
404
405static void __ext4_update_tstamp(__le32 *lo, __u8 *hi, time64_t now)
406{
407 now = clamp_val(now, 0, (1ull << 40) - 1);
408
409 *lo = cpu_to_le32(lower_32_bits(now));
410 *hi = upper_32_bits(now);
411}
412
413static time64_t __ext4_get_tstamp(__le32 *lo, __u8 *hi)
414{
415 return ((time64_t)(*hi) << 32) + le32_to_cpu(*lo);
416}
417#define ext4_update_tstamp(es, tstamp) \
418 __ext4_update_tstamp(&(es)->tstamp, &(es)->tstamp ## _hi, \
419 ktime_get_real_seconds())
420#define ext4_get_tstamp(es, tstamp) \
421 __ext4_get_tstamp(&(es)->tstamp, &(es)->tstamp ## _hi)
422
423
424
425
426
427
428
429
430
431static int block_device_ejected(struct super_block *sb)
432{
433 struct inode *bd_inode = sb->s_bdev->bd_inode;
434 struct backing_dev_info *bdi = inode_to_bdi(bd_inode);
435
436 return bdi->dev == NULL;
437}
438
439static void ext4_journal_commit_callback(journal_t *journal, transaction_t *txn)
440{
441 struct super_block *sb = journal->j_private;
442 struct ext4_sb_info *sbi = EXT4_SB(sb);
443 int error = is_journal_aborted(journal);
444 struct ext4_journal_cb_entry *jce;
445
446 BUG_ON(txn->t_state == T_FINISHED);
447
448 ext4_process_freed_data(sb, txn->t_tid);
449
450 spin_lock(&sbi->s_md_lock);
451 while (!list_empty(&txn->t_private_list)) {
452 jce = list_entry(txn->t_private_list.next,
453 struct ext4_journal_cb_entry, jce_list);
454 list_del_init(&jce->jce_list);
455 spin_unlock(&sbi->s_md_lock);
456 jce->jce_func(sb, jce, error);
457 spin_lock(&sbi->s_md_lock);
458 }
459 spin_unlock(&sbi->s_md_lock);
460}
461
462
463
464
465
466
467
468
469
470
471
472static int ext4_journalled_writepage_callback(struct page *page,
473 struct writeback_control *wbc,
474 void *data)
475{
476 transaction_t *transaction = (transaction_t *) data;
477 struct buffer_head *bh, *head;
478 struct journal_head *jh;
479
480 bh = head = page_buffers(page);
481 do {
482
483
484
485
486
487
488
489
490
491
492
493
494
495 jh = bh2jh(bh);
496 if (buffer_dirty(bh) ||
497 (jh && (jh->b_transaction != transaction ||
498 jh->b_next_transaction))) {
499 redirty_page_for_writepage(wbc, page);
500 goto out;
501 }
502 } while ((bh = bh->b_this_page) != head);
503
504out:
505 return AOP_WRITEPAGE_ACTIVATE;
506}
507
508static int ext4_journalled_submit_inode_data_buffers(struct jbd2_inode *jinode)
509{
510 struct address_space *mapping = jinode->i_vfs_inode->i_mapping;
511 struct writeback_control wbc = {
512 .sync_mode = WB_SYNC_ALL,
513 .nr_to_write = LONG_MAX,
514 .range_start = jinode->i_dirty_start,
515 .range_end = jinode->i_dirty_end,
516 };
517
518 return write_cache_pages(mapping, &wbc,
519 ext4_journalled_writepage_callback,
520 jinode->i_transaction);
521}
522
523static int ext4_journal_submit_inode_data_buffers(struct jbd2_inode *jinode)
524{
525 int ret;
526
527 if (ext4_should_journal_data(jinode->i_vfs_inode))
528 ret = ext4_journalled_submit_inode_data_buffers(jinode);
529 else
530 ret = jbd2_journal_submit_inode_data_buffers(jinode);
531
532 return ret;
533}
534
535static int ext4_journal_finish_inode_data_buffers(struct jbd2_inode *jinode)
536{
537 int ret = 0;
538
539 if (!ext4_should_journal_data(jinode->i_vfs_inode))
540 ret = jbd2_journal_finish_inode_data_buffers(jinode);
541
542 return ret;
543}
544
545static bool system_going_down(void)
546{
547 return system_state == SYSTEM_HALT || system_state == SYSTEM_POWER_OFF
548 || system_state == SYSTEM_RESTART;
549}
550
551struct ext4_err_translation {
552 int code;
553 int errno;
554};
555
556#define EXT4_ERR_TRANSLATE(err) { .code = EXT4_ERR_##err, .errno = err }
557
558static struct ext4_err_translation err_translation[] = {
559 EXT4_ERR_TRANSLATE(EIO),
560 EXT4_ERR_TRANSLATE(ENOMEM),
561 EXT4_ERR_TRANSLATE(EFSBADCRC),
562 EXT4_ERR_TRANSLATE(EFSCORRUPTED),
563 EXT4_ERR_TRANSLATE(ENOSPC),
564 EXT4_ERR_TRANSLATE(ENOKEY),
565 EXT4_ERR_TRANSLATE(EROFS),
566 EXT4_ERR_TRANSLATE(EFBIG),
567 EXT4_ERR_TRANSLATE(EEXIST),
568 EXT4_ERR_TRANSLATE(ERANGE),
569 EXT4_ERR_TRANSLATE(EOVERFLOW),
570 EXT4_ERR_TRANSLATE(EBUSY),
571 EXT4_ERR_TRANSLATE(ENOTDIR),
572 EXT4_ERR_TRANSLATE(ENOTEMPTY),
573 EXT4_ERR_TRANSLATE(ESHUTDOWN),
574 EXT4_ERR_TRANSLATE(EFAULT),
575};
576
577static int ext4_errno_to_code(int errno)
578{
579 int i;
580
581 for (i = 0; i < ARRAY_SIZE(err_translation); i++)
582 if (err_translation[i].errno == errno)
583 return err_translation[i].code;
584 return EXT4_ERR_UNKNOWN;
585}
586
587static void save_error_info(struct super_block *sb, int error,
588 __u32 ino, __u64 block,
589 const char *func, unsigned int line)
590{
591 struct ext4_sb_info *sbi = EXT4_SB(sb);
592
593
594 if (error == 0)
595 error = EFSCORRUPTED;
596
597 spin_lock(&sbi->s_error_lock);
598 sbi->s_add_error_count++;
599 sbi->s_last_error_code = error;
600 sbi->s_last_error_line = line;
601 sbi->s_last_error_ino = ino;
602 sbi->s_last_error_block = block;
603 sbi->s_last_error_func = func;
604 sbi->s_last_error_time = ktime_get_real_seconds();
605 if (!sbi->s_first_error_time) {
606 sbi->s_first_error_code = error;
607 sbi->s_first_error_line = line;
608 sbi->s_first_error_ino = ino;
609 sbi->s_first_error_block = block;
610 sbi->s_first_error_func = func;
611 sbi->s_first_error_time = sbi->s_last_error_time;
612 }
613 spin_unlock(&sbi->s_error_lock);
614}
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636static void ext4_handle_error(struct super_block *sb, bool force_ro, int error,
637 __u32 ino, __u64 block,
638 const char *func, unsigned int line)
639{
640 journal_t *journal = EXT4_SB(sb)->s_journal;
641 bool continue_fs = !force_ro && test_opt(sb, ERRORS_CONT);
642
643 EXT4_SB(sb)->s_mount_state |= EXT4_ERROR_FS;
644 if (test_opt(sb, WARN_ON_ERROR))
645 WARN_ON_ONCE(1);
646
647 if (!continue_fs && !sb_rdonly(sb)) {
648 ext4_set_mount_flag(sb, EXT4_MF_FS_ABORTED);
649 if (journal)
650 jbd2_journal_abort(journal, -EIO);
651 }
652
653 if (!bdev_read_only(sb->s_bdev)) {
654 save_error_info(sb, error, ino, block, func, line);
655
656
657
658
659
660
661 if (continue_fs && journal)
662 schedule_work(&EXT4_SB(sb)->s_error_work);
663 else
664 ext4_commit_super(sb);
665 }
666
667
668
669
670
671
672 if (test_opt(sb, ERRORS_PANIC) && !system_going_down()) {
673 panic("EXT4-fs (device %s): panic forced after error\n",
674 sb->s_id);
675 }
676
677 if (sb_rdonly(sb) || continue_fs)
678 return;
679
680 ext4_msg(sb, KERN_CRIT, "Remounting filesystem read-only");
681
682
683
684
685 smp_wmb();
686 sb->s_flags |= SB_RDONLY;
687}
688
689static void flush_stashed_error_work(struct work_struct *work)
690{
691 struct ext4_sb_info *sbi = container_of(work, struct ext4_sb_info,
692 s_error_work);
693 journal_t *journal = sbi->s_journal;
694 handle_t *handle;
695
696
697
698
699
700
701
702
703
704 if (!sb_rdonly(sbi->s_sb) && journal) {
705 struct buffer_head *sbh = sbi->s_sbh;
706 handle = jbd2_journal_start(journal, 1);
707 if (IS_ERR(handle))
708 goto write_directly;
709 if (jbd2_journal_get_write_access(handle, sbh)) {
710 jbd2_journal_stop(handle);
711 goto write_directly;
712 }
713 ext4_update_super(sbi->s_sb);
714 if (buffer_write_io_error(sbh) || !buffer_uptodate(sbh)) {
715 ext4_msg(sbi->s_sb, KERN_ERR, "previous I/O error to "
716 "superblock detected");
717 clear_buffer_write_io_error(sbh);
718 set_buffer_uptodate(sbh);
719 }
720
721 if (jbd2_journal_dirty_metadata(handle, sbh)) {
722 jbd2_journal_stop(handle);
723 goto write_directly;
724 }
725 jbd2_journal_stop(handle);
726 ext4_notify_error_sysfs(sbi);
727 return;
728 }
729write_directly:
730
731
732
733
734 ext4_commit_super(sbi->s_sb);
735 ext4_notify_error_sysfs(sbi);
736}
737
738#define ext4_error_ratelimit(sb) \
739 ___ratelimit(&(EXT4_SB(sb)->s_err_ratelimit_state), \
740 "EXT4-fs error")
741
742void __ext4_error(struct super_block *sb, const char *function,
743 unsigned int line, bool force_ro, int error, __u64 block,
744 const char *fmt, ...)
745{
746 struct va_format vaf;
747 va_list args;
748
749 if (unlikely(ext4_forced_shutdown(EXT4_SB(sb))))
750 return;
751
752 trace_ext4_error(sb, function, line);
753 if (ext4_error_ratelimit(sb)) {
754 va_start(args, fmt);
755 vaf.fmt = fmt;
756 vaf.va = &args;
757 printk(KERN_CRIT
758 "EXT4-fs error (device %s): %s:%d: comm %s: %pV\n",
759 sb->s_id, function, line, current->comm, &vaf);
760 va_end(args);
761 }
762 ext4_handle_error(sb, force_ro, error, 0, block, function, line);
763}
764
765void __ext4_error_inode(struct inode *inode, const char *function,
766 unsigned int line, ext4_fsblk_t block, int error,
767 const char *fmt, ...)
768{
769 va_list args;
770 struct va_format vaf;
771
772 if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb))))
773 return;
774
775 trace_ext4_error(inode->i_sb, function, line);
776 if (ext4_error_ratelimit(inode->i_sb)) {
777 va_start(args, fmt);
778 vaf.fmt = fmt;
779 vaf.va = &args;
780 if (block)
781 printk(KERN_CRIT "EXT4-fs error (device %s): %s:%d: "
782 "inode #%lu: block %llu: comm %s: %pV\n",
783 inode->i_sb->s_id, function, line, inode->i_ino,
784 block, current->comm, &vaf);
785 else
786 printk(KERN_CRIT "EXT4-fs error (device %s): %s:%d: "
787 "inode #%lu: comm %s: %pV\n",
788 inode->i_sb->s_id, function, line, inode->i_ino,
789 current->comm, &vaf);
790 va_end(args);
791 }
792 ext4_handle_error(inode->i_sb, false, error, inode->i_ino, block,
793 function, line);
794}
795
796void __ext4_error_file(struct file *file, const char *function,
797 unsigned int line, ext4_fsblk_t block,
798 const char *fmt, ...)
799{
800 va_list args;
801 struct va_format vaf;
802 struct inode *inode = file_inode(file);
803 char pathname[80], *path;
804
805 if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb))))
806 return;
807
808 trace_ext4_error(inode->i_sb, function, line);
809 if (ext4_error_ratelimit(inode->i_sb)) {
810 path = file_path(file, pathname, sizeof(pathname));
811 if (IS_ERR(path))
812 path = "(unknown)";
813 va_start(args, fmt);
814 vaf.fmt = fmt;
815 vaf.va = &args;
816 if (block)
817 printk(KERN_CRIT
818 "EXT4-fs error (device %s): %s:%d: inode #%lu: "
819 "block %llu: comm %s: path %s: %pV\n",
820 inode->i_sb->s_id, function, line, inode->i_ino,
821 block, current->comm, path, &vaf);
822 else
823 printk(KERN_CRIT
824 "EXT4-fs error (device %s): %s:%d: inode #%lu: "
825 "comm %s: path %s: %pV\n",
826 inode->i_sb->s_id, function, line, inode->i_ino,
827 current->comm, path, &vaf);
828 va_end(args);
829 }
830 ext4_handle_error(inode->i_sb, false, EFSCORRUPTED, inode->i_ino, block,
831 function, line);
832}
833
834const char *ext4_decode_error(struct super_block *sb, int errno,
835 char nbuf[16])
836{
837 char *errstr = NULL;
838
839 switch (errno) {
840 case -EFSCORRUPTED:
841 errstr = "Corrupt filesystem";
842 break;
843 case -EFSBADCRC:
844 errstr = "Filesystem failed CRC";
845 break;
846 case -EIO:
847 errstr = "IO failure";
848 break;
849 case -ENOMEM:
850 errstr = "Out of memory";
851 break;
852 case -EROFS:
853 if (!sb || (EXT4_SB(sb)->s_journal &&
854 EXT4_SB(sb)->s_journal->j_flags & JBD2_ABORT))
855 errstr = "Journal has aborted";
856 else
857 errstr = "Readonly filesystem";
858 break;
859 default:
860
861
862
863 if (nbuf) {
864
865 if (snprintf(nbuf, 16, "error %d", -errno) >= 0)
866 errstr = nbuf;
867 }
868 break;
869 }
870
871 return errstr;
872}
873
874
875
876
877void __ext4_std_error(struct super_block *sb, const char *function,
878 unsigned int line, int errno)
879{
880 char nbuf[16];
881 const char *errstr;
882
883 if (unlikely(ext4_forced_shutdown(EXT4_SB(sb))))
884 return;
885
886
887
888
889 if (errno == -EROFS && journal_current_handle() == NULL && sb_rdonly(sb))
890 return;
891
892 if (ext4_error_ratelimit(sb)) {
893 errstr = ext4_decode_error(sb, errno, nbuf);
894 printk(KERN_CRIT "EXT4-fs error (device %s) in %s:%d: %s\n",
895 sb->s_id, function, line, errstr);
896 }
897
898 ext4_handle_error(sb, false, -errno, 0, 0, function, line);
899}
900
901void __ext4_msg(struct super_block *sb,
902 const char *prefix, const char *fmt, ...)
903{
904 struct va_format vaf;
905 va_list args;
906
907 atomic_inc(&EXT4_SB(sb)->s_msg_count);
908 if (!___ratelimit(&(EXT4_SB(sb)->s_msg_ratelimit_state), "EXT4-fs"))
909 return;
910
911 va_start(args, fmt);
912 vaf.fmt = fmt;
913 vaf.va = &args;
914 printk("%sEXT4-fs (%s): %pV\n", prefix, sb->s_id, &vaf);
915 va_end(args);
916}
917
918static int ext4_warning_ratelimit(struct super_block *sb)
919{
920 atomic_inc(&EXT4_SB(sb)->s_warning_count);
921 return ___ratelimit(&(EXT4_SB(sb)->s_warning_ratelimit_state),
922 "EXT4-fs warning");
923}
924
925void __ext4_warning(struct super_block *sb, const char *function,
926 unsigned int line, const char *fmt, ...)
927{
928 struct va_format vaf;
929 va_list args;
930
931 if (!ext4_warning_ratelimit(sb))
932 return;
933
934 va_start(args, fmt);
935 vaf.fmt = fmt;
936 vaf.va = &args;
937 printk(KERN_WARNING "EXT4-fs warning (device %s): %s:%d: %pV\n",
938 sb->s_id, function, line, &vaf);
939 va_end(args);
940}
941
942void __ext4_warning_inode(const struct inode *inode, const char *function,
943 unsigned int line, const char *fmt, ...)
944{
945 struct va_format vaf;
946 va_list args;
947
948 if (!ext4_warning_ratelimit(inode->i_sb))
949 return;
950
951 va_start(args, fmt);
952 vaf.fmt = fmt;
953 vaf.va = &args;
954 printk(KERN_WARNING "EXT4-fs warning (device %s): %s:%d: "
955 "inode #%lu: comm %s: %pV\n", inode->i_sb->s_id,
956 function, line, inode->i_ino, current->comm, &vaf);
957 va_end(args);
958}
959
960void __ext4_grp_locked_error(const char *function, unsigned int line,
961 struct super_block *sb, ext4_group_t grp,
962 unsigned long ino, ext4_fsblk_t block,
963 const char *fmt, ...)
964__releases(bitlock)
965__acquires(bitlock)
966{
967 struct va_format vaf;
968 va_list args;
969
970 if (unlikely(ext4_forced_shutdown(EXT4_SB(sb))))
971 return;
972
973 trace_ext4_error(sb, function, line);
974 if (ext4_error_ratelimit(sb)) {
975 va_start(args, fmt);
976 vaf.fmt = fmt;
977 vaf.va = &args;
978 printk(KERN_CRIT "EXT4-fs error (device %s): %s:%d: group %u, ",
979 sb->s_id, function, line, grp);
980 if (ino)
981 printk(KERN_CONT "inode %lu: ", ino);
982 if (block)
983 printk(KERN_CONT "block %llu:",
984 (unsigned long long) block);
985 printk(KERN_CONT "%pV\n", &vaf);
986 va_end(args);
987 }
988
989 if (test_opt(sb, ERRORS_CONT)) {
990 if (test_opt(sb, WARN_ON_ERROR))
991 WARN_ON_ONCE(1);
992 EXT4_SB(sb)->s_mount_state |= EXT4_ERROR_FS;
993 if (!bdev_read_only(sb->s_bdev)) {
994 save_error_info(sb, EFSCORRUPTED, ino, block, function,
995 line);
996 schedule_work(&EXT4_SB(sb)->s_error_work);
997 }
998 return;
999 }
1000 ext4_unlock_group(sb, grp);
1001 ext4_handle_error(sb, false, EFSCORRUPTED, ino, block, function, line);
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013 ext4_lock_group(sb, grp);
1014 return;
1015}
1016
1017void ext4_mark_group_bitmap_corrupted(struct super_block *sb,
1018 ext4_group_t group,
1019 unsigned int flags)
1020{
1021 struct ext4_sb_info *sbi = EXT4_SB(sb);
1022 struct ext4_group_info *grp = ext4_get_group_info(sb, group);
1023 struct ext4_group_desc *gdp = ext4_get_group_desc(sb, group, NULL);
1024 int ret;
1025
1026 if (flags & EXT4_GROUP_INFO_BBITMAP_CORRUPT) {
1027 ret = ext4_test_and_set_bit(EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT,
1028 &grp->bb_state);
1029 if (!ret)
1030 percpu_counter_sub(&sbi->s_freeclusters_counter,
1031 grp->bb_free);
1032 }
1033
1034 if (flags & EXT4_GROUP_INFO_IBITMAP_CORRUPT) {
1035 ret = ext4_test_and_set_bit(EXT4_GROUP_INFO_IBITMAP_CORRUPT_BIT,
1036 &grp->bb_state);
1037 if (!ret && gdp) {
1038 int count;
1039
1040 count = ext4_free_inodes_count(sb, gdp);
1041 percpu_counter_sub(&sbi->s_freeinodes_counter,
1042 count);
1043 }
1044 }
1045}
1046
1047void ext4_update_dynamic_rev(struct super_block *sb)
1048{
1049 struct ext4_super_block *es = EXT4_SB(sb)->s_es;
1050
1051 if (le32_to_cpu(es->s_rev_level) > EXT4_GOOD_OLD_REV)
1052 return;
1053
1054 ext4_warning(sb,
1055 "updating to rev %d because of new feature flag, "
1056 "running e2fsck is recommended",
1057 EXT4_DYNAMIC_REV);
1058
1059 es->s_first_ino = cpu_to_le32(EXT4_GOOD_OLD_FIRST_INO);
1060 es->s_inode_size = cpu_to_le16(EXT4_GOOD_OLD_INODE_SIZE);
1061 es->s_rev_level = cpu_to_le32(EXT4_DYNAMIC_REV);
1062
1063
1064
1065
1066
1067
1068
1069
1070}
1071
1072
1073
1074
1075static struct block_device *ext4_blkdev_get(dev_t dev, struct super_block *sb)
1076{
1077 struct block_device *bdev;
1078
1079 bdev = blkdev_get_by_dev(dev, FMODE_READ|FMODE_WRITE|FMODE_EXCL, sb);
1080 if (IS_ERR(bdev))
1081 goto fail;
1082 return bdev;
1083
1084fail:
1085 ext4_msg(sb, KERN_ERR,
1086 "failed to open journal device unknown-block(%u,%u) %ld",
1087 MAJOR(dev), MINOR(dev), PTR_ERR(bdev));
1088 return NULL;
1089}
1090
1091
1092
1093
1094static void ext4_blkdev_put(struct block_device *bdev)
1095{
1096 blkdev_put(bdev, FMODE_READ|FMODE_WRITE|FMODE_EXCL);
1097}
1098
1099static void ext4_blkdev_remove(struct ext4_sb_info *sbi)
1100{
1101 struct block_device *bdev;
1102 bdev = sbi->s_journal_bdev;
1103 if (bdev) {
1104 ext4_blkdev_put(bdev);
1105 sbi->s_journal_bdev = NULL;
1106 }
1107}
1108
1109static inline struct inode *orphan_list_entry(struct list_head *l)
1110{
1111 return &list_entry(l, struct ext4_inode_info, i_orphan)->vfs_inode;
1112}
1113
1114static void dump_orphan_list(struct super_block *sb, struct ext4_sb_info *sbi)
1115{
1116 struct list_head *l;
1117
1118 ext4_msg(sb, KERN_ERR, "sb orphan head is %d",
1119 le32_to_cpu(sbi->s_es->s_last_orphan));
1120
1121 printk(KERN_ERR "sb_info orphan list:\n");
1122 list_for_each(l, &sbi->s_orphan) {
1123 struct inode *inode = orphan_list_entry(l);
1124 printk(KERN_ERR " "
1125 "inode %s:%lu at %p: mode %o, nlink %d, next %d\n",
1126 inode->i_sb->s_id, inode->i_ino, inode,
1127 inode->i_mode, inode->i_nlink,
1128 NEXT_ORPHAN(inode));
1129 }
1130}
1131
1132#ifdef CONFIG_QUOTA
1133static int ext4_quota_off(struct super_block *sb, int type);
1134
1135static inline void ext4_quota_off_umount(struct super_block *sb)
1136{
1137 int type;
1138
1139
1140 for (type = 0; type < EXT4_MAXQUOTAS; type++)
1141 ext4_quota_off(sb, type);
1142}
1143
1144
1145
1146
1147
1148static inline char *get_qf_name(struct super_block *sb,
1149 struct ext4_sb_info *sbi,
1150 int type)
1151{
1152 return rcu_dereference_protected(sbi->s_qf_names[type],
1153 lockdep_is_held(&sb->s_umount));
1154}
1155#else
1156static inline void ext4_quota_off_umount(struct super_block *sb)
1157{
1158}
1159#endif
1160
1161static void ext4_put_super(struct super_block *sb)
1162{
1163 struct ext4_sb_info *sbi = EXT4_SB(sb);
1164 struct ext4_super_block *es = sbi->s_es;
1165 struct buffer_head **group_desc;
1166 struct flex_groups **flex_groups;
1167 int aborted = 0;
1168 int i, err;
1169
1170 ext4_unregister_li_request(sb);
1171 ext4_quota_off_umount(sb);
1172
1173 flush_work(&sbi->s_error_work);
1174 destroy_workqueue(sbi->rsv_conversion_wq);
1175 ext4_release_orphan_info(sb);
1176
1177
1178
1179
1180
1181
1182 ext4_unregister_sysfs(sb);
1183
1184 if (sbi->s_journal) {
1185 aborted = is_journal_aborted(sbi->s_journal);
1186 err = jbd2_journal_destroy(sbi->s_journal);
1187 sbi->s_journal = NULL;
1188 if ((err < 0) && !aborted) {
1189 ext4_abort(sb, -err, "Couldn't clean up the journal");
1190 }
1191 }
1192
1193 ext4_es_unregister_shrinker(sbi);
1194 del_timer_sync(&sbi->s_err_report);
1195 ext4_release_system_zone(sb);
1196 ext4_mb_release(sb);
1197 ext4_ext_release(sb);
1198
1199 if (!sb_rdonly(sb) && !aborted) {
1200 ext4_clear_feature_journal_needs_recovery(sb);
1201 ext4_clear_feature_orphan_present(sb);
1202 es->s_state = cpu_to_le16(sbi->s_mount_state);
1203 }
1204 if (!sb_rdonly(sb))
1205 ext4_commit_super(sb);
1206
1207 rcu_read_lock();
1208 group_desc = rcu_dereference(sbi->s_group_desc);
1209 for (i = 0; i < sbi->s_gdb_count; i++)
1210 brelse(group_desc[i]);
1211 kvfree(group_desc);
1212 flex_groups = rcu_dereference(sbi->s_flex_groups);
1213 if (flex_groups) {
1214 for (i = 0; i < sbi->s_flex_groups_allocated; i++)
1215 kvfree(flex_groups[i]);
1216 kvfree(flex_groups);
1217 }
1218 rcu_read_unlock();
1219 percpu_counter_destroy(&sbi->s_freeclusters_counter);
1220 percpu_counter_destroy(&sbi->s_freeinodes_counter);
1221 percpu_counter_destroy(&sbi->s_dirs_counter);
1222 percpu_counter_destroy(&sbi->s_dirtyclusters_counter);
1223 percpu_counter_destroy(&sbi->s_sra_exceeded_retry_limit);
1224 percpu_free_rwsem(&sbi->s_writepages_rwsem);
1225#ifdef CONFIG_QUOTA
1226 for (i = 0; i < EXT4_MAXQUOTAS; i++)
1227 kfree(get_qf_name(sb, sbi, i));
1228#endif
1229
1230
1231
1232
1233
1234 if (!list_empty(&sbi->s_orphan))
1235 dump_orphan_list(sb, sbi);
1236 ASSERT(list_empty(&sbi->s_orphan));
1237
1238 sync_blockdev(sb->s_bdev);
1239 invalidate_bdev(sb->s_bdev);
1240 if (sbi->s_journal_bdev && sbi->s_journal_bdev != sb->s_bdev) {
1241
1242
1243
1244
1245
1246 sync_blockdev(sbi->s_journal_bdev);
1247 invalidate_bdev(sbi->s_journal_bdev);
1248 ext4_blkdev_remove(sbi);
1249 }
1250
1251 ext4_xattr_destroy_cache(sbi->s_ea_inode_cache);
1252 sbi->s_ea_inode_cache = NULL;
1253
1254 ext4_xattr_destroy_cache(sbi->s_ea_block_cache);
1255 sbi->s_ea_block_cache = NULL;
1256
1257 ext4_stop_mmpd(sbi);
1258
1259 brelse(sbi->s_sbh);
1260 sb->s_fs_info = NULL;
1261
1262
1263
1264
1265 kobject_put(&sbi->s_kobj);
1266 wait_for_completion(&sbi->s_kobj_unregister);
1267 if (sbi->s_chksum_driver)
1268 crypto_free_shash(sbi->s_chksum_driver);
1269 kfree(sbi->s_blockgroup_lock);
1270 fs_put_dax(sbi->s_daxdev);
1271 fscrypt_free_dummy_policy(&sbi->s_dummy_enc_policy);
1272#ifdef CONFIG_UNICODE
1273 utf8_unload(sb->s_encoding);
1274#endif
1275 kfree(sbi);
1276}
1277
1278static struct kmem_cache *ext4_inode_cachep;
1279
1280
1281
1282
1283static struct inode *ext4_alloc_inode(struct super_block *sb)
1284{
1285 struct ext4_inode_info *ei;
1286
1287 ei = kmem_cache_alloc(ext4_inode_cachep, GFP_NOFS);
1288 if (!ei)
1289 return NULL;
1290
1291 inode_set_iversion(&ei->vfs_inode, 1);
1292 spin_lock_init(&ei->i_raw_lock);
1293 INIT_LIST_HEAD(&ei->i_prealloc_list);
1294 atomic_set(&ei->i_prealloc_active, 0);
1295 spin_lock_init(&ei->i_prealloc_lock);
1296 ext4_es_init_tree(&ei->i_es_tree);
1297 rwlock_init(&ei->i_es_lock);
1298 INIT_LIST_HEAD(&ei->i_es_list);
1299 ei->i_es_all_nr = 0;
1300 ei->i_es_shk_nr = 0;
1301 ei->i_es_shrink_lblk = 0;
1302 ei->i_reserved_data_blocks = 0;
1303 spin_lock_init(&(ei->i_block_reservation_lock));
1304 ext4_init_pending_tree(&ei->i_pending_tree);
1305#ifdef CONFIG_QUOTA
1306 ei->i_reserved_quota = 0;
1307 memset(&ei->i_dquot, 0, sizeof(ei->i_dquot));
1308#endif
1309 ei->jinode = NULL;
1310 INIT_LIST_HEAD(&ei->i_rsv_conversion_list);
1311 spin_lock_init(&ei->i_completed_io_lock);
1312 ei->i_sync_tid = 0;
1313 ei->i_datasync_tid = 0;
1314 atomic_set(&ei->i_unwritten, 0);
1315 INIT_WORK(&ei->i_rsv_conversion_work, ext4_end_io_rsv_work);
1316 ext4_fc_init_inode(&ei->vfs_inode);
1317 mutex_init(&ei->i_fc_lock);
1318 return &ei->vfs_inode;
1319}
1320
1321static int ext4_drop_inode(struct inode *inode)
1322{
1323 int drop = generic_drop_inode(inode);
1324
1325 if (!drop)
1326 drop = fscrypt_drop_inode(inode);
1327
1328 trace_ext4_drop_inode(inode, drop);
1329 return drop;
1330}
1331
1332static void ext4_free_in_core_inode(struct inode *inode)
1333{
1334 fscrypt_free_inode(inode);
1335 if (!list_empty(&(EXT4_I(inode)->i_fc_list))) {
1336 pr_warn("%s: inode %ld still in fc list",
1337 __func__, inode->i_ino);
1338 }
1339 kmem_cache_free(ext4_inode_cachep, EXT4_I(inode));
1340}
1341
1342static void ext4_destroy_inode(struct inode *inode)
1343{
1344 if (!list_empty(&(EXT4_I(inode)->i_orphan))) {
1345 ext4_msg(inode->i_sb, KERN_ERR,
1346 "Inode %lu (%p): orphan list check failed!",
1347 inode->i_ino, EXT4_I(inode));
1348 print_hex_dump(KERN_INFO, "", DUMP_PREFIX_ADDRESS, 16, 4,
1349 EXT4_I(inode), sizeof(struct ext4_inode_info),
1350 true);
1351 dump_stack();
1352 }
1353
1354 if (EXT4_I(inode)->i_reserved_data_blocks)
1355 ext4_msg(inode->i_sb, KERN_ERR,
1356 "Inode %lu (%p): i_reserved_data_blocks (%u) not cleared!",
1357 inode->i_ino, EXT4_I(inode),
1358 EXT4_I(inode)->i_reserved_data_blocks);
1359}
1360
1361static void init_once(void *foo)
1362{
1363 struct ext4_inode_info *ei = (struct ext4_inode_info *) foo;
1364
1365 INIT_LIST_HEAD(&ei->i_orphan);
1366 init_rwsem(&ei->xattr_sem);
1367 init_rwsem(&ei->i_data_sem);
1368 inode_init_once(&ei->vfs_inode);
1369 ext4_fc_init_inode(&ei->vfs_inode);
1370}
1371
1372static int __init init_inodecache(void)
1373{
1374 ext4_inode_cachep = kmem_cache_create_usercopy("ext4_inode_cache",
1375 sizeof(struct ext4_inode_info), 0,
1376 (SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD|
1377 SLAB_ACCOUNT),
1378 offsetof(struct ext4_inode_info, i_data),
1379 sizeof_field(struct ext4_inode_info, i_data),
1380 init_once);
1381 if (ext4_inode_cachep == NULL)
1382 return -ENOMEM;
1383 return 0;
1384}
1385
1386static void destroy_inodecache(void)
1387{
1388
1389
1390
1391
1392 rcu_barrier();
1393 kmem_cache_destroy(ext4_inode_cachep);
1394}
1395
1396void ext4_clear_inode(struct inode *inode)
1397{
1398 ext4_fc_del(inode);
1399 invalidate_inode_buffers(inode);
1400 clear_inode(inode);
1401 ext4_discard_preallocations(inode, 0);
1402 ext4_es_remove_extent(inode, 0, EXT_MAX_BLOCKS);
1403 dquot_drop(inode);
1404 if (EXT4_I(inode)->jinode) {
1405 jbd2_journal_release_jbd_inode(EXT4_JOURNAL(inode),
1406 EXT4_I(inode)->jinode);
1407 jbd2_free_inode(EXT4_I(inode)->jinode);
1408 EXT4_I(inode)->jinode = NULL;
1409 }
1410 fscrypt_put_encryption_info(inode);
1411 fsverity_cleanup_inode(inode);
1412}
1413
1414static struct inode *ext4_nfs_get_inode(struct super_block *sb,
1415 u64 ino, u32 generation)
1416{
1417 struct inode *inode;
1418
1419
1420
1421
1422
1423 inode = ext4_iget(sb, ino, EXT4_IGET_HANDLE);
1424 if (IS_ERR(inode))
1425 return ERR_CAST(inode);
1426 if (generation && inode->i_generation != generation) {
1427 iput(inode);
1428 return ERR_PTR(-ESTALE);
1429 }
1430
1431 return inode;
1432}
1433
1434static struct dentry *ext4_fh_to_dentry(struct super_block *sb, struct fid *fid,
1435 int fh_len, int fh_type)
1436{
1437 return generic_fh_to_dentry(sb, fid, fh_len, fh_type,
1438 ext4_nfs_get_inode);
1439}
1440
1441static struct dentry *ext4_fh_to_parent(struct super_block *sb, struct fid *fid,
1442 int fh_len, int fh_type)
1443{
1444 return generic_fh_to_parent(sb, fid, fh_len, fh_type,
1445 ext4_nfs_get_inode);
1446}
1447
1448static int ext4_nfs_commit_metadata(struct inode *inode)
1449{
1450 struct writeback_control wbc = {
1451 .sync_mode = WB_SYNC_ALL
1452 };
1453
1454 trace_ext4_nfs_commit_metadata(inode);
1455 return ext4_write_inode(inode, &wbc);
1456}
1457
1458#ifdef CONFIG_FS_ENCRYPTION
1459static int ext4_get_context(struct inode *inode, void *ctx, size_t len)
1460{
1461 return ext4_xattr_get(inode, EXT4_XATTR_INDEX_ENCRYPTION,
1462 EXT4_XATTR_NAME_ENCRYPTION_CONTEXT, ctx, len);
1463}
1464
1465static int ext4_set_context(struct inode *inode, const void *ctx, size_t len,
1466 void *fs_data)
1467{
1468 handle_t *handle = fs_data;
1469 int res, res2, credits, retries = 0;
1470
1471
1472
1473
1474
1475
1476
1477 if (inode->i_ino == EXT4_ROOT_INO)
1478 return -EPERM;
1479
1480 if (WARN_ON_ONCE(IS_DAX(inode) && i_size_read(inode)))
1481 return -EINVAL;
1482
1483 if (ext4_test_inode_flag(inode, EXT4_INODE_DAX))
1484 return -EOPNOTSUPP;
1485
1486 res = ext4_convert_inline_data(inode);
1487 if (res)
1488 return res;
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498 if (handle) {
1499 res = ext4_xattr_set_handle(handle, inode,
1500 EXT4_XATTR_INDEX_ENCRYPTION,
1501 EXT4_XATTR_NAME_ENCRYPTION_CONTEXT,
1502 ctx, len, 0);
1503 if (!res) {
1504 ext4_set_inode_flag(inode, EXT4_INODE_ENCRYPT);
1505 ext4_clear_inode_state(inode,
1506 EXT4_STATE_MAY_INLINE_DATA);
1507
1508
1509
1510
1511 ext4_set_inode_flags(inode, false);
1512 }
1513 return res;
1514 }
1515
1516 res = dquot_initialize(inode);
1517 if (res)
1518 return res;
1519retry:
1520 res = ext4_xattr_set_credits(inode, len, false ,
1521 &credits);
1522 if (res)
1523 return res;
1524
1525 handle = ext4_journal_start(inode, EXT4_HT_MISC, credits);
1526 if (IS_ERR(handle))
1527 return PTR_ERR(handle);
1528
1529 res = ext4_xattr_set_handle(handle, inode, EXT4_XATTR_INDEX_ENCRYPTION,
1530 EXT4_XATTR_NAME_ENCRYPTION_CONTEXT,
1531 ctx, len, 0);
1532 if (!res) {
1533 ext4_set_inode_flag(inode, EXT4_INODE_ENCRYPT);
1534
1535
1536
1537
1538 ext4_set_inode_flags(inode, false);
1539 res = ext4_mark_inode_dirty(handle, inode);
1540 if (res)
1541 EXT4_ERROR_INODE(inode, "Failed to mark inode dirty");
1542 }
1543 res2 = ext4_journal_stop(handle);
1544
1545 if (res == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries))
1546 goto retry;
1547 if (!res)
1548 res = res2;
1549 return res;
1550}
1551
1552static const union fscrypt_policy *ext4_get_dummy_policy(struct super_block *sb)
1553{
1554 return EXT4_SB(sb)->s_dummy_enc_policy.policy;
1555}
1556
1557static bool ext4_has_stable_inodes(struct super_block *sb)
1558{
1559 return ext4_has_feature_stable_inodes(sb);
1560}
1561
1562static void ext4_get_ino_and_lblk_bits(struct super_block *sb,
1563 int *ino_bits_ret, int *lblk_bits_ret)
1564{
1565 *ino_bits_ret = 8 * sizeof(EXT4_SB(sb)->s_es->s_inodes_count);
1566 *lblk_bits_ret = 8 * sizeof(ext4_lblk_t);
1567}
1568
1569static const struct fscrypt_operations ext4_cryptops = {
1570 .key_prefix = "ext4:",
1571 .get_context = ext4_get_context,
1572 .set_context = ext4_set_context,
1573 .get_dummy_policy = ext4_get_dummy_policy,
1574 .empty_dir = ext4_empty_dir,
1575 .max_namelen = EXT4_NAME_LEN,
1576 .has_stable_inodes = ext4_has_stable_inodes,
1577 .get_ino_and_lblk_bits = ext4_get_ino_and_lblk_bits,
1578};
1579#endif
1580
1581#ifdef CONFIG_QUOTA
1582static const char * const quotatypes[] = INITQFNAMES;
1583#define QTYPE2NAME(t) (quotatypes[t])
1584
1585static int ext4_write_dquot(struct dquot *dquot);
1586static int ext4_acquire_dquot(struct dquot *dquot);
1587static int ext4_release_dquot(struct dquot *dquot);
1588static int ext4_mark_dquot_dirty(struct dquot *dquot);
1589static int ext4_write_info(struct super_block *sb, int type);
1590static int ext4_quota_on(struct super_block *sb, int type, int format_id,
1591 const struct path *path);
1592static ssize_t ext4_quota_read(struct super_block *sb, int type, char *data,
1593 size_t len, loff_t off);
1594static ssize_t ext4_quota_write(struct super_block *sb, int type,
1595 const char *data, size_t len, loff_t off);
1596static int ext4_quota_enable(struct super_block *sb, int type, int format_id,
1597 unsigned int flags);
1598
1599static struct dquot **ext4_get_dquots(struct inode *inode)
1600{
1601 return EXT4_I(inode)->i_dquot;
1602}
1603
1604static const struct dquot_operations ext4_quota_operations = {
1605 .get_reserved_space = ext4_get_reserved_space,
1606 .write_dquot = ext4_write_dquot,
1607 .acquire_dquot = ext4_acquire_dquot,
1608 .release_dquot = ext4_release_dquot,
1609 .mark_dirty = ext4_mark_dquot_dirty,
1610 .write_info = ext4_write_info,
1611 .alloc_dquot = dquot_alloc,
1612 .destroy_dquot = dquot_destroy,
1613 .get_projid = ext4_get_projid,
1614 .get_inode_usage = ext4_get_inode_usage,
1615 .get_next_id = dquot_get_next_id,
1616};
1617
1618static const struct quotactl_ops ext4_qctl_operations = {
1619 .quota_on = ext4_quota_on,
1620 .quota_off = ext4_quota_off,
1621 .quota_sync = dquot_quota_sync,
1622 .get_state = dquot_get_state,
1623 .set_info = dquot_set_dqinfo,
1624 .get_dqblk = dquot_get_dqblk,
1625 .set_dqblk = dquot_set_dqblk,
1626 .get_nextdqblk = dquot_get_next_dqblk,
1627};
1628#endif
1629
1630static const struct super_operations ext4_sops = {
1631 .alloc_inode = ext4_alloc_inode,
1632 .free_inode = ext4_free_in_core_inode,
1633 .destroy_inode = ext4_destroy_inode,
1634 .write_inode = ext4_write_inode,
1635 .dirty_inode = ext4_dirty_inode,
1636 .drop_inode = ext4_drop_inode,
1637 .evict_inode = ext4_evict_inode,
1638 .put_super = ext4_put_super,
1639 .sync_fs = ext4_sync_fs,
1640 .freeze_fs = ext4_freeze,
1641 .unfreeze_fs = ext4_unfreeze,
1642 .statfs = ext4_statfs,
1643 .remount_fs = ext4_remount,
1644 .show_options = ext4_show_options,
1645#ifdef CONFIG_QUOTA
1646 .quota_read = ext4_quota_read,
1647 .quota_write = ext4_quota_write,
1648 .get_dquots = ext4_get_dquots,
1649#endif
1650};
1651
1652static const struct export_operations ext4_export_ops = {
1653 .fh_to_dentry = ext4_fh_to_dentry,
1654 .fh_to_parent = ext4_fh_to_parent,
1655 .get_parent = ext4_get_parent,
1656 .commit_metadata = ext4_nfs_commit_metadata,
1657};
1658
1659enum {
1660 Opt_bsd_df, Opt_minix_df, Opt_grpid, Opt_nogrpid,
1661 Opt_resgid, Opt_resuid, Opt_sb, Opt_err_cont, Opt_err_panic, Opt_err_ro,
1662 Opt_nouid32, Opt_debug, Opt_removed,
1663 Opt_user_xattr, Opt_nouser_xattr, Opt_acl, Opt_noacl,
1664 Opt_auto_da_alloc, Opt_noauto_da_alloc, Opt_noload,
1665 Opt_commit, Opt_min_batch_time, Opt_max_batch_time, Opt_journal_dev,
1666 Opt_journal_path, Opt_journal_checksum, Opt_journal_async_commit,
1667 Opt_abort, Opt_data_journal, Opt_data_ordered, Opt_data_writeback,
1668 Opt_data_err_abort, Opt_data_err_ignore, Opt_test_dummy_encryption,
1669 Opt_inlinecrypt,
1670 Opt_usrjquota, Opt_grpjquota, Opt_offusrjquota, Opt_offgrpjquota,
1671 Opt_jqfmt_vfsold, Opt_jqfmt_vfsv0, Opt_jqfmt_vfsv1, Opt_quota,
1672 Opt_noquota, Opt_barrier, Opt_nobarrier, Opt_err,
1673 Opt_usrquota, Opt_grpquota, Opt_prjquota, Opt_i_version,
1674 Opt_dax, Opt_dax_always, Opt_dax_inode, Opt_dax_never,
1675 Opt_stripe, Opt_delalloc, Opt_nodelalloc, Opt_warn_on_error,
1676 Opt_nowarn_on_error, Opt_mblk_io_submit,
1677 Opt_lazytime, Opt_nolazytime, Opt_debug_want_extra_isize,
1678 Opt_nomblk_io_submit, Opt_block_validity, Opt_noblock_validity,
1679 Opt_inode_readahead_blks, Opt_journal_ioprio,
1680 Opt_dioread_nolock, Opt_dioread_lock,
1681 Opt_discard, Opt_nodiscard, Opt_init_itable, Opt_noinit_itable,
1682 Opt_max_dir_size_kb, Opt_nojournal_checksum, Opt_nombcache,
1683 Opt_no_prefetch_block_bitmaps, Opt_mb_optimize_scan,
1684#ifdef CONFIG_EXT4_DEBUG
1685 Opt_fc_debug_max_replay, Opt_fc_debug_force
1686#endif
1687};
1688
1689static const match_table_t tokens = {
1690 {Opt_bsd_df, "bsddf"},
1691 {Opt_minix_df, "minixdf"},
1692 {Opt_grpid, "grpid"},
1693 {Opt_grpid, "bsdgroups"},
1694 {Opt_nogrpid, "nogrpid"},
1695 {Opt_nogrpid, "sysvgroups"},
1696 {Opt_resgid, "resgid=%u"},
1697 {Opt_resuid, "resuid=%u"},
1698 {Opt_sb, "sb=%u"},
1699 {Opt_err_cont, "errors=continue"},
1700 {Opt_err_panic, "errors=panic"},
1701 {Opt_err_ro, "errors=remount-ro"},
1702 {Opt_nouid32, "nouid32"},
1703 {Opt_debug, "debug"},
1704 {Opt_removed, "oldalloc"},
1705 {Opt_removed, "orlov"},
1706 {Opt_user_xattr, "user_xattr"},
1707 {Opt_nouser_xattr, "nouser_xattr"},
1708 {Opt_acl, "acl"},
1709 {Opt_noacl, "noacl"},
1710 {Opt_noload, "norecovery"},
1711 {Opt_noload, "noload"},
1712 {Opt_removed, "nobh"},
1713 {Opt_removed, "bh"},
1714 {Opt_commit, "commit=%u"},
1715 {Opt_min_batch_time, "min_batch_time=%u"},
1716 {Opt_max_batch_time, "max_batch_time=%u"},
1717 {Opt_journal_dev, "journal_dev=%u"},
1718 {Opt_journal_path, "journal_path=%s"},
1719 {Opt_journal_checksum, "journal_checksum"},
1720 {Opt_nojournal_checksum, "nojournal_checksum"},
1721 {Opt_journal_async_commit, "journal_async_commit"},
1722 {Opt_abort, "abort"},
1723 {Opt_data_journal, "data=journal"},
1724 {Opt_data_ordered, "data=ordered"},
1725 {Opt_data_writeback, "data=writeback"},
1726 {Opt_data_err_abort, "data_err=abort"},
1727 {Opt_data_err_ignore, "data_err=ignore"},
1728 {Opt_offusrjquota, "usrjquota="},
1729 {Opt_usrjquota, "usrjquota=%s"},
1730 {Opt_offgrpjquota, "grpjquota="},
1731 {Opt_grpjquota, "grpjquota=%s"},
1732 {Opt_jqfmt_vfsold, "jqfmt=vfsold"},
1733 {Opt_jqfmt_vfsv0, "jqfmt=vfsv0"},
1734 {Opt_jqfmt_vfsv1, "jqfmt=vfsv1"},
1735 {Opt_grpquota, "grpquota"},
1736 {Opt_noquota, "noquota"},
1737 {Opt_quota, "quota"},
1738 {Opt_usrquota, "usrquota"},
1739 {Opt_prjquota, "prjquota"},
1740 {Opt_barrier, "barrier=%u"},
1741 {Opt_barrier, "barrier"},
1742 {Opt_nobarrier, "nobarrier"},
1743 {Opt_i_version, "i_version"},
1744 {Opt_dax, "dax"},
1745 {Opt_dax_always, "dax=always"},
1746 {Opt_dax_inode, "dax=inode"},
1747 {Opt_dax_never, "dax=never"},
1748 {Opt_stripe, "stripe=%u"},
1749 {Opt_delalloc, "delalloc"},
1750 {Opt_warn_on_error, "warn_on_error"},
1751 {Opt_nowarn_on_error, "nowarn_on_error"},
1752 {Opt_lazytime, "lazytime"},
1753 {Opt_nolazytime, "nolazytime"},
1754 {Opt_debug_want_extra_isize, "debug_want_extra_isize=%u"},
1755 {Opt_nodelalloc, "nodelalloc"},
1756 {Opt_removed, "mblk_io_submit"},
1757 {Opt_removed, "nomblk_io_submit"},
1758 {Opt_block_validity, "block_validity"},
1759 {Opt_noblock_validity, "noblock_validity"},
1760 {Opt_inode_readahead_blks, "inode_readahead_blks=%u"},
1761 {Opt_journal_ioprio, "journal_ioprio=%u"},
1762 {Opt_auto_da_alloc, "auto_da_alloc=%u"},
1763 {Opt_auto_da_alloc, "auto_da_alloc"},
1764 {Opt_noauto_da_alloc, "noauto_da_alloc"},
1765 {Opt_dioread_nolock, "dioread_nolock"},
1766 {Opt_dioread_lock, "nodioread_nolock"},
1767 {Opt_dioread_lock, "dioread_lock"},
1768 {Opt_discard, "discard"},
1769 {Opt_nodiscard, "nodiscard"},
1770 {Opt_init_itable, "init_itable=%u"},
1771 {Opt_init_itable, "init_itable"},
1772 {Opt_noinit_itable, "noinit_itable"},
1773#ifdef CONFIG_EXT4_DEBUG
1774 {Opt_fc_debug_force, "fc_debug_force"},
1775 {Opt_fc_debug_max_replay, "fc_debug_max_replay=%u"},
1776#endif
1777 {Opt_max_dir_size_kb, "max_dir_size_kb=%u"},
1778 {Opt_test_dummy_encryption, "test_dummy_encryption=%s"},
1779 {Opt_test_dummy_encryption, "test_dummy_encryption"},
1780 {Opt_inlinecrypt, "inlinecrypt"},
1781 {Opt_nombcache, "nombcache"},
1782 {Opt_nombcache, "no_mbcache"},
1783 {Opt_removed, "prefetch_block_bitmaps"},
1784 {Opt_no_prefetch_block_bitmaps, "no_prefetch_block_bitmaps"},
1785 {Opt_mb_optimize_scan, "mb_optimize_scan=%d"},
1786 {Opt_removed, "check=none"},
1787 {Opt_removed, "nocheck"},
1788 {Opt_removed, "reservation"},
1789 {Opt_removed, "noreservation"},
1790 {Opt_removed, "journal=%u"},
1791 {Opt_err, NULL},
1792};
1793
1794static ext4_fsblk_t get_sb_block(void **data)
1795{
1796 ext4_fsblk_t sb_block;
1797 char *options = (char *) *data;
1798
1799 if (!options || strncmp(options, "sb=", 3) != 0)
1800 return 1;
1801
1802 options += 3;
1803
1804 sb_block = simple_strtoul(options, &options, 0);
1805 if (*options && *options != ',') {
1806 printk(KERN_ERR "EXT4-fs: Invalid sb specification: %s\n",
1807 (char *) *data);
1808 return 1;
1809 }
1810 if (*options == ',')
1811 options++;
1812 *data = (void *) options;
1813
1814 return sb_block;
1815}
1816
1817#define DEFAULT_JOURNAL_IOPRIO (IOPRIO_PRIO_VALUE(IOPRIO_CLASS_BE, 3))
1818#define DEFAULT_MB_OPTIMIZE_SCAN (-1)
1819
1820static const char deprecated_msg[] =
1821 "Mount option \"%s\" will be removed by %s\n"
1822 "Contact linux-ext4@vger.kernel.org if you think we should keep it.\n";
1823
1824#ifdef CONFIG_QUOTA
1825static int set_qf_name(struct super_block *sb, int qtype, substring_t *args)
1826{
1827 struct ext4_sb_info *sbi = EXT4_SB(sb);
1828 char *qname, *old_qname = get_qf_name(sb, sbi, qtype);
1829 int ret = -1;
1830
1831 if (sb_any_quota_loaded(sb) && !old_qname) {
1832 ext4_msg(sb, KERN_ERR,
1833 "Cannot change journaled "
1834 "quota options when quota turned on");
1835 return -1;
1836 }
1837 if (ext4_has_feature_quota(sb)) {
1838 ext4_msg(sb, KERN_INFO, "Journaled quota options "
1839 "ignored when QUOTA feature is enabled");
1840 return 1;
1841 }
1842 qname = match_strdup(args);
1843 if (!qname) {
1844 ext4_msg(sb, KERN_ERR,
1845 "Not enough memory for storing quotafile name");
1846 return -1;
1847 }
1848 if (old_qname) {
1849 if (strcmp(old_qname, qname) == 0)
1850 ret = 1;
1851 else
1852 ext4_msg(sb, KERN_ERR,
1853 "%s quota file already specified",
1854 QTYPE2NAME(qtype));
1855 goto errout;
1856 }
1857 if (strchr(qname, '/')) {
1858 ext4_msg(sb, KERN_ERR,
1859 "quotafile must be on filesystem root");
1860 goto errout;
1861 }
1862 rcu_assign_pointer(sbi->s_qf_names[qtype], qname);
1863 set_opt(sb, QUOTA);
1864 return 1;
1865errout:
1866 kfree(qname);
1867 return ret;
1868}
1869
1870static int clear_qf_name(struct super_block *sb, int qtype)
1871{
1872
1873 struct ext4_sb_info *sbi = EXT4_SB(sb);
1874 char *old_qname = get_qf_name(sb, sbi, qtype);
1875
1876 if (sb_any_quota_loaded(sb) && old_qname) {
1877 ext4_msg(sb, KERN_ERR, "Cannot change journaled quota options"
1878 " when quota turned on");
1879 return -1;
1880 }
1881 rcu_assign_pointer(sbi->s_qf_names[qtype], NULL);
1882 synchronize_rcu();
1883 kfree(old_qname);
1884 return 1;
1885}
1886#endif
1887
1888#define MOPT_SET 0x0001
1889#define MOPT_CLEAR 0x0002
1890#define MOPT_NOSUPPORT 0x0004
1891#define MOPT_EXPLICIT 0x0008
1892#define MOPT_CLEAR_ERR 0x0010
1893#define MOPT_GTE0 0x0020
1894#ifdef CONFIG_QUOTA
1895#define MOPT_Q 0
1896#define MOPT_QFMT 0x0040
1897#else
1898#define MOPT_Q MOPT_NOSUPPORT
1899#define MOPT_QFMT MOPT_NOSUPPORT
1900#endif
1901#define MOPT_DATAJ 0x0080
1902#define MOPT_NO_EXT2 0x0100
1903#define MOPT_NO_EXT3 0x0200
1904#define MOPT_EXT4_ONLY (MOPT_NO_EXT2 | MOPT_NO_EXT3)
1905#define MOPT_STRING 0x0400
1906#define MOPT_SKIP 0x0800
1907#define MOPT_2 0x1000
1908
1909static const struct mount_opts {
1910 int token;
1911 int mount_opt;
1912 int flags;
1913} ext4_mount_opts[] = {
1914 {Opt_minix_df, EXT4_MOUNT_MINIX_DF, MOPT_SET},
1915 {Opt_bsd_df, EXT4_MOUNT_MINIX_DF, MOPT_CLEAR},
1916 {Opt_grpid, EXT4_MOUNT_GRPID, MOPT_SET},
1917 {Opt_nogrpid, EXT4_MOUNT_GRPID, MOPT_CLEAR},
1918 {Opt_block_validity, EXT4_MOUNT_BLOCK_VALIDITY, MOPT_SET},
1919 {Opt_noblock_validity, EXT4_MOUNT_BLOCK_VALIDITY, MOPT_CLEAR},
1920 {Opt_dioread_nolock, EXT4_MOUNT_DIOREAD_NOLOCK,
1921 MOPT_EXT4_ONLY | MOPT_SET},
1922 {Opt_dioread_lock, EXT4_MOUNT_DIOREAD_NOLOCK,
1923 MOPT_EXT4_ONLY | MOPT_CLEAR},
1924 {Opt_discard, EXT4_MOUNT_DISCARD, MOPT_SET},
1925 {Opt_nodiscard, EXT4_MOUNT_DISCARD, MOPT_CLEAR},
1926 {Opt_delalloc, EXT4_MOUNT_DELALLOC,
1927 MOPT_EXT4_ONLY | MOPT_SET | MOPT_EXPLICIT},
1928 {Opt_nodelalloc, EXT4_MOUNT_DELALLOC,
1929 MOPT_EXT4_ONLY | MOPT_CLEAR},
1930 {Opt_warn_on_error, EXT4_MOUNT_WARN_ON_ERROR, MOPT_SET},
1931 {Opt_nowarn_on_error, EXT4_MOUNT_WARN_ON_ERROR, MOPT_CLEAR},
1932 {Opt_nojournal_checksum, EXT4_MOUNT_JOURNAL_CHECKSUM,
1933 MOPT_EXT4_ONLY | MOPT_CLEAR},
1934 {Opt_journal_checksum, EXT4_MOUNT_JOURNAL_CHECKSUM,
1935 MOPT_EXT4_ONLY | MOPT_SET | MOPT_EXPLICIT},
1936 {Opt_journal_async_commit, (EXT4_MOUNT_JOURNAL_ASYNC_COMMIT |
1937 EXT4_MOUNT_JOURNAL_CHECKSUM),
1938 MOPT_EXT4_ONLY | MOPT_SET | MOPT_EXPLICIT},
1939 {Opt_noload, EXT4_MOUNT_NOLOAD, MOPT_NO_EXT2 | MOPT_SET},
1940 {Opt_err_panic, EXT4_MOUNT_ERRORS_PANIC, MOPT_SET | MOPT_CLEAR_ERR},
1941 {Opt_err_ro, EXT4_MOUNT_ERRORS_RO, MOPT_SET | MOPT_CLEAR_ERR},
1942 {Opt_err_cont, EXT4_MOUNT_ERRORS_CONT, MOPT_SET | MOPT_CLEAR_ERR},
1943 {Opt_data_err_abort, EXT4_MOUNT_DATA_ERR_ABORT,
1944 MOPT_NO_EXT2},
1945 {Opt_data_err_ignore, EXT4_MOUNT_DATA_ERR_ABORT,
1946 MOPT_NO_EXT2},
1947 {Opt_barrier, EXT4_MOUNT_BARRIER, MOPT_SET},
1948 {Opt_nobarrier, EXT4_MOUNT_BARRIER, MOPT_CLEAR},
1949 {Opt_noauto_da_alloc, EXT4_MOUNT_NO_AUTO_DA_ALLOC, MOPT_SET},
1950 {Opt_auto_da_alloc, EXT4_MOUNT_NO_AUTO_DA_ALLOC, MOPT_CLEAR},
1951 {Opt_noinit_itable, EXT4_MOUNT_INIT_INODE_TABLE, MOPT_CLEAR},
1952 {Opt_commit, 0, MOPT_GTE0},
1953 {Opt_max_batch_time, 0, MOPT_GTE0},
1954 {Opt_min_batch_time, 0, MOPT_GTE0},
1955 {Opt_inode_readahead_blks, 0, MOPT_GTE0},
1956 {Opt_init_itable, 0, MOPT_GTE0},
1957 {Opt_dax, EXT4_MOUNT_DAX_ALWAYS, MOPT_SET | MOPT_SKIP},
1958 {Opt_dax_always, EXT4_MOUNT_DAX_ALWAYS,
1959 MOPT_EXT4_ONLY | MOPT_SET | MOPT_SKIP},
1960 {Opt_dax_inode, EXT4_MOUNT2_DAX_INODE,
1961 MOPT_EXT4_ONLY | MOPT_SET | MOPT_SKIP},
1962 {Opt_dax_never, EXT4_MOUNT2_DAX_NEVER,
1963 MOPT_EXT4_ONLY | MOPT_SET | MOPT_SKIP},
1964 {Opt_stripe, 0, MOPT_GTE0},
1965 {Opt_resuid, 0, MOPT_GTE0},
1966 {Opt_resgid, 0, MOPT_GTE0},
1967 {Opt_journal_dev, 0, MOPT_NO_EXT2 | MOPT_GTE0},
1968 {Opt_journal_path, 0, MOPT_NO_EXT2 | MOPT_STRING},
1969 {Opt_journal_ioprio, 0, MOPT_NO_EXT2 | MOPT_GTE0},
1970 {Opt_data_journal, EXT4_MOUNT_JOURNAL_DATA, MOPT_NO_EXT2 | MOPT_DATAJ},
1971 {Opt_data_ordered, EXT4_MOUNT_ORDERED_DATA, MOPT_NO_EXT2 | MOPT_DATAJ},
1972 {Opt_data_writeback, EXT4_MOUNT_WRITEBACK_DATA,
1973 MOPT_NO_EXT2 | MOPT_DATAJ},
1974 {Opt_user_xattr, EXT4_MOUNT_XATTR_USER, MOPT_SET},
1975 {Opt_nouser_xattr, EXT4_MOUNT_XATTR_USER, MOPT_CLEAR},
1976#ifdef CONFIG_EXT4_FS_POSIX_ACL
1977 {Opt_acl, EXT4_MOUNT_POSIX_ACL, MOPT_SET},
1978 {Opt_noacl, EXT4_MOUNT_POSIX_ACL, MOPT_CLEAR},
1979#else
1980 {Opt_acl, 0, MOPT_NOSUPPORT},
1981 {Opt_noacl, 0, MOPT_NOSUPPORT},
1982#endif
1983 {Opt_nouid32, EXT4_MOUNT_NO_UID32, MOPT_SET},
1984 {Opt_debug, EXT4_MOUNT_DEBUG, MOPT_SET},
1985 {Opt_debug_want_extra_isize, 0, MOPT_GTE0},
1986 {Opt_quota, EXT4_MOUNT_QUOTA | EXT4_MOUNT_USRQUOTA, MOPT_SET | MOPT_Q},
1987 {Opt_usrquota, EXT4_MOUNT_QUOTA | EXT4_MOUNT_USRQUOTA,
1988 MOPT_SET | MOPT_Q},
1989 {Opt_grpquota, EXT4_MOUNT_QUOTA | EXT4_MOUNT_GRPQUOTA,
1990 MOPT_SET | MOPT_Q},
1991 {Opt_prjquota, EXT4_MOUNT_QUOTA | EXT4_MOUNT_PRJQUOTA,
1992 MOPT_SET | MOPT_Q},
1993 {Opt_noquota, (EXT4_MOUNT_QUOTA | EXT4_MOUNT_USRQUOTA |
1994 EXT4_MOUNT_GRPQUOTA | EXT4_MOUNT_PRJQUOTA),
1995 MOPT_CLEAR | MOPT_Q},
1996 {Opt_usrjquota, 0, MOPT_Q | MOPT_STRING},
1997 {Opt_grpjquota, 0, MOPT_Q | MOPT_STRING},
1998 {Opt_offusrjquota, 0, MOPT_Q},
1999 {Opt_offgrpjquota, 0, MOPT_Q},
2000 {Opt_jqfmt_vfsold, QFMT_VFS_OLD, MOPT_QFMT},
2001 {Opt_jqfmt_vfsv0, QFMT_VFS_V0, MOPT_QFMT},
2002 {Opt_jqfmt_vfsv1, QFMT_VFS_V1, MOPT_QFMT},
2003 {Opt_max_dir_size_kb, 0, MOPT_GTE0},
2004 {Opt_test_dummy_encryption, 0, MOPT_STRING},
2005 {Opt_nombcache, EXT4_MOUNT_NO_MBCACHE, MOPT_SET},
2006 {Opt_no_prefetch_block_bitmaps, EXT4_MOUNT_NO_PREFETCH_BLOCK_BITMAPS,
2007 MOPT_SET},
2008 {Opt_mb_optimize_scan, EXT4_MOUNT2_MB_OPTIMIZE_SCAN, MOPT_GTE0},
2009#ifdef CONFIG_EXT4_DEBUG
2010 {Opt_fc_debug_force, EXT4_MOUNT2_JOURNAL_FAST_COMMIT,
2011 MOPT_SET | MOPT_2 | MOPT_EXT4_ONLY},
2012 {Opt_fc_debug_max_replay, 0, MOPT_GTE0},
2013#endif
2014 {Opt_err, 0, 0}
2015};
2016
2017#ifdef CONFIG_UNICODE
2018static const struct ext4_sb_encodings {
2019 __u16 magic;
2020 char *name;
2021 char *version;
2022} ext4_sb_encoding_map[] = {
2023 {EXT4_ENC_UTF8_12_1, "utf8", "12.1.0"},
2024};
2025
2026static int ext4_sb_read_encoding(const struct ext4_super_block *es,
2027 const struct ext4_sb_encodings **encoding,
2028 __u16 *flags)
2029{
2030 __u16 magic = le16_to_cpu(es->s_encoding);
2031 int i;
2032
2033 for (i = 0; i < ARRAY_SIZE(ext4_sb_encoding_map); i++)
2034 if (magic == ext4_sb_encoding_map[i].magic)
2035 break;
2036
2037 if (i >= ARRAY_SIZE(ext4_sb_encoding_map))
2038 return -EINVAL;
2039
2040 *encoding = &ext4_sb_encoding_map[i];
2041 *flags = le16_to_cpu(es->s_encoding_flags);
2042
2043 return 0;
2044}
2045#endif
2046
2047static int ext4_set_test_dummy_encryption(struct super_block *sb,
2048 const char *opt,
2049 const substring_t *arg,
2050 bool is_remount)
2051{
2052#ifdef CONFIG_FS_ENCRYPTION
2053 struct ext4_sb_info *sbi = EXT4_SB(sb);
2054 int err;
2055
2056
2057
2058
2059
2060
2061
2062 if (is_remount && !sbi->s_dummy_enc_policy.policy) {
2063 ext4_msg(sb, KERN_WARNING,
2064 "Can't set test_dummy_encryption on remount");
2065 return -1;
2066 }
2067 err = fscrypt_set_test_dummy_encryption(sb, arg->from,
2068 &sbi->s_dummy_enc_policy);
2069 if (err) {
2070 if (err == -EEXIST)
2071 ext4_msg(sb, KERN_WARNING,
2072 "Can't change test_dummy_encryption on remount");
2073 else if (err == -EINVAL)
2074 ext4_msg(sb, KERN_WARNING,
2075 "Value of option \"%s\" is unrecognized", opt);
2076 else
2077 ext4_msg(sb, KERN_WARNING,
2078 "Error processing option \"%s\" [%d]",
2079 opt, err);
2080 return -1;
2081 }
2082 ext4_msg(sb, KERN_WARNING, "Test dummy encryption mode enabled");
2083#else
2084 ext4_msg(sb, KERN_WARNING,
2085 "Test dummy encryption mount option ignored");
2086#endif
2087 return 1;
2088}
2089
2090struct ext4_parsed_options {
2091 unsigned long journal_devnum;
2092 unsigned int journal_ioprio;
2093 int mb_optimize_scan;
2094};
2095
2096static int handle_mount_opt(struct super_block *sb, char *opt, int token,
2097 substring_t *args, struct ext4_parsed_options *parsed_opts,
2098 int is_remount)
2099{
2100 struct ext4_sb_info *sbi = EXT4_SB(sb);
2101 const struct mount_opts *m;
2102 kuid_t uid;
2103 kgid_t gid;
2104 int arg = 0;
2105
2106#ifdef CONFIG_QUOTA
2107 if (token == Opt_usrjquota)
2108 return set_qf_name(sb, USRQUOTA, &args[0]);
2109 else if (token == Opt_grpjquota)
2110 return set_qf_name(sb, GRPQUOTA, &args[0]);
2111 else if (token == Opt_offusrjquota)
2112 return clear_qf_name(sb, USRQUOTA);
2113 else if (token == Opt_offgrpjquota)
2114 return clear_qf_name(sb, GRPQUOTA);
2115#endif
2116 switch (token) {
2117 case Opt_noacl:
2118 case Opt_nouser_xattr:
2119 ext4_msg(sb, KERN_WARNING, deprecated_msg, opt, "3.5");
2120 break;
2121 case Opt_sb:
2122 return 1;
2123 case Opt_removed:
2124 ext4_msg(sb, KERN_WARNING, "Ignoring removed %s option", opt);
2125 return 1;
2126 case Opt_abort:
2127 ext4_set_mount_flag(sb, EXT4_MF_FS_ABORTED);
2128 return 1;
2129 case Opt_i_version:
2130 sb->s_flags |= SB_I_VERSION;
2131 return 1;
2132 case Opt_lazytime:
2133 sb->s_flags |= SB_LAZYTIME;
2134 return 1;
2135 case Opt_nolazytime:
2136 sb->s_flags &= ~SB_LAZYTIME;
2137 return 1;
2138 case Opt_inlinecrypt:
2139#ifdef CONFIG_FS_ENCRYPTION_INLINE_CRYPT
2140 sb->s_flags |= SB_INLINECRYPT;
2141#else
2142 ext4_msg(sb, KERN_ERR, "inline encryption not supported");
2143#endif
2144 return 1;
2145 }
2146
2147 for (m = ext4_mount_opts; m->token != Opt_err; m++)
2148 if (token == m->token)
2149 break;
2150
2151 if (m->token == Opt_err) {
2152 ext4_msg(sb, KERN_ERR, "Unrecognized mount option \"%s\" "
2153 "or missing value", opt);
2154 return -1;
2155 }
2156
2157 if ((m->flags & MOPT_NO_EXT2) && IS_EXT2_SB(sb)) {
2158 ext4_msg(sb, KERN_ERR,
2159 "Mount option \"%s\" incompatible with ext2", opt);
2160 return -1;
2161 }
2162 if ((m->flags & MOPT_NO_EXT3) && IS_EXT3_SB(sb)) {
2163 ext4_msg(sb, KERN_ERR,
2164 "Mount option \"%s\" incompatible with ext3", opt);
2165 return -1;
2166 }
2167
2168 if (args->from && !(m->flags & MOPT_STRING) && match_int(args, &arg))
2169 return -1;
2170 if (args->from && (m->flags & MOPT_GTE0) && (arg < 0))
2171 return -1;
2172 if (m->flags & MOPT_EXPLICIT) {
2173 if (m->mount_opt & EXT4_MOUNT_DELALLOC) {
2174 set_opt2(sb, EXPLICIT_DELALLOC);
2175 } else if (m->mount_opt & EXT4_MOUNT_JOURNAL_CHECKSUM) {
2176 set_opt2(sb, EXPLICIT_JOURNAL_CHECKSUM);
2177 } else
2178 return -1;
2179 }
2180 if (m->flags & MOPT_CLEAR_ERR)
2181 clear_opt(sb, ERRORS_MASK);
2182 if (token == Opt_noquota && sb_any_quota_loaded(sb)) {
2183 ext4_msg(sb, KERN_ERR, "Cannot change quota "
2184 "options when quota turned on");
2185 return -1;
2186 }
2187
2188 if (m->flags & MOPT_NOSUPPORT) {
2189 ext4_msg(sb, KERN_ERR, "%s option not supported", opt);
2190 } else if (token == Opt_commit) {
2191 if (arg == 0)
2192 arg = JBD2_DEFAULT_MAX_COMMIT_AGE;
2193 else if (arg > INT_MAX / HZ) {
2194 ext4_msg(sb, KERN_ERR,
2195 "Invalid commit interval %d, "
2196 "must be smaller than %d",
2197 arg, INT_MAX / HZ);
2198 return -1;
2199 }
2200 sbi->s_commit_interval = HZ * arg;
2201 } else if (token == Opt_debug_want_extra_isize) {
2202 if ((arg & 1) ||
2203 (arg < 4) ||
2204 (arg > (sbi->s_inode_size - EXT4_GOOD_OLD_INODE_SIZE))) {
2205 ext4_msg(sb, KERN_ERR,
2206 "Invalid want_extra_isize %d", arg);
2207 return -1;
2208 }
2209 sbi->s_want_extra_isize = arg;
2210 } else if (token == Opt_max_batch_time) {
2211 sbi->s_max_batch_time = arg;
2212 } else if (token == Opt_min_batch_time) {
2213 sbi->s_min_batch_time = arg;
2214 } else if (token == Opt_inode_readahead_blks) {
2215 if (arg && (arg > (1 << 30) || !is_power_of_2(arg))) {
2216 ext4_msg(sb, KERN_ERR,
2217 "EXT4-fs: inode_readahead_blks must be "
2218 "0 or a power of 2 smaller than 2^31");
2219 return -1;
2220 }
2221 sbi->s_inode_readahead_blks = arg;
2222 } else if (token == Opt_init_itable) {
2223 set_opt(sb, INIT_INODE_TABLE);
2224 if (!args->from)
2225 arg = EXT4_DEF_LI_WAIT_MULT;
2226 sbi->s_li_wait_mult = arg;
2227 } else if (token == Opt_max_dir_size_kb) {
2228 sbi->s_max_dir_size_kb = arg;
2229#ifdef CONFIG_EXT4_DEBUG
2230 } else if (token == Opt_fc_debug_max_replay) {
2231 sbi->s_fc_debug_max_replay = arg;
2232#endif
2233 } else if (token == Opt_stripe) {
2234 sbi->s_stripe = arg;
2235 } else if (token == Opt_resuid) {
2236 uid = make_kuid(current_user_ns(), arg);
2237 if (!uid_valid(uid)) {
2238 ext4_msg(sb, KERN_ERR, "Invalid uid value %d", arg);
2239 return -1;
2240 }
2241 sbi->s_resuid = uid;
2242 } else if (token == Opt_resgid) {
2243 gid = make_kgid(current_user_ns(), arg);
2244 if (!gid_valid(gid)) {
2245 ext4_msg(sb, KERN_ERR, "Invalid gid value %d", arg);
2246 return -1;
2247 }
2248 sbi->s_resgid = gid;
2249 } else if (token == Opt_journal_dev) {
2250 if (is_remount) {
2251 ext4_msg(sb, KERN_ERR,
2252 "Cannot specify journal on remount");
2253 return -1;
2254 }
2255 parsed_opts->journal_devnum = arg;
2256 } else if (token == Opt_journal_path) {
2257 char *journal_path;
2258 struct inode *journal_inode;
2259 struct path path;
2260 int error;
2261
2262 if (is_remount) {
2263 ext4_msg(sb, KERN_ERR,
2264 "Cannot specify journal on remount");
2265 return -1;
2266 }
2267 journal_path = match_strdup(&args[0]);
2268 if (!journal_path) {
2269 ext4_msg(sb, KERN_ERR, "error: could not dup "
2270 "journal device string");
2271 return -1;
2272 }
2273
2274 error = kern_path(journal_path, LOOKUP_FOLLOW, &path);
2275 if (error) {
2276 ext4_msg(sb, KERN_ERR, "error: could not find "
2277 "journal device path: error %d", error);
2278 kfree(journal_path);
2279 return -1;
2280 }
2281
2282 journal_inode = d_inode(path.dentry);
2283 if (!S_ISBLK(journal_inode->i_mode)) {
2284 ext4_msg(sb, KERN_ERR, "error: journal path %s "
2285 "is not a block device", journal_path);
2286 path_put(&path);
2287 kfree(journal_path);
2288 return -1;
2289 }
2290
2291 parsed_opts->journal_devnum = new_encode_dev(journal_inode->i_rdev);
2292 path_put(&path);
2293 kfree(journal_path);
2294 } else if (token == Opt_journal_ioprio) {
2295 if (arg > 7) {
2296 ext4_msg(sb, KERN_ERR, "Invalid journal IO priority"
2297 " (must be 0-7)");
2298 return -1;
2299 }
2300 parsed_opts->journal_ioprio =
2301 IOPRIO_PRIO_VALUE(IOPRIO_CLASS_BE, arg);
2302 } else if (token == Opt_test_dummy_encryption) {
2303 return ext4_set_test_dummy_encryption(sb, opt, &args[0],
2304 is_remount);
2305 } else if (m->flags & MOPT_DATAJ) {
2306 if (is_remount) {
2307 if (!sbi->s_journal)
2308 ext4_msg(sb, KERN_WARNING, "Remounting file system with no journal so ignoring journalled data option");
2309 else if (test_opt(sb, DATA_FLAGS) != m->mount_opt) {
2310 ext4_msg(sb, KERN_ERR,
2311 "Cannot change data mode on remount");
2312 return -1;
2313 }
2314 } else {
2315 clear_opt(sb, DATA_FLAGS);
2316 sbi->s_mount_opt |= m->mount_opt;
2317 }
2318#ifdef CONFIG_QUOTA
2319 } else if (m->flags & MOPT_QFMT) {
2320 if (sb_any_quota_loaded(sb) &&
2321 sbi->s_jquota_fmt != m->mount_opt) {
2322 ext4_msg(sb, KERN_ERR, "Cannot change journaled "
2323 "quota options when quota turned on");
2324 return -1;
2325 }
2326 if (ext4_has_feature_quota(sb)) {
2327 ext4_msg(sb, KERN_INFO,
2328 "Quota format mount options ignored "
2329 "when QUOTA feature is enabled");
2330 return 1;
2331 }
2332 sbi->s_jquota_fmt = m->mount_opt;
2333#endif
2334 } else if (token == Opt_dax || token == Opt_dax_always ||
2335 token == Opt_dax_inode || token == Opt_dax_never) {
2336#ifdef CONFIG_FS_DAX
2337 switch (token) {
2338 case Opt_dax:
2339 case Opt_dax_always:
2340 if (is_remount &&
2341 (!(sbi->s_mount_opt & EXT4_MOUNT_DAX_ALWAYS) ||
2342 (sbi->s_mount_opt2 & EXT4_MOUNT2_DAX_NEVER))) {
2343 fail_dax_change_remount:
2344 ext4_msg(sb, KERN_ERR, "can't change "
2345 "dax mount option while remounting");
2346 return -1;
2347 }
2348 if (is_remount &&
2349 (test_opt(sb, DATA_FLAGS) ==
2350 EXT4_MOUNT_JOURNAL_DATA)) {
2351 ext4_msg(sb, KERN_ERR, "can't mount with "
2352 "both data=journal and dax");
2353 return -1;
2354 }
2355 ext4_msg(sb, KERN_WARNING,
2356 "DAX enabled. Warning: EXPERIMENTAL, use at your own risk");
2357 sbi->s_mount_opt |= EXT4_MOUNT_DAX_ALWAYS;
2358 sbi->s_mount_opt2 &= ~EXT4_MOUNT2_DAX_NEVER;
2359 break;
2360 case Opt_dax_never:
2361 if (is_remount &&
2362 (!(sbi->s_mount_opt2 & EXT4_MOUNT2_DAX_NEVER) ||
2363 (sbi->s_mount_opt & EXT4_MOUNT_DAX_ALWAYS)))
2364 goto fail_dax_change_remount;
2365 sbi->s_mount_opt2 |= EXT4_MOUNT2_DAX_NEVER;
2366 sbi->s_mount_opt &= ~EXT4_MOUNT_DAX_ALWAYS;
2367 break;
2368 case Opt_dax_inode:
2369 if (is_remount &&
2370 ((sbi->s_mount_opt & EXT4_MOUNT_DAX_ALWAYS) ||
2371 (sbi->s_mount_opt2 & EXT4_MOUNT2_DAX_NEVER) ||
2372 !(sbi->s_mount_opt2 & EXT4_MOUNT2_DAX_INODE)))
2373 goto fail_dax_change_remount;
2374 sbi->s_mount_opt &= ~EXT4_MOUNT_DAX_ALWAYS;
2375 sbi->s_mount_opt2 &= ~EXT4_MOUNT2_DAX_NEVER;
2376
2377 sbi->s_mount_opt2 |= EXT4_MOUNT2_DAX_INODE;
2378 break;
2379 }
2380#else
2381 ext4_msg(sb, KERN_INFO, "dax option not supported");
2382 sbi->s_mount_opt2 |= EXT4_MOUNT2_DAX_NEVER;
2383 sbi->s_mount_opt &= ~EXT4_MOUNT_DAX_ALWAYS;
2384 return -1;
2385#endif
2386 } else if (token == Opt_data_err_abort) {
2387 sbi->s_mount_opt |= m->mount_opt;
2388 } else if (token == Opt_data_err_ignore) {
2389 sbi->s_mount_opt &= ~m->mount_opt;
2390 } else if (token == Opt_mb_optimize_scan) {
2391 if (arg != 0 && arg != 1) {
2392 ext4_msg(sb, KERN_WARNING,
2393 "mb_optimize_scan should be set to 0 or 1.");
2394 return -1;
2395 }
2396 parsed_opts->mb_optimize_scan = arg;
2397 } else {
2398 if (!args->from)
2399 arg = 1;
2400 if (m->flags & MOPT_CLEAR)
2401 arg = !arg;
2402 else if (unlikely(!(m->flags & MOPT_SET))) {
2403 ext4_msg(sb, KERN_WARNING,
2404 "buggy handling of option %s", opt);
2405 WARN_ON(1);
2406 return -1;
2407 }
2408 if (m->flags & MOPT_2) {
2409 if (arg != 0)
2410 sbi->s_mount_opt2 |= m->mount_opt;
2411 else
2412 sbi->s_mount_opt2 &= ~m->mount_opt;
2413 } else {
2414 if (arg != 0)
2415 sbi->s_mount_opt |= m->mount_opt;
2416 else
2417 sbi->s_mount_opt &= ~m->mount_opt;
2418 }
2419 }
2420 return 1;
2421}
2422
2423static int parse_options(char *options, struct super_block *sb,
2424 struct ext4_parsed_options *ret_opts,
2425 int is_remount)
2426{
2427 struct ext4_sb_info __maybe_unused *sbi = EXT4_SB(sb);
2428 char *p, __maybe_unused *usr_qf_name, __maybe_unused *grp_qf_name;
2429 substring_t args[MAX_OPT_ARGS];
2430 int token;
2431
2432 if (!options)
2433 return 1;
2434
2435 while ((p = strsep(&options, ",")) != NULL) {
2436 if (!*p)
2437 continue;
2438
2439
2440
2441
2442 args[0].to = args[0].from = NULL;
2443 token = match_token(p, tokens, args);
2444 if (handle_mount_opt(sb, p, token, args, ret_opts,
2445 is_remount) < 0)
2446 return 0;
2447 }
2448#ifdef CONFIG_QUOTA
2449
2450
2451
2452
2453
2454 if (test_opt(sb, PRJQUOTA) && !ext4_has_feature_project(sb)) {
2455 ext4_msg(sb, KERN_ERR, "Project quota feature not enabled. "
2456 "Cannot enable project quota enforcement.");
2457 return 0;
2458 }
2459 usr_qf_name = get_qf_name(sb, sbi, USRQUOTA);
2460 grp_qf_name = get_qf_name(sb, sbi, GRPQUOTA);
2461 if (usr_qf_name || grp_qf_name) {
2462 if (test_opt(sb, USRQUOTA) && usr_qf_name)
2463 clear_opt(sb, USRQUOTA);
2464
2465 if (test_opt(sb, GRPQUOTA) && grp_qf_name)
2466 clear_opt(sb, GRPQUOTA);
2467
2468 if (test_opt(sb, GRPQUOTA) || test_opt(sb, USRQUOTA)) {
2469 ext4_msg(sb, KERN_ERR, "old and new quota "
2470 "format mixing");
2471 return 0;
2472 }
2473
2474 if (!sbi->s_jquota_fmt) {
2475 ext4_msg(sb, KERN_ERR, "journaled quota format "
2476 "not specified");
2477 return 0;
2478 }
2479 }
2480#endif
2481 if (test_opt(sb, DIOREAD_NOLOCK)) {
2482 int blocksize =
2483 BLOCK_SIZE << le32_to_cpu(sbi->s_es->s_log_block_size);
2484 if (blocksize < PAGE_SIZE)
2485 ext4_msg(sb, KERN_WARNING, "Warning: mounting with an "
2486 "experimental mount option 'dioread_nolock' "
2487 "for blocksize < PAGE_SIZE");
2488 }
2489 return 1;
2490}
2491
2492static inline void ext4_show_quota_options(struct seq_file *seq,
2493 struct super_block *sb)
2494{
2495#if defined(CONFIG_QUOTA)
2496 struct ext4_sb_info *sbi = EXT4_SB(sb);
2497 char *usr_qf_name, *grp_qf_name;
2498
2499 if (sbi->s_jquota_fmt) {
2500 char *fmtname = "";
2501
2502 switch (sbi->s_jquota_fmt) {
2503 case QFMT_VFS_OLD:
2504 fmtname = "vfsold";
2505 break;
2506 case QFMT_VFS_V0:
2507 fmtname = "vfsv0";
2508 break;
2509 case QFMT_VFS_V1:
2510 fmtname = "vfsv1";
2511 break;
2512 }
2513 seq_printf(seq, ",jqfmt=%s", fmtname);
2514 }
2515
2516 rcu_read_lock();
2517 usr_qf_name = rcu_dereference(sbi->s_qf_names[USRQUOTA]);
2518 grp_qf_name = rcu_dereference(sbi->s_qf_names[GRPQUOTA]);
2519 if (usr_qf_name)
2520 seq_show_option(seq, "usrjquota", usr_qf_name);
2521 if (grp_qf_name)
2522 seq_show_option(seq, "grpjquota", grp_qf_name);
2523 rcu_read_unlock();
2524#endif
2525}
2526
2527static const char *token2str(int token)
2528{
2529 const struct match_token *t;
2530
2531 for (t = tokens; t->token != Opt_err; t++)
2532 if (t->token == token && !strchr(t->pattern, '='))
2533 break;
2534 return t->pattern;
2535}
2536
2537
2538
2539
2540
2541
2542static int _ext4_show_options(struct seq_file *seq, struct super_block *sb,
2543 int nodefs)
2544{
2545 struct ext4_sb_info *sbi = EXT4_SB(sb);
2546 struct ext4_super_block *es = sbi->s_es;
2547 int def_errors, def_mount_opt = sbi->s_def_mount_opt;
2548 const struct mount_opts *m;
2549 char sep = nodefs ? '\n' : ',';
2550
2551#define SEQ_OPTS_PUTS(str) seq_printf(seq, "%c" str, sep)
2552#define SEQ_OPTS_PRINT(str, arg) seq_printf(seq, "%c" str, sep, arg)
2553
2554 if (sbi->s_sb_block != 1)
2555 SEQ_OPTS_PRINT("sb=%llu", sbi->s_sb_block);
2556
2557 for (m = ext4_mount_opts; m->token != Opt_err; m++) {
2558 int want_set = m->flags & MOPT_SET;
2559 if (((m->flags & (MOPT_SET|MOPT_CLEAR)) == 0) ||
2560 (m->flags & MOPT_CLEAR_ERR) || m->flags & MOPT_SKIP)
2561 continue;
2562 if (!nodefs && !(m->mount_opt & (sbi->s_mount_opt ^ def_mount_opt)))
2563 continue;
2564 if ((want_set &&
2565 (sbi->s_mount_opt & m->mount_opt) != m->mount_opt) ||
2566 (!want_set && (sbi->s_mount_opt & m->mount_opt)))
2567 continue;
2568 SEQ_OPTS_PRINT("%s", token2str(m->token));
2569 }
2570
2571 if (nodefs || !uid_eq(sbi->s_resuid, make_kuid(&init_user_ns, EXT4_DEF_RESUID)) ||
2572 le16_to_cpu(es->s_def_resuid) != EXT4_DEF_RESUID)
2573 SEQ_OPTS_PRINT("resuid=%u",
2574 from_kuid_munged(&init_user_ns, sbi->s_resuid));
2575 if (nodefs || !gid_eq(sbi->s_resgid, make_kgid(&init_user_ns, EXT4_DEF_RESGID)) ||
2576 le16_to_cpu(es->s_def_resgid) != EXT4_DEF_RESGID)
2577 SEQ_OPTS_PRINT("resgid=%u",
2578 from_kgid_munged(&init_user_ns, sbi->s_resgid));
2579 def_errors = nodefs ? -1 : le16_to_cpu(es->s_errors);
2580 if (test_opt(sb, ERRORS_RO) && def_errors != EXT4_ERRORS_RO)
2581 SEQ_OPTS_PUTS("errors=remount-ro");
2582 if (test_opt(sb, ERRORS_CONT) && def_errors != EXT4_ERRORS_CONTINUE)
2583 SEQ_OPTS_PUTS("errors=continue");
2584 if (test_opt(sb, ERRORS_PANIC) && def_errors != EXT4_ERRORS_PANIC)
2585 SEQ_OPTS_PUTS("errors=panic");
2586 if (nodefs || sbi->s_commit_interval != JBD2_DEFAULT_MAX_COMMIT_AGE*HZ)
2587 SEQ_OPTS_PRINT("commit=%lu", sbi->s_commit_interval / HZ);
2588 if (nodefs || sbi->s_min_batch_time != EXT4_DEF_MIN_BATCH_TIME)
2589 SEQ_OPTS_PRINT("min_batch_time=%u", sbi->s_min_batch_time);
2590 if (nodefs || sbi->s_max_batch_time != EXT4_DEF_MAX_BATCH_TIME)
2591 SEQ_OPTS_PRINT("max_batch_time=%u", sbi->s_max_batch_time);
2592 if (sb->s_flags & SB_I_VERSION)
2593 SEQ_OPTS_PUTS("i_version");
2594 if (nodefs || sbi->s_stripe)
2595 SEQ_OPTS_PRINT("stripe=%lu", sbi->s_stripe);
2596 if (nodefs || EXT4_MOUNT_DATA_FLAGS &
2597 (sbi->s_mount_opt ^ def_mount_opt)) {
2598 if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA)
2599 SEQ_OPTS_PUTS("data=journal");
2600 else if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_ORDERED_DATA)
2601 SEQ_OPTS_PUTS("data=ordered");
2602 else if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_WRITEBACK_DATA)
2603 SEQ_OPTS_PUTS("data=writeback");
2604 }
2605 if (nodefs ||
2606 sbi->s_inode_readahead_blks != EXT4_DEF_INODE_READAHEAD_BLKS)
2607 SEQ_OPTS_PRINT("inode_readahead_blks=%u",
2608 sbi->s_inode_readahead_blks);
2609
2610 if (test_opt(sb, INIT_INODE_TABLE) && (nodefs ||
2611 (sbi->s_li_wait_mult != EXT4_DEF_LI_WAIT_MULT)))
2612 SEQ_OPTS_PRINT("init_itable=%u", sbi->s_li_wait_mult);
2613 if (nodefs || sbi->s_max_dir_size_kb)
2614 SEQ_OPTS_PRINT("max_dir_size_kb=%u", sbi->s_max_dir_size_kb);
2615 if (test_opt(sb, DATA_ERR_ABORT))
2616 SEQ_OPTS_PUTS("data_err=abort");
2617
2618 fscrypt_show_test_dummy_encryption(seq, sep, sb);
2619
2620 if (sb->s_flags & SB_INLINECRYPT)
2621 SEQ_OPTS_PUTS("inlinecrypt");
2622
2623 if (test_opt(sb, DAX_ALWAYS)) {
2624 if (IS_EXT2_SB(sb))
2625 SEQ_OPTS_PUTS("dax");
2626 else
2627 SEQ_OPTS_PUTS("dax=always");
2628 } else if (test_opt2(sb, DAX_NEVER)) {
2629 SEQ_OPTS_PUTS("dax=never");
2630 } else if (test_opt2(sb, DAX_INODE)) {
2631 SEQ_OPTS_PUTS("dax=inode");
2632 }
2633 ext4_show_quota_options(seq, sb);
2634 return 0;
2635}
2636
2637static int ext4_show_options(struct seq_file *seq, struct dentry *root)
2638{
2639 return _ext4_show_options(seq, root->d_sb, 0);
2640}
2641
2642int ext4_seq_options_show(struct seq_file *seq, void *offset)
2643{
2644 struct super_block *sb = seq->private;
2645 int rc;
2646
2647 seq_puts(seq, sb_rdonly(sb) ? "ro" : "rw");
2648 rc = _ext4_show_options(seq, sb, 1);
2649 seq_puts(seq, "\n");
2650 return rc;
2651}
2652
2653static int ext4_setup_super(struct super_block *sb, struct ext4_super_block *es,
2654 int read_only)
2655{
2656 struct ext4_sb_info *sbi = EXT4_SB(sb);
2657 int err = 0;
2658
2659 if (le32_to_cpu(es->s_rev_level) > EXT4_MAX_SUPP_REV) {
2660 ext4_msg(sb, KERN_ERR, "revision level too high, "
2661 "forcing read-only mode");
2662 err = -EROFS;
2663 goto done;
2664 }
2665 if (read_only)
2666 goto done;
2667 if (!(sbi->s_mount_state & EXT4_VALID_FS))
2668 ext4_msg(sb, KERN_WARNING, "warning: mounting unchecked fs, "
2669 "running e2fsck is recommended");
2670 else if (sbi->s_mount_state & EXT4_ERROR_FS)
2671 ext4_msg(sb, KERN_WARNING,
2672 "warning: mounting fs with errors, "
2673 "running e2fsck is recommended");
2674 else if ((__s16) le16_to_cpu(es->s_max_mnt_count) > 0 &&
2675 le16_to_cpu(es->s_mnt_count) >=
2676 (unsigned short) (__s16) le16_to_cpu(es->s_max_mnt_count))
2677 ext4_msg(sb, KERN_WARNING,
2678 "warning: maximal mount count reached, "
2679 "running e2fsck is recommended");
2680 else if (le32_to_cpu(es->s_checkinterval) &&
2681 (ext4_get_tstamp(es, s_lastcheck) +
2682 le32_to_cpu(es->s_checkinterval) <= ktime_get_real_seconds()))
2683 ext4_msg(sb, KERN_WARNING,
2684 "warning: checktime reached, "
2685 "running e2fsck is recommended");
2686 if (!sbi->s_journal)
2687 es->s_state &= cpu_to_le16(~EXT4_VALID_FS);
2688 if (!(__s16) le16_to_cpu(es->s_max_mnt_count))
2689 es->s_max_mnt_count = cpu_to_le16(EXT4_DFL_MAX_MNT_COUNT);
2690 le16_add_cpu(&es->s_mnt_count, 1);
2691 ext4_update_tstamp(es, s_mtime);
2692 if (sbi->s_journal) {
2693 ext4_set_feature_journal_needs_recovery(sb);
2694 if (ext4_has_feature_orphan_file(sb))
2695 ext4_set_feature_orphan_present(sb);
2696 }
2697
2698 err = ext4_commit_super(sb);
2699done:
2700 if (test_opt(sb, DEBUG))
2701 printk(KERN_INFO "[EXT4 FS bs=%lu, gc=%u, "
2702 "bpg=%lu, ipg=%lu, mo=%04x, mo2=%04x]\n",
2703 sb->s_blocksize,
2704 sbi->s_groups_count,
2705 EXT4_BLOCKS_PER_GROUP(sb),
2706 EXT4_INODES_PER_GROUP(sb),
2707 sbi->s_mount_opt, sbi->s_mount_opt2);
2708
2709 cleancache_init_fs(sb);
2710 return err;
2711}
2712
2713int ext4_alloc_flex_bg_array(struct super_block *sb, ext4_group_t ngroup)
2714{
2715 struct ext4_sb_info *sbi = EXT4_SB(sb);
2716 struct flex_groups **old_groups, **new_groups;
2717 int size, i, j;
2718
2719 if (!sbi->s_log_groups_per_flex)
2720 return 0;
2721
2722 size = ext4_flex_group(sbi, ngroup - 1) + 1;
2723 if (size <= sbi->s_flex_groups_allocated)
2724 return 0;
2725
2726 new_groups = kvzalloc(roundup_pow_of_two(size *
2727 sizeof(*sbi->s_flex_groups)), GFP_KERNEL);
2728 if (!new_groups) {
2729 ext4_msg(sb, KERN_ERR,
2730 "not enough memory for %d flex group pointers", size);
2731 return -ENOMEM;
2732 }
2733 for (i = sbi->s_flex_groups_allocated; i < size; i++) {
2734 new_groups[i] = kvzalloc(roundup_pow_of_two(
2735 sizeof(struct flex_groups)),
2736 GFP_KERNEL);
2737 if (!new_groups[i]) {
2738 for (j = sbi->s_flex_groups_allocated; j < i; j++)
2739 kvfree(new_groups[j]);
2740 kvfree(new_groups);
2741 ext4_msg(sb, KERN_ERR,
2742 "not enough memory for %d flex groups", size);
2743 return -ENOMEM;
2744 }
2745 }
2746 rcu_read_lock();
2747 old_groups = rcu_dereference(sbi->s_flex_groups);
2748 if (old_groups)
2749 memcpy(new_groups, old_groups,
2750 (sbi->s_flex_groups_allocated *
2751 sizeof(struct flex_groups *)));
2752 rcu_read_unlock();
2753 rcu_assign_pointer(sbi->s_flex_groups, new_groups);
2754 sbi->s_flex_groups_allocated = size;
2755 if (old_groups)
2756 ext4_kvfree_array_rcu(old_groups);
2757 return 0;
2758}
2759
2760static int ext4_fill_flex_info(struct super_block *sb)
2761{
2762 struct ext4_sb_info *sbi = EXT4_SB(sb);
2763 struct ext4_group_desc *gdp = NULL;
2764 struct flex_groups *fg;
2765 ext4_group_t flex_group;
2766 int i, err;
2767
2768 sbi->s_log_groups_per_flex = sbi->s_es->s_log_groups_per_flex;
2769 if (sbi->s_log_groups_per_flex < 1 || sbi->s_log_groups_per_flex > 31) {
2770 sbi->s_log_groups_per_flex = 0;
2771 return 1;
2772 }
2773
2774 err = ext4_alloc_flex_bg_array(sb, sbi->s_groups_count);
2775 if (err)
2776 goto failed;
2777
2778 for (i = 0; i < sbi->s_groups_count; i++) {
2779 gdp = ext4_get_group_desc(sb, i, NULL);
2780
2781 flex_group = ext4_flex_group(sbi, i);
2782 fg = sbi_array_rcu_deref(sbi, s_flex_groups, flex_group);
2783 atomic_add(ext4_free_inodes_count(sb, gdp), &fg->free_inodes);
2784 atomic64_add(ext4_free_group_clusters(sb, gdp),
2785 &fg->free_clusters);
2786 atomic_add(ext4_used_dirs_count(sb, gdp), &fg->used_dirs);
2787 }
2788
2789 return 1;
2790failed:
2791 return 0;
2792}
2793
2794static __le16 ext4_group_desc_csum(struct super_block *sb, __u32 block_group,
2795 struct ext4_group_desc *gdp)
2796{
2797 int offset = offsetof(struct ext4_group_desc, bg_checksum);
2798 __u16 crc = 0;
2799 __le32 le_group = cpu_to_le32(block_group);
2800 struct ext4_sb_info *sbi = EXT4_SB(sb);
2801
2802 if (ext4_has_metadata_csum(sbi->s_sb)) {
2803
2804 __u32 csum32;
2805 __u16 dummy_csum = 0;
2806
2807 csum32 = ext4_chksum(sbi, sbi->s_csum_seed, (__u8 *)&le_group,
2808 sizeof(le_group));
2809 csum32 = ext4_chksum(sbi, csum32, (__u8 *)gdp, offset);
2810 csum32 = ext4_chksum(sbi, csum32, (__u8 *)&dummy_csum,
2811 sizeof(dummy_csum));
2812 offset += sizeof(dummy_csum);
2813 if (offset < sbi->s_desc_size)
2814 csum32 = ext4_chksum(sbi, csum32, (__u8 *)gdp + offset,
2815 sbi->s_desc_size - offset);
2816
2817 crc = csum32 & 0xFFFF;
2818 goto out;
2819 }
2820
2821
2822 if (!ext4_has_feature_gdt_csum(sb))
2823 return 0;
2824
2825 crc = crc16(~0, sbi->s_es->s_uuid, sizeof(sbi->s_es->s_uuid));
2826 crc = crc16(crc, (__u8 *)&le_group, sizeof(le_group));
2827 crc = crc16(crc, (__u8 *)gdp, offset);
2828 offset += sizeof(gdp->bg_checksum);
2829
2830 if (ext4_has_feature_64bit(sb) &&
2831 offset < le16_to_cpu(sbi->s_es->s_desc_size))
2832 crc = crc16(crc, (__u8 *)gdp + offset,
2833 le16_to_cpu(sbi->s_es->s_desc_size) -
2834 offset);
2835
2836out:
2837 return cpu_to_le16(crc);
2838}
2839
2840int ext4_group_desc_csum_verify(struct super_block *sb, __u32 block_group,
2841 struct ext4_group_desc *gdp)
2842{
2843 if (ext4_has_group_desc_csum(sb) &&
2844 (gdp->bg_checksum != ext4_group_desc_csum(sb, block_group, gdp)))
2845 return 0;
2846
2847 return 1;
2848}
2849
2850void ext4_group_desc_csum_set(struct super_block *sb, __u32 block_group,
2851 struct ext4_group_desc *gdp)
2852{
2853 if (!ext4_has_group_desc_csum(sb))
2854 return;
2855 gdp->bg_checksum = ext4_group_desc_csum(sb, block_group, gdp);
2856}
2857
2858
2859static int ext4_check_descriptors(struct super_block *sb,
2860 ext4_fsblk_t sb_block,
2861 ext4_group_t *first_not_zeroed)
2862{
2863 struct ext4_sb_info *sbi = EXT4_SB(sb);
2864 ext4_fsblk_t first_block = le32_to_cpu(sbi->s_es->s_first_data_block);
2865 ext4_fsblk_t last_block;
2866 ext4_fsblk_t last_bg_block = sb_block + ext4_bg_num_gdb(sb, 0);
2867 ext4_fsblk_t block_bitmap;
2868 ext4_fsblk_t inode_bitmap;
2869 ext4_fsblk_t inode_table;
2870 int flexbg_flag = 0;
2871 ext4_group_t i, grp = sbi->s_groups_count;
2872
2873 if (ext4_has_feature_flex_bg(sb))
2874 flexbg_flag = 1;
2875
2876 ext4_debug("Checking group descriptors");
2877
2878 for (i = 0; i < sbi->s_groups_count; i++) {
2879 struct ext4_group_desc *gdp = ext4_get_group_desc(sb, i, NULL);
2880
2881 if (i == sbi->s_groups_count - 1 || flexbg_flag)
2882 last_block = ext4_blocks_count(sbi->s_es) - 1;
2883 else
2884 last_block = first_block +
2885 (EXT4_BLOCKS_PER_GROUP(sb) - 1);
2886
2887 if ((grp == sbi->s_groups_count) &&
2888 !(gdp->bg_flags & cpu_to_le16(EXT4_BG_INODE_ZEROED)))
2889 grp = i;
2890
2891 block_bitmap = ext4_block_bitmap(sb, gdp);
2892 if (block_bitmap == sb_block) {
2893 ext4_msg(sb, KERN_ERR, "ext4_check_descriptors: "
2894 "Block bitmap for group %u overlaps "
2895 "superblock", i);
2896 if (!sb_rdonly(sb))
2897 return 0;
2898 }
2899 if (block_bitmap >= sb_block + 1 &&
2900 block_bitmap <= last_bg_block) {
2901 ext4_msg(sb, KERN_ERR, "ext4_check_descriptors: "
2902 "Block bitmap for group %u overlaps "
2903 "block group descriptors", i);
2904 if (!sb_rdonly(sb))
2905 return 0;
2906 }
2907 if (block_bitmap < first_block || block_bitmap > last_block) {
2908 ext4_msg(sb, KERN_ERR, "ext4_check_descriptors: "
2909 "Block bitmap for group %u not in group "
2910 "(block %llu)!", i, block_bitmap);
2911 return 0;
2912 }
2913 inode_bitmap = ext4_inode_bitmap(sb, gdp);
2914 if (inode_bitmap == sb_block) {
2915 ext4_msg(sb, KERN_ERR, "ext4_check_descriptors: "
2916 "Inode bitmap for group %u overlaps "
2917 "superblock", i);
2918 if (!sb_rdonly(sb))
2919 return 0;
2920 }
2921 if (inode_bitmap >= sb_block + 1 &&
2922 inode_bitmap <= last_bg_block) {
2923 ext4_msg(sb, KERN_ERR, "ext4_check_descriptors: "
2924 "Inode bitmap for group %u overlaps "
2925 "block group descriptors", i);
2926 if (!sb_rdonly(sb))
2927 return 0;
2928 }
2929 if (inode_bitmap < first_block || inode_bitmap > last_block) {
2930 ext4_msg(sb, KERN_ERR, "ext4_check_descriptors: "
2931 "Inode bitmap for group %u not in group "
2932 "(block %llu)!", i, inode_bitmap);
2933 return 0;
2934 }
2935 inode_table = ext4_inode_table(sb, gdp);
2936 if (inode_table == sb_block) {
2937 ext4_msg(sb, KERN_ERR, "ext4_check_descriptors: "
2938 "Inode table for group %u overlaps "
2939 "superblock", i);
2940 if (!sb_rdonly(sb))
2941 return 0;
2942 }
2943 if (inode_table >= sb_block + 1 &&
2944 inode_table <= last_bg_block) {
2945 ext4_msg(sb, KERN_ERR, "ext4_check_descriptors: "
2946 "Inode table for group %u overlaps "
2947 "block group descriptors", i);
2948 if (!sb_rdonly(sb))
2949 return 0;
2950 }
2951 if (inode_table < first_block ||
2952 inode_table + sbi->s_itb_per_group - 1 > last_block) {
2953 ext4_msg(sb, KERN_ERR, "ext4_check_descriptors: "
2954 "Inode table for group %u not in group "
2955 "(block %llu)!", i, inode_table);
2956 return 0;
2957 }
2958 ext4_lock_group(sb, i);
2959 if (!ext4_group_desc_csum_verify(sb, i, gdp)) {
2960 ext4_msg(sb, KERN_ERR, "ext4_check_descriptors: "
2961 "Checksum for group %u failed (%u!=%u)",
2962 i, le16_to_cpu(ext4_group_desc_csum(sb, i,
2963 gdp)), le16_to_cpu(gdp->bg_checksum));
2964 if (!sb_rdonly(sb)) {
2965 ext4_unlock_group(sb, i);
2966 return 0;
2967 }
2968 }
2969 ext4_unlock_group(sb, i);
2970 if (!flexbg_flag)
2971 first_block += EXT4_BLOCKS_PER_GROUP(sb);
2972 }
2973 if (NULL != first_not_zeroed)
2974 *first_not_zeroed = grp;
2975 return 1;
2976}
2977
2978
2979
2980
2981
2982
2983
2984
2985
2986
2987
2988
2989
2990
2991
2992
2993static loff_t ext4_max_size(int blkbits, int has_huge_files)
2994{
2995 loff_t res;
2996 loff_t upper_limit = MAX_LFS_FILESIZE;
2997
2998 BUILD_BUG_ON(sizeof(blkcnt_t) < sizeof(u64));
2999
3000 if (!has_huge_files) {
3001 upper_limit = (1LL << 32) - 1;
3002
3003
3004 upper_limit >>= (blkbits - 9);
3005 upper_limit <<= blkbits;
3006 }
3007
3008
3009
3010
3011
3012
3013 res = (1LL << 32) - 1;
3014 res <<= blkbits;
3015
3016
3017 if (res > upper_limit)
3018 res = upper_limit;
3019
3020 return res;
3021}
3022
3023
3024
3025
3026
3027
3028static loff_t ext4_max_bitmap_size(int bits, int has_huge_files)
3029{
3030 unsigned long long upper_limit, res = EXT4_NDIR_BLOCKS;
3031 int meta_blocks;
3032
3033
3034
3035
3036
3037
3038
3039
3040
3041 if (!has_huge_files) {
3042
3043
3044
3045
3046
3047 upper_limit = (1LL << 32) - 1;
3048
3049
3050 upper_limit >>= (bits - 9);
3051
3052 } else {
3053
3054
3055
3056
3057
3058
3059 upper_limit = (1LL << 48) - 1;
3060
3061 }
3062
3063
3064 meta_blocks = 1;
3065
3066 meta_blocks += 1 + (1LL << (bits-2));
3067
3068 meta_blocks += 1 + (1LL << (bits-2)) + (1LL << (2*(bits-2)));
3069
3070 upper_limit -= meta_blocks;
3071 upper_limit <<= bits;
3072
3073 res += 1LL << (bits-2);
3074 res += 1LL << (2*(bits-2));
3075 res += 1LL << (3*(bits-2));
3076 res <<= bits;
3077 if (res > upper_limit)
3078 res = upper_limit;
3079
3080 if (res > MAX_LFS_FILESIZE)
3081 res = MAX_LFS_FILESIZE;
3082
3083 return (loff_t)res;
3084}
3085
3086static ext4_fsblk_t descriptor_loc(struct super_block *sb,
3087 ext4_fsblk_t logical_sb_block, int nr)
3088{
3089 struct ext4_sb_info *sbi = EXT4_SB(sb);
3090 ext4_group_t bg, first_meta_bg;
3091 int has_super = 0;
3092
3093 first_meta_bg = le32_to_cpu(sbi->s_es->s_first_meta_bg);
3094
3095 if (!ext4_has_feature_meta_bg(sb) || nr < first_meta_bg)
3096 return logical_sb_block + nr + 1;
3097 bg = sbi->s_desc_per_block * nr;
3098 if (ext4_bg_has_super(sb, bg))
3099 has_super = 1;
3100
3101
3102
3103
3104
3105
3106
3107 if (sb->s_blocksize == 1024 && nr == 0 &&
3108 le32_to_cpu(sbi->s_es->s_first_data_block) == 0)
3109 has_super++;
3110
3111 return (has_super + ext4_group_first_block_no(sb, bg));
3112}
3113
3114
3115
3116
3117
3118
3119
3120
3121
3122
3123
3124
3125static unsigned long ext4_get_stripe_size(struct ext4_sb_info *sbi)
3126{
3127 unsigned long stride = le16_to_cpu(sbi->s_es->s_raid_stride);
3128 unsigned long stripe_width =
3129 le32_to_cpu(sbi->s_es->s_raid_stripe_width);
3130 int ret;
3131
3132 if (sbi->s_stripe && sbi->s_stripe <= sbi->s_blocks_per_group)
3133 ret = sbi->s_stripe;
3134 else if (stripe_width && stripe_width <= sbi->s_blocks_per_group)
3135 ret = stripe_width;
3136 else if (stride && stride <= sbi->s_blocks_per_group)
3137 ret = stride;
3138 else
3139 ret = 0;
3140
3141
3142
3143
3144
3145 if (ret <= 1)
3146 ret = 0;
3147
3148 return ret;
3149}
3150
3151
3152
3153
3154
3155
3156
3157int ext4_feature_set_ok(struct super_block *sb, int readonly)
3158{
3159 if (ext4_has_unknown_ext4_incompat_features(sb)) {
3160 ext4_msg(sb, KERN_ERR,
3161 "Couldn't mount because of "
3162 "unsupported optional features (%x)",
3163 (le32_to_cpu(EXT4_SB(sb)->s_es->s_feature_incompat) &
3164 ~EXT4_FEATURE_INCOMPAT_SUPP));
3165 return 0;
3166 }
3167
3168#ifndef CONFIG_UNICODE
3169 if (ext4_has_feature_casefold(sb)) {
3170 ext4_msg(sb, KERN_ERR,
3171 "Filesystem with casefold feature cannot be "
3172 "mounted without CONFIG_UNICODE");
3173 return 0;
3174 }
3175#endif
3176
3177 if (readonly)
3178 return 1;
3179
3180 if (ext4_has_feature_readonly(sb)) {
3181 ext4_msg(sb, KERN_INFO, "filesystem is read-only");
3182 sb->s_flags |= SB_RDONLY;
3183 return 1;
3184 }
3185
3186
3187 if (ext4_has_unknown_ext4_ro_compat_features(sb)) {
3188 ext4_msg(sb, KERN_ERR, "couldn't mount RDWR because of "
3189 "unsupported optional features (%x)",
3190 (le32_to_cpu(EXT4_SB(sb)->s_es->s_feature_ro_compat) &
3191 ~EXT4_FEATURE_RO_COMPAT_SUPP));
3192 return 0;
3193 }
3194 if (ext4_has_feature_bigalloc(sb) && !ext4_has_feature_extents(sb)) {
3195 ext4_msg(sb, KERN_ERR,
3196 "Can't support bigalloc feature without "
3197 "extents feature\n");
3198 return 0;
3199 }
3200
3201#if !IS_ENABLED(CONFIG_QUOTA) || !IS_ENABLED(CONFIG_QFMT_V2)
3202 if (!readonly && (ext4_has_feature_quota(sb) ||
3203 ext4_has_feature_project(sb))) {
3204 ext4_msg(sb, KERN_ERR,
3205 "The kernel was not built with CONFIG_QUOTA and CONFIG_QFMT_V2");
3206 return 0;
3207 }
3208#endif
3209 return 1;
3210}
3211
3212
3213
3214
3215
3216static void print_daily_error_info(struct timer_list *t)
3217{
3218 struct ext4_sb_info *sbi = from_timer(sbi, t, s_err_report);
3219 struct super_block *sb = sbi->s_sb;
3220 struct ext4_super_block *es = sbi->s_es;
3221
3222 if (es->s_error_count)
3223
3224 ext4_msg(sb, KERN_NOTICE, "error count since last fsck: %u",
3225 le32_to_cpu(es->s_error_count));
3226 if (es->s_first_error_time) {
3227 printk(KERN_NOTICE "EXT4-fs (%s): initial error at time %llu: %.*s:%d",
3228 sb->s_id,
3229 ext4_get_tstamp(es, s_first_error_time),
3230 (int) sizeof(es->s_first_error_func),
3231 es->s_first_error_func,
3232 le32_to_cpu(es->s_first_error_line));
3233 if (es->s_first_error_ino)
3234 printk(KERN_CONT ": inode %u",
3235 le32_to_cpu(es->s_first_error_ino));
3236 if (es->s_first_error_block)
3237 printk(KERN_CONT ": block %llu", (unsigned long long)
3238 le64_to_cpu(es->s_first_error_block));
3239 printk(KERN_CONT "\n");
3240 }
3241 if (es->s_last_error_time) {
3242 printk(KERN_NOTICE "EXT4-fs (%s): last error at time %llu: %.*s:%d",
3243 sb->s_id,
3244 ext4_get_tstamp(es, s_last_error_time),
3245 (int) sizeof(es->s_last_error_func),
3246 es->s_last_error_func,
3247 le32_to_cpu(es->s_last_error_line));
3248 if (es->s_last_error_ino)
3249 printk(KERN_CONT ": inode %u",
3250 le32_to_cpu(es->s_last_error_ino));
3251 if (es->s_last_error_block)
3252 printk(KERN_CONT ": block %llu", (unsigned long long)
3253 le64_to_cpu(es->s_last_error_block));
3254 printk(KERN_CONT "\n");
3255 }
3256 mod_timer(&sbi->s_err_report, jiffies + 24*60*60*HZ);
3257}
3258
3259
3260static int ext4_run_li_request(struct ext4_li_request *elr)
3261{
3262 struct ext4_group_desc *gdp = NULL;
3263 struct super_block *sb = elr->lr_super;
3264 ext4_group_t ngroups = EXT4_SB(sb)->s_groups_count;
3265 ext4_group_t group = elr->lr_next_group;
3266 unsigned long timeout = 0;
3267 unsigned int prefetch_ios = 0;
3268 int ret = 0;
3269
3270 if (elr->lr_mode == EXT4_LI_MODE_PREFETCH_BBITMAP) {
3271 elr->lr_next_group = ext4_mb_prefetch(sb, group,
3272 EXT4_SB(sb)->s_mb_prefetch, &prefetch_ios);
3273 if (prefetch_ios)
3274 ext4_mb_prefetch_fini(sb, elr->lr_next_group,
3275 prefetch_ios);
3276 trace_ext4_prefetch_bitmaps(sb, group, elr->lr_next_group,
3277 prefetch_ios);
3278 if (group >= elr->lr_next_group) {
3279 ret = 1;
3280 if (elr->lr_first_not_zeroed != ngroups &&
3281 !sb_rdonly(sb) && test_opt(sb, INIT_INODE_TABLE)) {
3282 elr->lr_next_group = elr->lr_first_not_zeroed;
3283 elr->lr_mode = EXT4_LI_MODE_ITABLE;
3284 ret = 0;
3285 }
3286 }
3287 return ret;
3288 }
3289
3290 for (; group < ngroups; group++) {
3291 gdp = ext4_get_group_desc(sb, group, NULL);
3292 if (!gdp) {
3293 ret = 1;
3294 break;
3295 }
3296
3297 if (!(gdp->bg_flags & cpu_to_le16(EXT4_BG_INODE_ZEROED)))
3298 break;
3299 }
3300
3301 if (group >= ngroups)
3302 ret = 1;
3303
3304 if (!ret) {
3305 timeout = jiffies;
3306 ret = ext4_init_inode_table(sb, group,
3307 elr->lr_timeout ? 0 : 1);
3308 trace_ext4_lazy_itable_init(sb, group);
3309 if (elr->lr_timeout == 0) {
3310 timeout = (jiffies - timeout) *
3311 EXT4_SB(elr->lr_super)->s_li_wait_mult;
3312 elr->lr_timeout = timeout;
3313 }
3314 elr->lr_next_sched = jiffies + elr->lr_timeout;
3315 elr->lr_next_group = group + 1;
3316 }
3317 return ret;
3318}
3319
3320
3321
3322
3323
3324static void ext4_remove_li_request(struct ext4_li_request *elr)
3325{
3326 if (!elr)
3327 return;
3328
3329 list_del(&elr->lr_request);
3330 EXT4_SB(elr->lr_super)->s_li_request = NULL;
3331 kfree(elr);
3332}
3333
3334static void ext4_unregister_li_request(struct super_block *sb)
3335{
3336 mutex_lock(&ext4_li_mtx);
3337 if (!ext4_li_info) {
3338 mutex_unlock(&ext4_li_mtx);
3339 return;
3340 }
3341
3342 mutex_lock(&ext4_li_info->li_list_mtx);
3343 ext4_remove_li_request(EXT4_SB(sb)->s_li_request);
3344 mutex_unlock(&ext4_li_info->li_list_mtx);
3345 mutex_unlock(&ext4_li_mtx);
3346}
3347
3348static struct task_struct *ext4_lazyinit_task;
3349
3350
3351
3352
3353
3354
3355
3356
3357
3358
3359static int ext4_lazyinit_thread(void *arg)
3360{
3361 struct ext4_lazy_init *eli = (struct ext4_lazy_init *)arg;
3362 struct list_head *pos, *n;
3363 struct ext4_li_request *elr;
3364 unsigned long next_wakeup, cur;
3365
3366 BUG_ON(NULL == eli);
3367
3368cont_thread:
3369 while (true) {
3370 next_wakeup = MAX_JIFFY_OFFSET;
3371
3372 mutex_lock(&eli->li_list_mtx);
3373 if (list_empty(&eli->li_request_list)) {
3374 mutex_unlock(&eli->li_list_mtx);
3375 goto exit_thread;
3376 }
3377 list_for_each_safe(pos, n, &eli->li_request_list) {
3378 int err = 0;
3379 int progress = 0;
3380 elr = list_entry(pos, struct ext4_li_request,
3381 lr_request);
3382
3383 if (time_before(jiffies, elr->lr_next_sched)) {
3384 if (time_before(elr->lr_next_sched, next_wakeup))
3385 next_wakeup = elr->lr_next_sched;
3386 continue;
3387 }
3388 if (down_read_trylock(&elr->lr_super->s_umount)) {
3389 if (sb_start_write_trylock(elr->lr_super)) {
3390 progress = 1;
3391
3392
3393
3394
3395
3396 mutex_unlock(&eli->li_list_mtx);
3397 err = ext4_run_li_request(elr);
3398 sb_end_write(elr->lr_super);
3399 mutex_lock(&eli->li_list_mtx);
3400 n = pos->next;
3401 }
3402 up_read((&elr->lr_super->s_umount));
3403 }
3404
3405 if (err) {
3406 ext4_remove_li_request(elr);
3407 continue;
3408 }
3409 if (!progress) {
3410 elr->lr_next_sched = jiffies +
3411 (prandom_u32()
3412 % (EXT4_DEF_LI_MAX_START_DELAY * HZ));
3413 }
3414 if (time_before(elr->lr_next_sched, next_wakeup))
3415 next_wakeup = elr->lr_next_sched;
3416 }
3417 mutex_unlock(&eli->li_list_mtx);
3418
3419 try_to_freeze();
3420
3421 cur = jiffies;
3422 if ((time_after_eq(cur, next_wakeup)) ||
3423 (MAX_JIFFY_OFFSET == next_wakeup)) {
3424 cond_resched();
3425 continue;
3426 }
3427
3428 schedule_timeout_interruptible(next_wakeup - cur);
3429
3430 if (kthread_should_stop()) {
3431 ext4_clear_request_list();
3432 goto exit_thread;
3433 }
3434 }
3435
3436exit_thread:
3437
3438
3439
3440
3441
3442
3443
3444
3445 mutex_lock(&ext4_li_mtx);
3446 mutex_lock(&eli->li_list_mtx);
3447 if (!list_empty(&eli->li_request_list)) {
3448 mutex_unlock(&eli->li_list_mtx);
3449 mutex_unlock(&ext4_li_mtx);
3450 goto cont_thread;
3451 }
3452 mutex_unlock(&eli->li_list_mtx);
3453 kfree(ext4_li_info);
3454 ext4_li_info = NULL;
3455 mutex_unlock(&ext4_li_mtx);
3456
3457 return 0;
3458}
3459
3460static void ext4_clear_request_list(void)
3461{
3462 struct list_head *pos, *n;
3463 struct ext4_li_request *elr;
3464
3465 mutex_lock(&ext4_li_info->li_list_mtx);
3466 list_for_each_safe(pos, n, &ext4_li_info->li_request_list) {
3467 elr = list_entry(pos, struct ext4_li_request,
3468 lr_request);
3469 ext4_remove_li_request(elr);
3470 }
3471 mutex_unlock(&ext4_li_info->li_list_mtx);
3472}
3473
3474static int ext4_run_lazyinit_thread(void)
3475{
3476 ext4_lazyinit_task = kthread_run(ext4_lazyinit_thread,
3477 ext4_li_info, "ext4lazyinit");
3478 if (IS_ERR(ext4_lazyinit_task)) {
3479 int err = PTR_ERR(ext4_lazyinit_task);
3480 ext4_clear_request_list();
3481 kfree(ext4_li_info);
3482 ext4_li_info = NULL;
3483 printk(KERN_CRIT "EXT4-fs: error %d creating inode table "
3484 "initialization thread\n",
3485 err);
3486 return err;
3487 }
3488 ext4_li_info->li_state |= EXT4_LAZYINIT_RUNNING;
3489 return 0;
3490}
3491
3492
3493
3494
3495
3496
3497
3498static ext4_group_t ext4_has_uninit_itable(struct super_block *sb)
3499{
3500 ext4_group_t group, ngroups = EXT4_SB(sb)->s_groups_count;
3501 struct ext4_group_desc *gdp = NULL;
3502
3503 if (!ext4_has_group_desc_csum(sb))
3504 return ngroups;
3505
3506 for (group = 0; group < ngroups; group++) {
3507 gdp = ext4_get_group_desc(sb, group, NULL);
3508 if (!gdp)
3509 continue;
3510
3511 if (!(gdp->bg_flags & cpu_to_le16(EXT4_BG_INODE_ZEROED)))
3512 break;
3513 }
3514
3515 return group;
3516}
3517
3518static int ext4_li_info_new(void)
3519{
3520 struct ext4_lazy_init *eli = NULL;
3521
3522 eli = kzalloc(sizeof(*eli), GFP_KERNEL);
3523 if (!eli)
3524 return -ENOMEM;
3525
3526 INIT_LIST_HEAD(&eli->li_request_list);
3527 mutex_init(&eli->li_list_mtx);
3528
3529 eli->li_state |= EXT4_LAZYINIT_QUIT;
3530
3531 ext4_li_info = eli;
3532
3533 return 0;
3534}
3535
3536static struct ext4_li_request *ext4_li_request_new(struct super_block *sb,
3537 ext4_group_t start)
3538{
3539 struct ext4_li_request *elr;
3540
3541 elr = kzalloc(sizeof(*elr), GFP_KERNEL);
3542 if (!elr)
3543 return NULL;
3544
3545 elr->lr_super = sb;
3546 elr->lr_first_not_zeroed = start;
3547 if (test_opt(sb, NO_PREFETCH_BLOCK_BITMAPS)) {
3548 elr->lr_mode = EXT4_LI_MODE_ITABLE;
3549 elr->lr_next_group = start;
3550 } else {
3551 elr->lr_mode = EXT4_LI_MODE_PREFETCH_BBITMAP;
3552 }
3553
3554
3555
3556
3557
3558
3559 elr->lr_next_sched = jiffies + (prandom_u32() %
3560 (EXT4_DEF_LI_MAX_START_DELAY * HZ));
3561 return elr;
3562}
3563
3564int ext4_register_li_request(struct super_block *sb,
3565 ext4_group_t first_not_zeroed)
3566{
3567 struct ext4_sb_info *sbi = EXT4_SB(sb);
3568 struct ext4_li_request *elr = NULL;
3569 ext4_group_t ngroups = sbi->s_groups_count;
3570 int ret = 0;
3571
3572 mutex_lock(&ext4_li_mtx);
3573 if (sbi->s_li_request != NULL) {
3574
3575
3576
3577
3578 sbi->s_li_request->lr_timeout = 0;
3579 goto out;
3580 }
3581
3582 if (test_opt(sb, NO_PREFETCH_BLOCK_BITMAPS) &&
3583 (first_not_zeroed == ngroups || sb_rdonly(sb) ||
3584 !test_opt(sb, INIT_INODE_TABLE)))
3585 goto out;
3586
3587 elr = ext4_li_request_new(sb, first_not_zeroed);
3588 if (!elr) {
3589 ret = -ENOMEM;
3590 goto out;
3591 }
3592
3593 if (NULL == ext4_li_info) {
3594 ret = ext4_li_info_new();
3595 if (ret)
3596 goto out;
3597 }
3598
3599 mutex_lock(&ext4_li_info->li_list_mtx);
3600 list_add(&elr->lr_request, &ext4_li_info->li_request_list);
3601 mutex_unlock(&ext4_li_info->li_list_mtx);
3602
3603 sbi->s_li_request = elr;
3604
3605
3606
3607
3608
3609 elr = NULL;
3610
3611 if (!(ext4_li_info->li_state & EXT4_LAZYINIT_RUNNING)) {
3612 ret = ext4_run_lazyinit_thread();
3613 if (ret)
3614 goto out;
3615 }
3616out:
3617 mutex_unlock(&ext4_li_mtx);
3618 if (ret)
3619 kfree(elr);
3620 return ret;
3621}
3622
3623
3624
3625
3626
3627static void ext4_destroy_lazyinit_thread(void)
3628{
3629
3630
3631
3632
3633 if (!ext4_li_info || !ext4_lazyinit_task)
3634 return;
3635
3636 kthread_stop(ext4_lazyinit_task);
3637}
3638
3639static int set_journal_csum_feature_set(struct super_block *sb)
3640{
3641 int ret = 1;
3642 int compat, incompat;
3643 struct ext4_sb_info *sbi = EXT4_SB(sb);
3644
3645 if (ext4_has_metadata_csum(sb)) {
3646
3647 compat = 0;
3648 incompat = JBD2_FEATURE_INCOMPAT_CSUM_V3;
3649 } else {
3650
3651 compat = JBD2_FEATURE_COMPAT_CHECKSUM;
3652 incompat = 0;
3653 }
3654
3655 jbd2_journal_clear_features(sbi->s_journal,
3656 JBD2_FEATURE_COMPAT_CHECKSUM, 0,
3657 JBD2_FEATURE_INCOMPAT_CSUM_V3 |
3658 JBD2_FEATURE_INCOMPAT_CSUM_V2);
3659 if (test_opt(sb, JOURNAL_ASYNC_COMMIT)) {
3660 ret = jbd2_journal_set_features(sbi->s_journal,
3661 compat, 0,
3662 JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT |
3663 incompat);
3664 } else if (test_opt(sb, JOURNAL_CHECKSUM)) {
3665 ret = jbd2_journal_set_features(sbi->s_journal,
3666 compat, 0,
3667 incompat);
3668 jbd2_journal_clear_features(sbi->s_journal, 0, 0,
3669 JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT);
3670 } else {
3671 jbd2_journal_clear_features(sbi->s_journal, 0, 0,
3672 JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT);
3673 }
3674
3675 return ret;
3676}
3677
3678
3679
3680
3681
3682
3683
3684
3685
3686
3687
3688
3689
3690
3691
3692
3693static int count_overhead(struct super_block *sb, ext4_group_t grp,
3694 char *buf)
3695{
3696 struct ext4_sb_info *sbi = EXT4_SB(sb);
3697 struct ext4_group_desc *gdp;
3698 ext4_fsblk_t first_block, last_block, b;
3699 ext4_group_t i, ngroups = ext4_get_groups_count(sb);
3700 int s, j, count = 0;
3701
3702 if (!ext4_has_feature_bigalloc(sb))
3703 return (ext4_bg_has_super(sb, grp) + ext4_bg_num_gdb(sb, grp) +
3704 sbi->s_itb_per_group + 2);
3705
3706 first_block = le32_to_cpu(sbi->s_es->s_first_data_block) +
3707 (grp * EXT4_BLOCKS_PER_GROUP(sb));
3708 last_block = first_block + EXT4_BLOCKS_PER_GROUP(sb) - 1;
3709 for (i = 0; i < ngroups; i++) {
3710 gdp = ext4_get_group_desc(sb, i, NULL);
3711 b = ext4_block_bitmap(sb, gdp);
3712 if (b >= first_block && b <= last_block) {
3713 ext4_set_bit(EXT4_B2C(sbi, b - first_block), buf);
3714 count++;
3715 }
3716 b = ext4_inode_bitmap(sb, gdp);
3717 if (b >= first_block && b <= last_block) {
3718 ext4_set_bit(EXT4_B2C(sbi, b - first_block), buf);
3719 count++;
3720 }
3721 b = ext4_inode_table(sb, gdp);
3722 if (b >= first_block && b + sbi->s_itb_per_group <= last_block)
3723 for (j = 0; j < sbi->s_itb_per_group; j++, b++) {
3724 int c = EXT4_B2C(sbi, b - first_block);
3725 ext4_set_bit(c, buf);
3726 count++;
3727 }
3728 if (i != grp)
3729 continue;
3730 s = 0;
3731 if (ext4_bg_has_super(sb, grp)) {
3732 ext4_set_bit(s++, buf);
3733 count++;
3734 }
3735 j = ext4_bg_num_gdb(sb, grp);
3736 if (s + j > EXT4_BLOCKS_PER_GROUP(sb)) {
3737 ext4_error(sb, "Invalid number of block group "
3738 "descriptor blocks: %d", j);
3739 j = EXT4_BLOCKS_PER_GROUP(sb) - s;
3740 }
3741 count += j;
3742 for (; j > 0; j--)
3743 ext4_set_bit(EXT4_B2C(sbi, s++), buf);
3744 }
3745 if (!count)
3746 return 0;
3747 return EXT4_CLUSTERS_PER_GROUP(sb) -
3748 ext4_count_free(buf, EXT4_CLUSTERS_PER_GROUP(sb) / 8);
3749}
3750
3751
3752
3753
3754int ext4_calculate_overhead(struct super_block *sb)
3755{
3756 struct ext4_sb_info *sbi = EXT4_SB(sb);
3757 struct ext4_super_block *es = sbi->s_es;
3758 struct inode *j_inode;
3759 unsigned int j_blocks, j_inum = le32_to_cpu(es->s_journal_inum);
3760 ext4_group_t i, ngroups = ext4_get_groups_count(sb);
3761 ext4_fsblk_t overhead = 0;
3762 char *buf = (char *) get_zeroed_page(GFP_NOFS);
3763
3764 if (!buf)
3765 return -ENOMEM;
3766
3767
3768
3769
3770
3771
3772
3773
3774
3775
3776 overhead = EXT4_B2C(sbi, le32_to_cpu(es->s_first_data_block));
3777
3778
3779
3780
3781 for (i = 0; i < ngroups; i++) {
3782 int blks;
3783
3784 blks = count_overhead(sb, i, buf);
3785 overhead += blks;
3786 if (blks)
3787 memset(buf, 0, PAGE_SIZE);
3788 cond_resched();
3789 }
3790
3791
3792
3793
3794
3795 if (sbi->s_journal && !sbi->s_journal_bdev)
3796 overhead += EXT4_NUM_B2C(sbi, sbi->s_journal->j_total_len);
3797 else if (ext4_has_feature_journal(sb) && !sbi->s_journal && j_inum) {
3798
3799 j_inode = ext4_get_journal_inode(sb, j_inum);
3800 if (j_inode) {
3801 j_blocks = j_inode->i_size >> sb->s_blocksize_bits;
3802 overhead += EXT4_NUM_B2C(sbi, j_blocks);
3803 iput(j_inode);
3804 } else {
3805 ext4_msg(sb, KERN_ERR, "can't get journal size");
3806 }
3807 }
3808 sbi->s_overhead = overhead;
3809 smp_wmb();
3810 free_page((unsigned long) buf);
3811 return 0;
3812}
3813
3814static void ext4_set_resv_clusters(struct super_block *sb)
3815{
3816 ext4_fsblk_t resv_clusters;
3817 struct ext4_sb_info *sbi = EXT4_SB(sb);
3818
3819
3820
3821
3822
3823
3824
3825 if (!ext4_has_feature_extents(sb))
3826 return;
3827
3828
3829
3830
3831
3832
3833
3834
3835 resv_clusters = (ext4_blocks_count(sbi->s_es) >>
3836 sbi->s_cluster_bits);
3837
3838 do_div(resv_clusters, 50);
3839 resv_clusters = min_t(ext4_fsblk_t, resv_clusters, 4096);
3840
3841 atomic64_set(&sbi->s_resv_clusters, resv_clusters);
3842}
3843
3844static const char *ext4_quota_mode(struct super_block *sb)
3845{
3846#ifdef CONFIG_QUOTA
3847 if (!ext4_quota_capable(sb))
3848 return "none";
3849
3850 if (EXT4_SB(sb)->s_journal && ext4_is_quota_journalled(sb))
3851 return "journalled";
3852 else
3853 return "writeback";
3854#else
3855 return "disabled";
3856#endif
3857}
3858
3859static void ext4_setup_csum_trigger(struct super_block *sb,
3860 enum ext4_journal_trigger_type type,
3861 void (*trigger)(
3862 struct jbd2_buffer_trigger_type *type,
3863 struct buffer_head *bh,
3864 void *mapped_data,
3865 size_t size))
3866{
3867 struct ext4_sb_info *sbi = EXT4_SB(sb);
3868
3869 sbi->s_journal_triggers[type].sb = sb;
3870 sbi->s_journal_triggers[type].tr_triggers.t_frozen = trigger;
3871}
3872
3873static int ext4_fill_super(struct super_block *sb, void *data, int silent)
3874{
3875 struct dax_device *dax_dev = fs_dax_get_by_bdev(sb->s_bdev);
3876 char *orig_data = kstrdup(data, GFP_KERNEL);
3877 struct buffer_head *bh, **group_desc;
3878 struct ext4_super_block *es = NULL;
3879 struct ext4_sb_info *sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
3880 struct flex_groups **flex_groups;
3881 ext4_fsblk_t block;
3882 ext4_fsblk_t sb_block = get_sb_block(&data);
3883 ext4_fsblk_t logical_sb_block;
3884 unsigned long offset = 0;
3885 unsigned long def_mount_opts;
3886 struct inode *root;
3887 const char *descr;
3888 int ret = -ENOMEM;
3889 int blocksize, clustersize;
3890 unsigned int db_count;
3891 unsigned int i;
3892 int needs_recovery, has_huge_files;
3893 __u64 blocks_count;
3894 int err = 0;
3895 ext4_group_t first_not_zeroed;
3896 struct ext4_parsed_options parsed_opts;
3897
3898
3899 parsed_opts.journal_ioprio = DEFAULT_JOURNAL_IOPRIO;
3900 parsed_opts.journal_devnum = 0;
3901 parsed_opts.mb_optimize_scan = DEFAULT_MB_OPTIMIZE_SCAN;
3902
3903 if ((data && !orig_data) || !sbi)
3904 goto out_free_base;
3905
3906 sbi->s_daxdev = dax_dev;
3907 sbi->s_blockgroup_lock =
3908 kzalloc(sizeof(struct blockgroup_lock), GFP_KERNEL);
3909 if (!sbi->s_blockgroup_lock)
3910 goto out_free_base;
3911
3912 sb->s_fs_info = sbi;
3913 sbi->s_sb = sb;
3914 sbi->s_inode_readahead_blks = EXT4_DEF_INODE_READAHEAD_BLKS;
3915 sbi->s_sb_block = sb_block;
3916 sbi->s_sectors_written_start =
3917 part_stat_read(sb->s_bdev, sectors[STAT_WRITE]);
3918
3919
3920 strreplace(sb->s_id, '/', '!');
3921
3922
3923 ret = -EINVAL;
3924 blocksize = sb_min_blocksize(sb, EXT4_MIN_BLOCK_SIZE);
3925 if (!blocksize) {
3926 ext4_msg(sb, KERN_ERR, "unable to set blocksize");
3927 goto out_fail;
3928 }
3929
3930
3931
3932
3933
3934 if (blocksize != EXT4_MIN_BLOCK_SIZE) {
3935 logical_sb_block = sb_block * EXT4_MIN_BLOCK_SIZE;
3936 offset = do_div(logical_sb_block, blocksize);
3937 } else {
3938 logical_sb_block = sb_block;
3939 }
3940
3941 bh = ext4_sb_bread_unmovable(sb, logical_sb_block);
3942 if (IS_ERR(bh)) {
3943 ext4_msg(sb, KERN_ERR, "unable to read superblock");
3944 ret = PTR_ERR(bh);
3945 goto out_fail;
3946 }
3947
3948
3949
3950
3951 es = (struct ext4_super_block *) (bh->b_data + offset);
3952 sbi->s_es = es;
3953 sb->s_magic = le16_to_cpu(es->s_magic);
3954 if (sb->s_magic != EXT4_SUPER_MAGIC)
3955 goto cantfind_ext4;
3956 sbi->s_kbytes_written = le64_to_cpu(es->s_kbytes_written);
3957
3958
3959 if (ext4_has_feature_metadata_csum(sb) &&
3960 ext4_has_feature_gdt_csum(sb))
3961 ext4_warning(sb, "metadata_csum and uninit_bg are "
3962 "redundant flags; please run fsck.");
3963
3964
3965 if (!ext4_verify_csum_type(sb, es)) {
3966 ext4_msg(sb, KERN_ERR, "VFS: Found ext4 filesystem with "
3967 "unknown checksum algorithm.");
3968 silent = 1;
3969 goto cantfind_ext4;
3970 }
3971 ext4_setup_csum_trigger(sb, EXT4_JTR_ORPHAN_FILE,
3972 ext4_orphan_file_block_trigger);
3973
3974
3975 sbi->s_chksum_driver = crypto_alloc_shash("crc32c", 0, 0);
3976 if (IS_ERR(sbi->s_chksum_driver)) {
3977 ext4_msg(sb, KERN_ERR, "Cannot load crc32c driver.");
3978 ret = PTR_ERR(sbi->s_chksum_driver);
3979 sbi->s_chksum_driver = NULL;
3980 goto failed_mount;
3981 }
3982
3983
3984 if (!ext4_superblock_csum_verify(sb, es)) {
3985 ext4_msg(sb, KERN_ERR, "VFS: Found ext4 filesystem with "
3986 "invalid superblock checksum. Run e2fsck?");
3987 silent = 1;
3988 ret = -EFSBADCRC;
3989 goto cantfind_ext4;
3990 }
3991
3992
3993 if (ext4_has_feature_csum_seed(sb))
3994 sbi->s_csum_seed = le32_to_cpu(es->s_checksum_seed);
3995 else if (ext4_has_metadata_csum(sb) || ext4_has_feature_ea_inode(sb))
3996 sbi->s_csum_seed = ext4_chksum(sbi, ~0, es->s_uuid,
3997 sizeof(es->s_uuid));
3998
3999
4000 def_mount_opts = le32_to_cpu(es->s_default_mount_opts);
4001 set_opt(sb, INIT_INODE_TABLE);
4002 if (def_mount_opts & EXT4_DEFM_DEBUG)
4003 set_opt(sb, DEBUG);
4004 if (def_mount_opts & EXT4_DEFM_BSDGROUPS)
4005 set_opt(sb, GRPID);
4006 if (def_mount_opts & EXT4_DEFM_UID16)
4007 set_opt(sb, NO_UID32);
4008
4009 set_opt(sb, XATTR_USER);
4010#ifdef CONFIG_EXT4_FS_POSIX_ACL
4011 set_opt(sb, POSIX_ACL);
4012#endif
4013 if (ext4_has_feature_fast_commit(sb))
4014 set_opt2(sb, JOURNAL_FAST_COMMIT);
4015
4016 if (ext4_has_metadata_csum(sb))
4017 set_opt(sb, JOURNAL_CHECKSUM);
4018
4019 if ((def_mount_opts & EXT4_DEFM_JMODE) == EXT4_DEFM_JMODE_DATA)
4020 set_opt(sb, JOURNAL_DATA);
4021 else if ((def_mount_opts & EXT4_DEFM_JMODE) == EXT4_DEFM_JMODE_ORDERED)
4022 set_opt(sb, ORDERED_DATA);
4023 else if ((def_mount_opts & EXT4_DEFM_JMODE) == EXT4_DEFM_JMODE_WBACK)
4024 set_opt(sb, WRITEBACK_DATA);
4025
4026 if (le16_to_cpu(sbi->s_es->s_errors) == EXT4_ERRORS_PANIC)
4027 set_opt(sb, ERRORS_PANIC);
4028 else if (le16_to_cpu(sbi->s_es->s_errors) == EXT4_ERRORS_CONTINUE)
4029 set_opt(sb, ERRORS_CONT);
4030 else
4031 set_opt(sb, ERRORS_RO);
4032
4033 set_opt(sb, BLOCK_VALIDITY);
4034 if (def_mount_opts & EXT4_DEFM_DISCARD)
4035 set_opt(sb, DISCARD);
4036
4037 sbi->s_resuid = make_kuid(&init_user_ns, le16_to_cpu(es->s_def_resuid));
4038 sbi->s_resgid = make_kgid(&init_user_ns, le16_to_cpu(es->s_def_resgid));
4039 sbi->s_commit_interval = JBD2_DEFAULT_MAX_COMMIT_AGE * HZ;
4040 sbi->s_min_batch_time = EXT4_DEF_MIN_BATCH_TIME;
4041 sbi->s_max_batch_time = EXT4_DEF_MAX_BATCH_TIME;
4042
4043 if ((def_mount_opts & EXT4_DEFM_NOBARRIER) == 0)
4044 set_opt(sb, BARRIER);
4045
4046
4047
4048
4049
4050 if (!IS_EXT3_SB(sb) && !IS_EXT2_SB(sb) &&
4051 ((def_mount_opts & EXT4_DEFM_NODELALLOC) == 0))
4052 set_opt(sb, DELALLOC);
4053
4054
4055
4056
4057
4058 sbi->s_li_wait_mult = EXT4_DEF_LI_WAIT_MULT;
4059
4060 if (le32_to_cpu(es->s_log_block_size) >
4061 (EXT4_MAX_BLOCK_LOG_SIZE - EXT4_MIN_BLOCK_LOG_SIZE)) {
4062 ext4_msg(sb, KERN_ERR,
4063 "Invalid log block size: %u",
4064 le32_to_cpu(es->s_log_block_size));
4065 goto failed_mount;
4066 }
4067 if (le32_to_cpu(es->s_log_cluster_size) >
4068 (EXT4_MAX_CLUSTER_LOG_SIZE - EXT4_MIN_BLOCK_LOG_SIZE)) {
4069 ext4_msg(sb, KERN_ERR,
4070 "Invalid log cluster size: %u",
4071 le32_to_cpu(es->s_log_cluster_size));
4072 goto failed_mount;
4073 }
4074
4075 blocksize = EXT4_MIN_BLOCK_SIZE << le32_to_cpu(es->s_log_block_size);
4076
4077 if (blocksize == PAGE_SIZE)
4078 set_opt(sb, DIOREAD_NOLOCK);
4079
4080 if (le32_to_cpu(es->s_rev_level) == EXT4_GOOD_OLD_REV) {
4081 sbi->s_inode_size = EXT4_GOOD_OLD_INODE_SIZE;
4082 sbi->s_first_ino = EXT4_GOOD_OLD_FIRST_INO;
4083 } else {
4084 sbi->s_inode_size = le16_to_cpu(es->s_inode_size);
4085 sbi->s_first_ino = le32_to_cpu(es->s_first_ino);
4086 if (sbi->s_first_ino < EXT4_GOOD_OLD_FIRST_INO) {
4087 ext4_msg(sb, KERN_ERR, "invalid first ino: %u",
4088 sbi->s_first_ino);
4089 goto failed_mount;
4090 }
4091 if ((sbi->s_inode_size < EXT4_GOOD_OLD_INODE_SIZE) ||
4092 (!is_power_of_2(sbi->s_inode_size)) ||
4093 (sbi->s_inode_size > blocksize)) {
4094 ext4_msg(sb, KERN_ERR,
4095 "unsupported inode size: %d",
4096 sbi->s_inode_size);
4097 ext4_msg(sb, KERN_ERR, "blocksize: %d", blocksize);
4098 goto failed_mount;
4099 }
4100
4101
4102
4103
4104
4105
4106 if (sbi->s_inode_size >= offsetof(struct ext4_inode, i_atime_extra) +
4107 sizeof(((struct ext4_inode *)0)->i_atime_extra)) {
4108 sb->s_time_gran = 1;
4109 sb->s_time_max = EXT4_EXTRA_TIMESTAMP_MAX;
4110 } else {
4111 sb->s_time_gran = NSEC_PER_SEC;
4112 sb->s_time_max = EXT4_NON_EXTRA_TIMESTAMP_MAX;
4113 }
4114 sb->s_time_min = EXT4_TIMESTAMP_MIN;
4115 }
4116 if (sbi->s_inode_size > EXT4_GOOD_OLD_INODE_SIZE) {
4117 sbi->s_want_extra_isize = sizeof(struct ext4_inode) -
4118 EXT4_GOOD_OLD_INODE_SIZE;
4119 if (ext4_has_feature_extra_isize(sb)) {
4120 unsigned v, max = (sbi->s_inode_size -
4121 EXT4_GOOD_OLD_INODE_SIZE);
4122
4123 v = le16_to_cpu(es->s_want_extra_isize);
4124 if (v > max) {
4125 ext4_msg(sb, KERN_ERR,
4126 "bad s_want_extra_isize: %d", v);
4127 goto failed_mount;
4128 }
4129 if (sbi->s_want_extra_isize < v)
4130 sbi->s_want_extra_isize = v;
4131
4132 v = le16_to_cpu(es->s_min_extra_isize);
4133 if (v > max) {
4134 ext4_msg(sb, KERN_ERR,
4135 "bad s_min_extra_isize: %d", v);
4136 goto failed_mount;
4137 }
4138 if (sbi->s_want_extra_isize < v)
4139 sbi->s_want_extra_isize = v;
4140 }
4141 }
4142
4143 if (sbi->s_es->s_mount_opts[0]) {
4144 char *s_mount_opts = kstrndup(sbi->s_es->s_mount_opts,
4145 sizeof(sbi->s_es->s_mount_opts),
4146 GFP_KERNEL);
4147 if (!s_mount_opts)
4148 goto failed_mount;
4149 if (!parse_options(s_mount_opts, sb, &parsed_opts, 0)) {
4150 ext4_msg(sb, KERN_WARNING,
4151 "failed to parse options in superblock: %s",
4152 s_mount_opts);
4153 }
4154 kfree(s_mount_opts);
4155 }
4156 sbi->s_def_mount_opt = sbi->s_mount_opt;
4157 if (!parse_options((char *) data, sb, &parsed_opts, 0))
4158 goto failed_mount;
4159
4160#ifdef CONFIG_UNICODE
4161 if (ext4_has_feature_casefold(sb) && !sb->s_encoding) {
4162 const struct ext4_sb_encodings *encoding_info;
4163 struct unicode_map *encoding;
4164 __u16 encoding_flags;
4165
4166 if (ext4_sb_read_encoding(es, &encoding_info,
4167 &encoding_flags)) {
4168 ext4_msg(sb, KERN_ERR,
4169 "Encoding requested by superblock is unknown");
4170 goto failed_mount;
4171 }
4172
4173 encoding = utf8_load(encoding_info->version);
4174 if (IS_ERR(encoding)) {
4175 ext4_msg(sb, KERN_ERR,
4176 "can't mount with superblock charset: %s-%s "
4177 "not supported by the kernel. flags: 0x%x.",
4178 encoding_info->name, encoding_info->version,
4179 encoding_flags);
4180 goto failed_mount;
4181 }
4182 ext4_msg(sb, KERN_INFO,"Using encoding defined by superblock: "
4183 "%s-%s with flags 0x%hx", encoding_info->name,
4184 encoding_info->version?:"\b", encoding_flags);
4185
4186 sb->s_encoding = encoding;
4187 sb->s_encoding_flags = encoding_flags;
4188 }
4189#endif
4190
4191 if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA) {
4192 printk_once(KERN_WARNING "EXT4-fs: Warning: mounting with data=journal disables delayed allocation, dioread_nolock, O_DIRECT and fast_commit support!\n");
4193
4194 clear_opt(sb, DIOREAD_NOLOCK);
4195 clear_opt2(sb, JOURNAL_FAST_COMMIT);
4196 if (test_opt2(sb, EXPLICIT_DELALLOC)) {
4197 ext4_msg(sb, KERN_ERR, "can't mount with "
4198 "both data=journal and delalloc");
4199 goto failed_mount;
4200 }
4201 if (test_opt(sb, DAX_ALWAYS)) {
4202 ext4_msg(sb, KERN_ERR, "can't mount with "
4203 "both data=journal and dax");
4204 goto failed_mount;
4205 }
4206 if (ext4_has_feature_encrypt(sb)) {
4207 ext4_msg(sb, KERN_WARNING,
4208 "encrypted files will use data=ordered "
4209 "instead of data journaling mode");
4210 }
4211 if (test_opt(sb, DELALLOC))
4212 clear_opt(sb, DELALLOC);
4213 } else {
4214 sb->s_iflags |= SB_I_CGROUPWB;
4215 }
4216
4217 sb->s_flags = (sb->s_flags & ~SB_POSIXACL) |
4218 (test_opt(sb, POSIX_ACL) ? SB_POSIXACL : 0);
4219
4220 if (le32_to_cpu(es->s_rev_level) == EXT4_GOOD_OLD_REV &&
4221 (ext4_has_compat_features(sb) ||
4222 ext4_has_ro_compat_features(sb) ||
4223 ext4_has_incompat_features(sb)))
4224 ext4_msg(sb, KERN_WARNING,
4225 "feature flags set on rev 0 fs, "
4226 "running e2fsck is recommended");
4227
4228 if (es->s_creator_os == cpu_to_le32(EXT4_OS_HURD)) {
4229 set_opt2(sb, HURD_COMPAT);
4230 if (ext4_has_feature_64bit(sb)) {
4231 ext4_msg(sb, KERN_ERR,
4232 "The Hurd can't support 64-bit file systems");
4233 goto failed_mount;
4234 }
4235
4236
4237
4238
4239
4240 if (ext4_has_feature_ea_inode(sb)) {
4241 ext4_msg(sb, KERN_ERR,
4242 "ea_inode feature is not supported for Hurd");
4243 goto failed_mount;
4244 }
4245 }
4246
4247 if (IS_EXT2_SB(sb)) {
4248 if (ext2_feature_set_ok(sb))
4249 ext4_msg(sb, KERN_INFO, "mounting ext2 file system "
4250 "using the ext4 subsystem");
4251 else {
4252
4253
4254
4255
4256 if (silent && ext4_feature_set_ok(sb, sb_rdonly(sb)))
4257 goto failed_mount;
4258 ext4_msg(sb, KERN_ERR, "couldn't mount as ext2 due "
4259 "to feature incompatibilities");
4260 goto failed_mount;
4261 }
4262 }
4263
4264 if (IS_EXT3_SB(sb)) {
4265 if (ext3_feature_set_ok(sb))
4266 ext4_msg(sb, KERN_INFO, "mounting ext3 file system "
4267 "using the ext4 subsystem");
4268 else {
4269
4270
4271
4272
4273 if (silent && ext4_feature_set_ok(sb, sb_rdonly(sb)))
4274 goto failed_mount;
4275 ext4_msg(sb, KERN_ERR, "couldn't mount as ext3 due "
4276 "to feature incompatibilities");
4277 goto failed_mount;
4278 }
4279 }
4280
4281
4282
4283
4284
4285
4286 if (!ext4_feature_set_ok(sb, (sb_rdonly(sb))))
4287 goto failed_mount;
4288
4289 if (le16_to_cpu(sbi->s_es->s_reserved_gdt_blocks) > (blocksize / 4)) {
4290 ext4_msg(sb, KERN_ERR,
4291 "Number of reserved GDT blocks insanely large: %d",
4292 le16_to_cpu(sbi->s_es->s_reserved_gdt_blocks));
4293 goto failed_mount;
4294 }
4295
4296 if (dax_supported(dax_dev, sb->s_bdev, blocksize, 0,
4297 bdev_nr_sectors(sb->s_bdev)))
4298 set_bit(EXT4_FLAGS_BDEV_IS_DAX, &sbi->s_ext4_flags);
4299
4300 if (sbi->s_mount_opt & EXT4_MOUNT_DAX_ALWAYS) {
4301 if (ext4_has_feature_inline_data(sb)) {
4302 ext4_msg(sb, KERN_ERR, "Cannot use DAX on a filesystem"
4303 " that may contain inline data");
4304 goto failed_mount;
4305 }
4306 if (!test_bit(EXT4_FLAGS_BDEV_IS_DAX, &sbi->s_ext4_flags)) {
4307 ext4_msg(sb, KERN_ERR,
4308 "DAX unsupported by block device.");
4309 goto failed_mount;
4310 }
4311 }
4312
4313 if (ext4_has_feature_encrypt(sb) && es->s_encryption_level) {
4314 ext4_msg(sb, KERN_ERR, "Unsupported encryption level %d",
4315 es->s_encryption_level);
4316 goto failed_mount;
4317 }
4318
4319 if (sb->s_blocksize != blocksize) {
4320
4321
4322
4323
4324
4325 brelse(bh);
4326
4327 if (!sb_set_blocksize(sb, blocksize)) {
4328 ext4_msg(sb, KERN_ERR, "bad block size %d",
4329 blocksize);
4330 bh = NULL;
4331 goto failed_mount;
4332 }
4333
4334 logical_sb_block = sb_block * EXT4_MIN_BLOCK_SIZE;
4335 offset = do_div(logical_sb_block, blocksize);
4336 bh = ext4_sb_bread_unmovable(sb, logical_sb_block);
4337 if (IS_ERR(bh)) {
4338 ext4_msg(sb, KERN_ERR,
4339 "Can't read superblock on 2nd try");
4340 ret = PTR_ERR(bh);
4341 bh = NULL;
4342 goto failed_mount;
4343 }
4344 es = (struct ext4_super_block *)(bh->b_data + offset);
4345 sbi->s_es = es;
4346 if (es->s_magic != cpu_to_le16(EXT4_SUPER_MAGIC)) {
4347 ext4_msg(sb, KERN_ERR,
4348 "Magic mismatch, very weird!");
4349 goto failed_mount;
4350 }
4351 }
4352
4353 has_huge_files = ext4_has_feature_huge_file(sb);
4354 sbi->s_bitmap_maxbytes = ext4_max_bitmap_size(sb->s_blocksize_bits,
4355 has_huge_files);
4356 sb->s_maxbytes = ext4_max_size(sb->s_blocksize_bits, has_huge_files);
4357
4358 sbi->s_desc_size = le16_to_cpu(es->s_desc_size);
4359 if (ext4_has_feature_64bit(sb)) {
4360 if (sbi->s_desc_size < EXT4_MIN_DESC_SIZE_64BIT ||
4361 sbi->s_desc_size > EXT4_MAX_DESC_SIZE ||
4362 !is_power_of_2(sbi->s_desc_size)) {
4363 ext4_msg(sb, KERN_ERR,
4364 "unsupported descriptor size %lu",
4365 sbi->s_desc_size);
4366 goto failed_mount;
4367 }
4368 } else
4369 sbi->s_desc_size = EXT4_MIN_DESC_SIZE;
4370
4371 sbi->s_blocks_per_group = le32_to_cpu(es->s_blocks_per_group);
4372 sbi->s_inodes_per_group = le32_to_cpu(es->s_inodes_per_group);
4373
4374 sbi->s_inodes_per_block = blocksize / EXT4_INODE_SIZE(sb);
4375 if (sbi->s_inodes_per_block == 0)
4376 goto cantfind_ext4;
4377 if (sbi->s_inodes_per_group < sbi->s_inodes_per_block ||
4378 sbi->s_inodes_per_group > blocksize * 8) {
4379 ext4_msg(sb, KERN_ERR, "invalid inodes per group: %lu\n",
4380 sbi->s_inodes_per_group);
4381 goto failed_mount;
4382 }
4383 sbi->s_itb_per_group = sbi->s_inodes_per_group /
4384 sbi->s_inodes_per_block;
4385 sbi->s_desc_per_block = blocksize / EXT4_DESC_SIZE(sb);
4386 sbi->s_sbh = bh;
4387 sbi->s_mount_state = le16_to_cpu(es->s_state);
4388 sbi->s_addr_per_block_bits = ilog2(EXT4_ADDR_PER_BLOCK(sb));
4389 sbi->s_desc_per_block_bits = ilog2(EXT4_DESC_PER_BLOCK(sb));
4390
4391 for (i = 0; i < 4; i++)
4392 sbi->s_hash_seed[i] = le32_to_cpu(es->s_hash_seed[i]);
4393 sbi->s_def_hash_version = es->s_def_hash_version;
4394 if (ext4_has_feature_dir_index(sb)) {
4395 i = le32_to_cpu(es->s_flags);
4396 if (i & EXT2_FLAGS_UNSIGNED_HASH)
4397 sbi->s_hash_unsigned = 3;
4398 else if ((i & EXT2_FLAGS_SIGNED_HASH) == 0) {
4399#ifdef __CHAR_UNSIGNED__
4400 if (!sb_rdonly(sb))
4401 es->s_flags |=
4402 cpu_to_le32(EXT2_FLAGS_UNSIGNED_HASH);
4403 sbi->s_hash_unsigned = 3;
4404#else
4405 if (!sb_rdonly(sb))
4406 es->s_flags |=
4407 cpu_to_le32(EXT2_FLAGS_SIGNED_HASH);
4408#endif
4409 }
4410 }
4411
4412
4413 clustersize = BLOCK_SIZE << le32_to_cpu(es->s_log_cluster_size);
4414 if (ext4_has_feature_bigalloc(sb)) {
4415 if (clustersize < blocksize) {
4416 ext4_msg(sb, KERN_ERR,
4417 "cluster size (%d) smaller than "
4418 "block size (%d)", clustersize, blocksize);
4419 goto failed_mount;
4420 }
4421 sbi->s_cluster_bits = le32_to_cpu(es->s_log_cluster_size) -
4422 le32_to_cpu(es->s_log_block_size);
4423 sbi->s_clusters_per_group =
4424 le32_to_cpu(es->s_clusters_per_group);
4425 if (sbi->s_clusters_per_group > blocksize * 8) {
4426 ext4_msg(sb, KERN_ERR,
4427 "#clusters per group too big: %lu",
4428 sbi->s_clusters_per_group);
4429 goto failed_mount;
4430 }
4431 if (sbi->s_blocks_per_group !=
4432 (sbi->s_clusters_per_group * (clustersize / blocksize))) {
4433 ext4_msg(sb, KERN_ERR, "blocks per group (%lu) and "
4434 "clusters per group (%lu) inconsistent",
4435 sbi->s_blocks_per_group,
4436 sbi->s_clusters_per_group);
4437 goto failed_mount;
4438 }
4439 } else {
4440 if (clustersize != blocksize) {
4441 ext4_msg(sb, KERN_ERR,
4442 "fragment/cluster size (%d) != "
4443 "block size (%d)", clustersize, blocksize);
4444 goto failed_mount;
4445 }
4446 if (sbi->s_blocks_per_group > blocksize * 8) {
4447 ext4_msg(sb, KERN_ERR,
4448 "#blocks per group too big: %lu",
4449 sbi->s_blocks_per_group);
4450 goto failed_mount;
4451 }
4452 sbi->s_clusters_per_group = sbi->s_blocks_per_group;
4453 sbi->s_cluster_bits = 0;
4454 }
4455 sbi->s_cluster_ratio = clustersize / blocksize;
4456
4457
4458 if (sbi->s_blocks_per_group == clustersize << 3)
4459 set_opt2(sb, STD_GROUP_SIZE);
4460
4461
4462
4463
4464
4465 err = generic_check_addressable(sb->s_blocksize_bits,
4466 ext4_blocks_count(es));
4467 if (err) {
4468 ext4_msg(sb, KERN_ERR, "filesystem"
4469 " too large to mount safely on this system");
4470 goto failed_mount;
4471 }
4472
4473 if (EXT4_BLOCKS_PER_GROUP(sb) == 0)
4474 goto cantfind_ext4;
4475
4476
4477 blocks_count = sb->s_bdev->bd_inode->i_size >> sb->s_blocksize_bits;
4478 if (blocks_count && ext4_blocks_count(es) > blocks_count) {
4479 ext4_msg(sb, KERN_WARNING, "bad geometry: block count %llu "
4480 "exceeds size of device (%llu blocks)",
4481 ext4_blocks_count(es), blocks_count);
4482 goto failed_mount;
4483 }
4484
4485
4486
4487
4488
4489 if (le32_to_cpu(es->s_first_data_block) >= ext4_blocks_count(es)) {
4490 ext4_msg(sb, KERN_WARNING, "bad geometry: first data "
4491 "block %u is beyond end of filesystem (%llu)",
4492 le32_to_cpu(es->s_first_data_block),
4493 ext4_blocks_count(es));
4494 goto failed_mount;
4495 }
4496 if ((es->s_first_data_block == 0) && (es->s_log_block_size == 0) &&
4497 (sbi->s_cluster_ratio == 1)) {
4498 ext4_msg(sb, KERN_WARNING, "bad geometry: first data "
4499 "block is 0 with a 1k block and cluster size");
4500 goto failed_mount;
4501 }
4502
4503 blocks_count = (ext4_blocks_count(es) -
4504 le32_to_cpu(es->s_first_data_block) +
4505 EXT4_BLOCKS_PER_GROUP(sb) - 1);
4506 do_div(blocks_count, EXT4_BLOCKS_PER_GROUP(sb));
4507 if (blocks_count > ((uint64_t)1<<32) - EXT4_DESC_PER_BLOCK(sb)) {
4508 ext4_msg(sb, KERN_WARNING, "groups count too large: %llu "
4509 "(block count %llu, first data block %u, "
4510 "blocks per group %lu)", blocks_count,
4511 ext4_blocks_count(es),
4512 le32_to_cpu(es->s_first_data_block),
4513 EXT4_BLOCKS_PER_GROUP(sb));
4514 goto failed_mount;
4515 }
4516 sbi->s_groups_count = blocks_count;
4517 sbi->s_blockfile_groups = min_t(ext4_group_t, sbi->s_groups_count,
4518 (EXT4_MAX_BLOCK_FILE_PHYS / EXT4_BLOCKS_PER_GROUP(sb)));
4519 if (((u64)sbi->s_groups_count * sbi->s_inodes_per_group) !=
4520 le32_to_cpu(es->s_inodes_count)) {
4521 ext4_msg(sb, KERN_ERR, "inodes count not valid: %u vs %llu",
4522 le32_to_cpu(es->s_inodes_count),
4523 ((u64)sbi->s_groups_count * sbi->s_inodes_per_group));
4524 ret = -EINVAL;
4525 goto failed_mount;
4526 }
4527 db_count = (sbi->s_groups_count + EXT4_DESC_PER_BLOCK(sb) - 1) /
4528 EXT4_DESC_PER_BLOCK(sb);
4529 if (ext4_has_feature_meta_bg(sb)) {
4530 if (le32_to_cpu(es->s_first_meta_bg) > db_count) {
4531 ext4_msg(sb, KERN_WARNING,
4532 "first meta block group too large: %u "
4533 "(group descriptor block count %u)",
4534 le32_to_cpu(es->s_first_meta_bg), db_count);
4535 goto failed_mount;
4536 }
4537 }
4538 rcu_assign_pointer(sbi->s_group_desc,
4539 kvmalloc_array(db_count,
4540 sizeof(struct buffer_head *),
4541 GFP_KERNEL));
4542 if (sbi->s_group_desc == NULL) {
4543 ext4_msg(sb, KERN_ERR, "not enough memory");
4544 ret = -ENOMEM;
4545 goto failed_mount;
4546 }
4547
4548 bgl_lock_init(sbi->s_blockgroup_lock);
4549
4550
4551 for (i = 0; i < db_count; i++) {
4552 block = descriptor_loc(sb, logical_sb_block, i);
4553 ext4_sb_breadahead_unmovable(sb, block);
4554 }
4555
4556 for (i = 0; i < db_count; i++) {
4557 struct buffer_head *bh;
4558
4559 block = descriptor_loc(sb, logical_sb_block, i);
4560 bh = ext4_sb_bread_unmovable(sb, block);
4561 if (IS_ERR(bh)) {
4562 ext4_msg(sb, KERN_ERR,
4563 "can't read group descriptor %d", i);
4564 db_count = i;
4565 ret = PTR_ERR(bh);
4566 goto failed_mount2;
4567 }
4568 rcu_read_lock();
4569 rcu_dereference(sbi->s_group_desc)[i] = bh;
4570 rcu_read_unlock();
4571 }
4572 sbi->s_gdb_count = db_count;
4573 if (!ext4_check_descriptors(sb, logical_sb_block, &first_not_zeroed)) {
4574 ext4_msg(sb, KERN_ERR, "group descriptors corrupted!");
4575 ret = -EFSCORRUPTED;
4576 goto failed_mount2;
4577 }
4578
4579 timer_setup(&sbi->s_err_report, print_daily_error_info, 0);
4580 spin_lock_init(&sbi->s_error_lock);
4581 INIT_WORK(&sbi->s_error_work, flush_stashed_error_work);
4582
4583
4584 if (ext4_es_register_shrinker(sbi))
4585 goto failed_mount3;
4586
4587 sbi->s_stripe = ext4_get_stripe_size(sbi);
4588 sbi->s_extent_max_zeroout_kb = 32;
4589
4590
4591
4592
4593 sb->s_op = &ext4_sops;
4594 sb->s_export_op = &ext4_export_ops;
4595 sb->s_xattr = ext4_xattr_handlers;
4596#ifdef CONFIG_FS_ENCRYPTION
4597 sb->s_cop = &ext4_cryptops;
4598#endif
4599#ifdef CONFIG_FS_VERITY
4600 sb->s_vop = &ext4_verityops;
4601#endif
4602#ifdef CONFIG_QUOTA
4603 sb->dq_op = &ext4_quota_operations;
4604 if (ext4_has_feature_quota(sb))
4605 sb->s_qcop = &dquot_quotactl_sysfile_ops;
4606 else
4607 sb->s_qcop = &ext4_qctl_operations;
4608 sb->s_quota_types = QTYPE_MASK_USR | QTYPE_MASK_GRP | QTYPE_MASK_PRJ;
4609#endif
4610 memcpy(&sb->s_uuid, es->s_uuid, sizeof(es->s_uuid));
4611
4612 INIT_LIST_HEAD(&sbi->s_orphan);
4613 mutex_init(&sbi->s_orphan_lock);
4614
4615
4616 atomic_set(&sbi->s_fc_subtid, 0);
4617 atomic_set(&sbi->s_fc_ineligible_updates, 0);
4618 INIT_LIST_HEAD(&sbi->s_fc_q[FC_Q_MAIN]);
4619 INIT_LIST_HEAD(&sbi->s_fc_q[FC_Q_STAGING]);
4620 INIT_LIST_HEAD(&sbi->s_fc_dentry_q[FC_Q_MAIN]);
4621 INIT_LIST_HEAD(&sbi->s_fc_dentry_q[FC_Q_STAGING]);
4622 sbi->s_fc_bytes = 0;
4623 ext4_clear_mount_flag(sb, EXT4_MF_FC_INELIGIBLE);
4624 ext4_clear_mount_flag(sb, EXT4_MF_FC_COMMITTING);
4625 spin_lock_init(&sbi->s_fc_lock);
4626 memset(&sbi->s_fc_stats, 0, sizeof(sbi->s_fc_stats));
4627 sbi->s_fc_replay_state.fc_regions = NULL;
4628 sbi->s_fc_replay_state.fc_regions_size = 0;
4629 sbi->s_fc_replay_state.fc_regions_used = 0;
4630 sbi->s_fc_replay_state.fc_regions_valid = 0;
4631 sbi->s_fc_replay_state.fc_modified_inodes = NULL;
4632 sbi->s_fc_replay_state.fc_modified_inodes_size = 0;
4633 sbi->s_fc_replay_state.fc_modified_inodes_used = 0;
4634
4635 sb->s_root = NULL;
4636
4637 needs_recovery = (es->s_last_orphan != 0 ||
4638 ext4_has_feature_orphan_present(sb) ||
4639 ext4_has_feature_journal_needs_recovery(sb));
4640
4641 if (ext4_has_feature_mmp(sb) && !sb_rdonly(sb))
4642 if (ext4_multi_mount_protect(sb, le64_to_cpu(es->s_mmp_block)))
4643 goto failed_mount3a;
4644
4645
4646
4647
4648
4649 if (!test_opt(sb, NOLOAD) && ext4_has_feature_journal(sb)) {
4650 err = ext4_load_journal(sb, es, parsed_opts.journal_devnum);
4651 if (err)
4652 goto failed_mount3a;
4653 } else if (test_opt(sb, NOLOAD) && !sb_rdonly(sb) &&
4654 ext4_has_feature_journal_needs_recovery(sb)) {
4655 ext4_msg(sb, KERN_ERR, "required journal recovery "
4656 "suppressed and not mounted read-only");
4657 goto failed_mount_wq;
4658 } else {
4659
4660 if (test_opt2(sb, EXPLICIT_JOURNAL_CHECKSUM)) {
4661 ext4_msg(sb, KERN_ERR, "can't mount with "
4662 "journal_checksum, fs mounted w/o journal");
4663 goto failed_mount_wq;
4664 }
4665 if (test_opt(sb, JOURNAL_ASYNC_COMMIT)) {
4666 ext4_msg(sb, KERN_ERR, "can't mount with "
4667 "journal_async_commit, fs mounted w/o journal");
4668 goto failed_mount_wq;
4669 }
4670 if (sbi->s_commit_interval != JBD2_DEFAULT_MAX_COMMIT_AGE*HZ) {
4671 ext4_msg(sb, KERN_ERR, "can't mount with "
4672 "commit=%lu, fs mounted w/o journal",
4673 sbi->s_commit_interval / HZ);
4674 goto failed_mount_wq;
4675 }
4676 if (EXT4_MOUNT_DATA_FLAGS &
4677 (sbi->s_mount_opt ^ sbi->s_def_mount_opt)) {
4678 ext4_msg(sb, KERN_ERR, "can't mount with "
4679 "data=, fs mounted w/o journal");
4680 goto failed_mount_wq;
4681 }
4682 sbi->s_def_mount_opt &= ~EXT4_MOUNT_JOURNAL_CHECKSUM;
4683 clear_opt(sb, JOURNAL_CHECKSUM);
4684 clear_opt(sb, DATA_FLAGS);
4685 clear_opt2(sb, JOURNAL_FAST_COMMIT);
4686 sbi->s_journal = NULL;
4687 needs_recovery = 0;
4688 goto no_journal;
4689 }
4690
4691 if (ext4_has_feature_64bit(sb) &&
4692 !jbd2_journal_set_features(EXT4_SB(sb)->s_journal, 0, 0,
4693 JBD2_FEATURE_INCOMPAT_64BIT)) {
4694 ext4_msg(sb, KERN_ERR, "Failed to set 64-bit journal feature");
4695 goto failed_mount_wq;
4696 }
4697
4698 if (!set_journal_csum_feature_set(sb)) {
4699 ext4_msg(sb, KERN_ERR, "Failed to set journal checksum "
4700 "feature set");
4701 goto failed_mount_wq;
4702 }
4703
4704 if (test_opt2(sb, JOURNAL_FAST_COMMIT) &&
4705 !jbd2_journal_set_features(EXT4_SB(sb)->s_journal, 0, 0,
4706 JBD2_FEATURE_INCOMPAT_FAST_COMMIT)) {
4707 ext4_msg(sb, KERN_ERR,
4708 "Failed to set fast commit journal feature");
4709 goto failed_mount_wq;
4710 }
4711
4712
4713
4714 switch (test_opt(sb, DATA_FLAGS)) {
4715 case 0:
4716
4717
4718
4719
4720 if (jbd2_journal_check_available_features
4721 (sbi->s_journal, 0, 0, JBD2_FEATURE_INCOMPAT_REVOKE)) {
4722 set_opt(sb, ORDERED_DATA);
4723 sbi->s_def_mount_opt |= EXT4_MOUNT_ORDERED_DATA;
4724 } else {
4725 set_opt(sb, JOURNAL_DATA);
4726 sbi->s_def_mount_opt |= EXT4_MOUNT_JOURNAL_DATA;
4727 }
4728 break;
4729
4730 case EXT4_MOUNT_ORDERED_DATA:
4731 case EXT4_MOUNT_WRITEBACK_DATA:
4732 if (!jbd2_journal_check_available_features
4733 (sbi->s_journal, 0, 0, JBD2_FEATURE_INCOMPAT_REVOKE)) {
4734 ext4_msg(sb, KERN_ERR, "Journal does not support "
4735 "requested data journaling mode");
4736 goto failed_mount_wq;
4737 }
4738 break;
4739 default:
4740 break;
4741 }
4742
4743 if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_ORDERED_DATA &&
4744 test_opt(sb, JOURNAL_ASYNC_COMMIT)) {
4745 ext4_msg(sb, KERN_ERR, "can't mount with "
4746 "journal_async_commit in data=ordered mode");
4747 goto failed_mount_wq;
4748 }
4749
4750 set_task_ioprio(sbi->s_journal->j_task, parsed_opts.journal_ioprio);
4751
4752 sbi->s_journal->j_submit_inode_data_buffers =
4753 ext4_journal_submit_inode_data_buffers;
4754 sbi->s_journal->j_finish_inode_data_buffers =
4755 ext4_journal_finish_inode_data_buffers;
4756
4757no_journal:
4758 if (!test_opt(sb, NO_MBCACHE)) {
4759 sbi->s_ea_block_cache = ext4_xattr_create_cache();
4760 if (!sbi->s_ea_block_cache) {
4761 ext4_msg(sb, KERN_ERR,
4762 "Failed to create ea_block_cache");
4763 goto failed_mount_wq;
4764 }
4765
4766 if (ext4_has_feature_ea_inode(sb)) {
4767 sbi->s_ea_inode_cache = ext4_xattr_create_cache();
4768 if (!sbi->s_ea_inode_cache) {
4769 ext4_msg(sb, KERN_ERR,
4770 "Failed to create ea_inode_cache");
4771 goto failed_mount_wq;
4772 }
4773 }
4774 }
4775
4776 if (ext4_has_feature_verity(sb) && blocksize != PAGE_SIZE) {
4777 ext4_msg(sb, KERN_ERR, "Unsupported blocksize for fs-verity");
4778 goto failed_mount_wq;
4779 }
4780
4781 if (DUMMY_ENCRYPTION_ENABLED(sbi) && !sb_rdonly(sb) &&
4782 !ext4_has_feature_encrypt(sb)) {
4783 ext4_set_feature_encrypt(sb);
4784 ext4_commit_super(sb);
4785 }
4786
4787
4788
4789
4790
4791 if (es->s_overhead_clusters)
4792 sbi->s_overhead = le32_to_cpu(es->s_overhead_clusters);
4793 else {
4794 err = ext4_calculate_overhead(sb);
4795 if (err)
4796 goto failed_mount_wq;
4797 }
4798
4799
4800
4801
4802
4803 EXT4_SB(sb)->rsv_conversion_wq =
4804 alloc_workqueue("ext4-rsv-conversion", WQ_MEM_RECLAIM | WQ_UNBOUND, 1);
4805 if (!EXT4_SB(sb)->rsv_conversion_wq) {
4806 printk(KERN_ERR "EXT4-fs: failed to create workqueue\n");
4807 ret = -ENOMEM;
4808 goto failed_mount4;
4809 }
4810
4811
4812
4813
4814
4815
4816 root = ext4_iget(sb, EXT4_ROOT_INO, EXT4_IGET_SPECIAL);
4817 if (IS_ERR(root)) {
4818 ext4_msg(sb, KERN_ERR, "get root inode failed");
4819 ret = PTR_ERR(root);
4820 root = NULL;
4821 goto failed_mount4;
4822 }
4823 if (!S_ISDIR(root->i_mode) || !root->i_blocks || !root->i_size) {
4824 ext4_msg(sb, KERN_ERR, "corrupt root inode, run e2fsck");
4825 iput(root);
4826 goto failed_mount4;
4827 }
4828
4829 sb->s_root = d_make_root(root);
4830 if (!sb->s_root) {
4831 ext4_msg(sb, KERN_ERR, "get root dentry failed");
4832 ret = -ENOMEM;
4833 goto failed_mount4;
4834 }
4835
4836 ret = ext4_setup_super(sb, es, sb_rdonly(sb));
4837 if (ret == -EROFS) {
4838 sb->s_flags |= SB_RDONLY;
4839 ret = 0;
4840 } else if (ret)
4841 goto failed_mount4a;
4842
4843 ext4_set_resv_clusters(sb);
4844
4845 if (test_opt(sb, BLOCK_VALIDITY)) {
4846 err = ext4_setup_system_zone(sb);
4847 if (err) {
4848 ext4_msg(sb, KERN_ERR, "failed to initialize system "
4849 "zone (%d)", err);
4850 goto failed_mount4a;
4851 }
4852 }
4853 ext4_fc_replay_cleanup(sb);
4854
4855 ext4_ext_init(sb);
4856
4857
4858
4859
4860
4861
4862 if (parsed_opts.mb_optimize_scan == 1)
4863 set_opt2(sb, MB_OPTIMIZE_SCAN);
4864 else if (parsed_opts.mb_optimize_scan == 0)
4865 clear_opt2(sb, MB_OPTIMIZE_SCAN);
4866 else if (sbi->s_groups_count >= MB_DEFAULT_LINEAR_SCAN_THRESHOLD)
4867 set_opt2(sb, MB_OPTIMIZE_SCAN);
4868
4869 err = ext4_mb_init(sb);
4870 if (err) {
4871 ext4_msg(sb, KERN_ERR, "failed to initialize mballoc (%d)",
4872 err);
4873 goto failed_mount5;
4874 }
4875
4876
4877
4878
4879
4880 if (sbi->s_journal)
4881 sbi->s_journal->j_commit_callback =
4882 ext4_journal_commit_callback;
4883
4884 block = ext4_count_free_clusters(sb);
4885 ext4_free_blocks_count_set(sbi->s_es,
4886 EXT4_C2B(sbi, block));
4887 err = percpu_counter_init(&sbi->s_freeclusters_counter, block,
4888 GFP_KERNEL);
4889 if (!err) {
4890 unsigned long freei = ext4_count_free_inodes(sb);
4891 sbi->s_es->s_free_inodes_count = cpu_to_le32(freei);
4892 err = percpu_counter_init(&sbi->s_freeinodes_counter, freei,
4893 GFP_KERNEL);
4894 }
4895
4896
4897
4898
4899
4900
4901
4902 ext4_superblock_csum_set(sb);
4903 if (!err)
4904 err = percpu_counter_init(&sbi->s_dirs_counter,
4905 ext4_count_dirs(sb), GFP_KERNEL);
4906 if (!err)
4907 err = percpu_counter_init(&sbi->s_dirtyclusters_counter, 0,
4908 GFP_KERNEL);
4909 if (!err)
4910 err = percpu_counter_init(&sbi->s_sra_exceeded_retry_limit, 0,
4911 GFP_KERNEL);
4912 if (!err)
4913 err = percpu_init_rwsem(&sbi->s_writepages_rwsem);
4914
4915 if (err) {
4916 ext4_msg(sb, KERN_ERR, "insufficient memory");
4917 goto failed_mount6;
4918 }
4919
4920 if (ext4_has_feature_flex_bg(sb))
4921 if (!ext4_fill_flex_info(sb)) {
4922 ext4_msg(sb, KERN_ERR,
4923 "unable to initialize "
4924 "flex_bg meta info!");
4925 ret = -ENOMEM;
4926 goto failed_mount6;
4927 }
4928
4929 err = ext4_register_li_request(sb, first_not_zeroed);
4930 if (err)
4931 goto failed_mount6;
4932
4933 err = ext4_register_sysfs(sb);
4934 if (err)
4935 goto failed_mount7;
4936
4937 err = ext4_init_orphan_info(sb);
4938 if (err)
4939 goto failed_mount8;
4940#ifdef CONFIG_QUOTA
4941
4942 if (ext4_has_feature_quota(sb) && !sb_rdonly(sb)) {
4943 err = ext4_enable_quotas(sb);
4944 if (err)
4945 goto failed_mount9;
4946 }
4947#endif
4948
4949
4950
4951
4952
4953 spin_lock_init(&sbi->s_bdev_wb_lock);
4954 errseq_check_and_advance(&sb->s_bdev->bd_inode->i_mapping->wb_err,
4955 &sbi->s_bdev_wb_err);
4956 sb->s_bdev->bd_super = sb;
4957 EXT4_SB(sb)->s_mount_state |= EXT4_ORPHAN_FS;
4958 ext4_orphan_cleanup(sb, es);
4959 EXT4_SB(sb)->s_mount_state &= ~EXT4_ORPHAN_FS;
4960 if (needs_recovery) {
4961 ext4_msg(sb, KERN_INFO, "recovery complete");
4962 err = ext4_mark_recovery_complete(sb, es);
4963 if (err)
4964 goto failed_mount9;
4965 }
4966 if (EXT4_SB(sb)->s_journal) {
4967 if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA)
4968 descr = " journalled data mode";
4969 else if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_ORDERED_DATA)
4970 descr = " ordered data mode";
4971 else
4972 descr = " writeback data mode";
4973 } else
4974 descr = "out journal";
4975
4976 if (test_opt(sb, DISCARD)) {
4977 struct request_queue *q = bdev_get_queue(sb->s_bdev);
4978 if (!blk_queue_discard(q))
4979 ext4_msg(sb, KERN_WARNING,
4980 "mounting with \"discard\" option, but "
4981 "the device does not support discard");
4982 }
4983
4984 if (___ratelimit(&ext4_mount_msg_ratelimit, "EXT4-fs mount"))
4985 ext4_msg(sb, KERN_INFO, "mounted filesystem with%s. "
4986 "Opts: %.*s%s%s. Quota mode: %s.", descr,
4987 (int) sizeof(sbi->s_es->s_mount_opts),
4988 sbi->s_es->s_mount_opts,
4989 *sbi->s_es->s_mount_opts ? "; " : "", orig_data,
4990 ext4_quota_mode(sb));
4991
4992 if (es->s_error_count)
4993 mod_timer(&sbi->s_err_report, jiffies + 300*HZ);
4994
4995
4996 ratelimit_state_init(&sbi->s_err_ratelimit_state, 5 * HZ, 10);
4997 ratelimit_state_init(&sbi->s_warning_ratelimit_state, 5 * HZ, 10);
4998 ratelimit_state_init(&sbi->s_msg_ratelimit_state, 5 * HZ, 10);
4999 atomic_set(&sbi->s_warning_count, 0);
5000 atomic_set(&sbi->s_msg_count, 0);
5001
5002 kfree(orig_data);
5003 return 0;
5004
5005cantfind_ext4:
5006 if (!silent)
5007 ext4_msg(sb, KERN_ERR, "VFS: Can't find ext4 filesystem");
5008 goto failed_mount;
5009
5010failed_mount9:
5011 ext4_release_orphan_info(sb);
5012failed_mount8:
5013 ext4_unregister_sysfs(sb);
5014 kobject_put(&sbi->s_kobj);
5015failed_mount7:
5016 ext4_unregister_li_request(sb);
5017failed_mount6:
5018 ext4_mb_release(sb);
5019 rcu_read_lock();
5020 flex_groups = rcu_dereference(sbi->s_flex_groups);
5021 if (flex_groups) {
5022 for (i = 0; i < sbi->s_flex_groups_allocated; i++)
5023 kvfree(flex_groups[i]);
5024 kvfree(flex_groups);
5025 }
5026 rcu_read_unlock();
5027 percpu_counter_destroy(&sbi->s_freeclusters_counter);
5028 percpu_counter_destroy(&sbi->s_freeinodes_counter);
5029 percpu_counter_destroy(&sbi->s_dirs_counter);
5030 percpu_counter_destroy(&sbi->s_dirtyclusters_counter);
5031 percpu_counter_destroy(&sbi->s_sra_exceeded_retry_limit);
5032 percpu_free_rwsem(&sbi->s_writepages_rwsem);
5033failed_mount5:
5034 ext4_ext_release(sb);
5035 ext4_release_system_zone(sb);
5036failed_mount4a:
5037 dput(sb->s_root);
5038 sb->s_root = NULL;
5039failed_mount4:
5040 ext4_msg(sb, KERN_ERR, "mount failed");
5041 if (EXT4_SB(sb)->rsv_conversion_wq)
5042 destroy_workqueue(EXT4_SB(sb)->rsv_conversion_wq);
5043failed_mount_wq:
5044 ext4_xattr_destroy_cache(sbi->s_ea_inode_cache);
5045 sbi->s_ea_inode_cache = NULL;
5046
5047 ext4_xattr_destroy_cache(sbi->s_ea_block_cache);
5048 sbi->s_ea_block_cache = NULL;
5049
5050 if (sbi->s_journal) {
5051
5052 flush_work(&sbi->s_error_work);
5053 jbd2_journal_destroy(sbi->s_journal);
5054 sbi->s_journal = NULL;
5055 }
5056failed_mount3a:
5057 ext4_es_unregister_shrinker(sbi);
5058failed_mount3:
5059
5060 flush_work(&sbi->s_error_work);
5061 del_timer_sync(&sbi->s_err_report);
5062 ext4_stop_mmpd(sbi);
5063failed_mount2:
5064 rcu_read_lock();
5065 group_desc = rcu_dereference(sbi->s_group_desc);
5066 for (i = 0; i < db_count; i++)
5067 brelse(group_desc[i]);
5068 kvfree(group_desc);
5069 rcu_read_unlock();
5070failed_mount:
5071 if (sbi->s_chksum_driver)
5072 crypto_free_shash(sbi->s_chksum_driver);
5073
5074#ifdef CONFIG_UNICODE
5075 utf8_unload(sb->s_encoding);
5076#endif
5077
5078#ifdef CONFIG_QUOTA
5079 for (i = 0; i < EXT4_MAXQUOTAS; i++)
5080 kfree(get_qf_name(sb, sbi, i));
5081#endif
5082 fscrypt_free_dummy_policy(&sbi->s_dummy_enc_policy);
5083
5084 brelse(bh);
5085 ext4_blkdev_remove(sbi);
5086out_fail:
5087 sb->s_fs_info = NULL;
5088 kfree(sbi->s_blockgroup_lock);
5089out_free_base:
5090 kfree(sbi);
5091 kfree(orig_data);
5092 fs_put_dax(dax_dev);
5093 return err ? err : ret;
5094}
5095
5096
5097
5098
5099
5100
5101static void ext4_init_journal_params(struct super_block *sb, journal_t *journal)
5102{
5103 struct ext4_sb_info *sbi = EXT4_SB(sb);
5104
5105 journal->j_commit_interval = sbi->s_commit_interval;
5106 journal->j_min_batch_time = sbi->s_min_batch_time;
5107 journal->j_max_batch_time = sbi->s_max_batch_time;
5108 ext4_fc_init(sb, journal);
5109
5110 write_lock(&journal->j_state_lock);
5111 if (test_opt(sb, BARRIER))
5112 journal->j_flags |= JBD2_BARRIER;
5113 else
5114 journal->j_flags &= ~JBD2_BARRIER;
5115 if (test_opt(sb, DATA_ERR_ABORT))
5116 journal->j_flags |= JBD2_ABORT_ON_SYNCDATA_ERR;
5117 else
5118 journal->j_flags &= ~JBD2_ABORT_ON_SYNCDATA_ERR;
5119 write_unlock(&journal->j_state_lock);
5120}
5121
5122static struct inode *ext4_get_journal_inode(struct super_block *sb,
5123 unsigned int journal_inum)
5124{
5125 struct inode *journal_inode;
5126
5127
5128
5129
5130
5131
5132 journal_inode = ext4_iget(sb, journal_inum, EXT4_IGET_SPECIAL);
5133 if (IS_ERR(journal_inode)) {
5134 ext4_msg(sb, KERN_ERR, "no journal found");
5135 return NULL;
5136 }
5137 if (!journal_inode->i_nlink) {
5138 make_bad_inode(journal_inode);
5139 iput(journal_inode);
5140 ext4_msg(sb, KERN_ERR, "journal inode is deleted");
5141 return NULL;
5142 }
5143
5144 jbd_debug(2, "Journal inode found at %p: %lld bytes\n",
5145 journal_inode, journal_inode->i_size);
5146 if (!S_ISREG(journal_inode->i_mode)) {
5147 ext4_msg(sb, KERN_ERR, "invalid journal inode");
5148 iput(journal_inode);
5149 return NULL;
5150 }
5151 return journal_inode;
5152}
5153
5154static journal_t *ext4_get_journal(struct super_block *sb,
5155 unsigned int journal_inum)
5156{
5157 struct inode *journal_inode;
5158 journal_t *journal;
5159
5160 if (WARN_ON_ONCE(!ext4_has_feature_journal(sb)))
5161 return NULL;
5162
5163 journal_inode = ext4_get_journal_inode(sb, journal_inum);
5164 if (!journal_inode)
5165 return NULL;
5166
5167 journal = jbd2_journal_init_inode(journal_inode);
5168 if (!journal) {
5169 ext4_msg(sb, KERN_ERR, "Could not load journal inode");
5170 iput(journal_inode);
5171 return NULL;
5172 }
5173 journal->j_private = sb;
5174 ext4_init_journal_params(sb, journal);
5175 return journal;
5176}
5177
5178static journal_t *ext4_get_dev_journal(struct super_block *sb,
5179 dev_t j_dev)
5180{
5181 struct buffer_head *bh;
5182 journal_t *journal;
5183 ext4_fsblk_t start;
5184 ext4_fsblk_t len;
5185 int hblock, blocksize;
5186 ext4_fsblk_t sb_block;
5187 unsigned long offset;
5188 struct ext4_super_block *es;
5189 struct block_device *bdev;
5190
5191 if (WARN_ON_ONCE(!ext4_has_feature_journal(sb)))
5192 return NULL;
5193
5194 bdev = ext4_blkdev_get(j_dev, sb);
5195 if (bdev == NULL)
5196 return NULL;
5197
5198 blocksize = sb->s_blocksize;
5199 hblock = bdev_logical_block_size(bdev);
5200 if (blocksize < hblock) {
5201 ext4_msg(sb, KERN_ERR,
5202 "blocksize too small for journal device");
5203 goto out_bdev;
5204 }
5205
5206 sb_block = EXT4_MIN_BLOCK_SIZE / blocksize;
5207 offset = EXT4_MIN_BLOCK_SIZE % blocksize;
5208 set_blocksize(bdev, blocksize);
5209 if (!(bh = __bread(bdev, sb_block, blocksize))) {
5210 ext4_msg(sb, KERN_ERR, "couldn't read superblock of "
5211 "external journal");
5212 goto out_bdev;
5213 }
5214
5215 es = (struct ext4_super_block *) (bh->b_data + offset);
5216 if ((le16_to_cpu(es->s_magic) != EXT4_SUPER_MAGIC) ||
5217 !(le32_to_cpu(es->s_feature_incompat) &
5218 EXT4_FEATURE_INCOMPAT_JOURNAL_DEV)) {
5219 ext4_msg(sb, KERN_ERR, "external journal has "
5220 "bad superblock");
5221 brelse(bh);
5222 goto out_bdev;
5223 }
5224
5225 if ((le32_to_cpu(es->s_feature_ro_compat) &
5226 EXT4_FEATURE_RO_COMPAT_METADATA_CSUM) &&
5227 es->s_checksum != ext4_superblock_csum(sb, es)) {
5228 ext4_msg(sb, KERN_ERR, "external journal has "
5229 "corrupt superblock");
5230 brelse(bh);
5231 goto out_bdev;
5232 }
5233
5234 if (memcmp(EXT4_SB(sb)->s_es->s_journal_uuid, es->s_uuid, 16)) {
5235 ext4_msg(sb, KERN_ERR, "journal UUID does not match");
5236 brelse(bh);
5237 goto out_bdev;
5238 }
5239
5240 len = ext4_blocks_count(es);
5241 start = sb_block + 1;
5242 brelse(bh);
5243
5244 journal = jbd2_journal_init_dev(bdev, sb->s_bdev,
5245 start, len, blocksize);
5246 if (!journal) {
5247 ext4_msg(sb, KERN_ERR, "failed to create device journal");
5248 goto out_bdev;
5249 }
5250 journal->j_private = sb;
5251 if (ext4_read_bh_lock(journal->j_sb_buffer, REQ_META | REQ_PRIO, true)) {
5252 ext4_msg(sb, KERN_ERR, "I/O error on journal device");
5253 goto out_journal;
5254 }
5255 if (be32_to_cpu(journal->j_superblock->s_nr_users) != 1) {
5256 ext4_msg(sb, KERN_ERR, "External journal has more than one "
5257 "user (unsupported) - %d",
5258 be32_to_cpu(journal->j_superblock->s_nr_users));
5259 goto out_journal;
5260 }
5261 EXT4_SB(sb)->s_journal_bdev = bdev;
5262 ext4_init_journal_params(sb, journal);
5263 return journal;
5264
5265out_journal:
5266 jbd2_journal_destroy(journal);
5267out_bdev:
5268 ext4_blkdev_put(bdev);
5269 return NULL;
5270}
5271
5272static int ext4_load_journal(struct super_block *sb,
5273 struct ext4_super_block *es,
5274 unsigned long journal_devnum)
5275{
5276 journal_t *journal;
5277 unsigned int journal_inum = le32_to_cpu(es->s_journal_inum);
5278 dev_t journal_dev;
5279 int err = 0;
5280 int really_read_only;
5281 int journal_dev_ro;
5282
5283 if (WARN_ON_ONCE(!ext4_has_feature_journal(sb)))
5284 return -EFSCORRUPTED;
5285
5286 if (journal_devnum &&
5287 journal_devnum != le32_to_cpu(es->s_journal_dev)) {
5288 ext4_msg(sb, KERN_INFO, "external journal device major/minor "
5289 "numbers have changed");
5290 journal_dev = new_decode_dev(journal_devnum);
5291 } else
5292 journal_dev = new_decode_dev(le32_to_cpu(es->s_journal_dev));
5293
5294 if (journal_inum && journal_dev) {
5295 ext4_msg(sb, KERN_ERR,
5296 "filesystem has both journal inode and journal device!");
5297 return -EINVAL;
5298 }
5299
5300 if (journal_inum) {
5301 journal = ext4_get_journal(sb, journal_inum);
5302 if (!journal)
5303 return -EINVAL;
5304 } else {
5305 journal = ext4_get_dev_journal(sb, journal_dev);
5306 if (!journal)
5307 return -EINVAL;
5308 }
5309
5310 journal_dev_ro = bdev_read_only(journal->j_dev);
5311 really_read_only = bdev_read_only(sb->s_bdev) | journal_dev_ro;
5312
5313 if (journal_dev_ro && !sb_rdonly(sb)) {
5314 ext4_msg(sb, KERN_ERR,
5315 "journal device read-only, try mounting with '-o ro'");
5316 err = -EROFS;
5317 goto err_out;
5318 }
5319
5320
5321
5322
5323
5324
5325 if (ext4_has_feature_journal_needs_recovery(sb)) {
5326 if (sb_rdonly(sb)) {
5327 ext4_msg(sb, KERN_INFO, "INFO: recovery "
5328 "required on readonly filesystem");
5329 if (really_read_only) {
5330 ext4_msg(sb, KERN_ERR, "write access "
5331 "unavailable, cannot proceed "
5332 "(try mounting with noload)");
5333 err = -EROFS;
5334 goto err_out;
5335 }
5336 ext4_msg(sb, KERN_INFO, "write access will "
5337 "be enabled during recovery");
5338 }
5339 }
5340
5341 if (!(journal->j_flags & JBD2_BARRIER))
5342 ext4_msg(sb, KERN_INFO, "barriers disabled");
5343
5344 if (!ext4_has_feature_journal_needs_recovery(sb))
5345 err = jbd2_journal_wipe(journal, !really_read_only);
5346 if (!err) {
5347 char *save = kmalloc(EXT4_S_ERR_LEN, GFP_KERNEL);
5348 if (save)
5349 memcpy(save, ((char *) es) +
5350 EXT4_S_ERR_START, EXT4_S_ERR_LEN);
5351 err = jbd2_journal_load(journal);
5352 if (save)
5353 memcpy(((char *) es) + EXT4_S_ERR_START,
5354 save, EXT4_S_ERR_LEN);
5355 kfree(save);
5356 }
5357
5358 if (err) {
5359 ext4_msg(sb, KERN_ERR, "error loading journal");
5360 goto err_out;
5361 }
5362
5363 EXT4_SB(sb)->s_journal = journal;
5364 err = ext4_clear_journal_err(sb, es);
5365 if (err) {
5366 EXT4_SB(sb)->s_journal = NULL;
5367 jbd2_journal_destroy(journal);
5368 return err;
5369 }
5370
5371 if (!really_read_only && journal_devnum &&
5372 journal_devnum != le32_to_cpu(es->s_journal_dev)) {
5373 es->s_journal_dev = cpu_to_le32(journal_devnum);
5374
5375
5376 ext4_commit_super(sb);
5377 }
5378
5379 return 0;
5380
5381err_out:
5382 jbd2_journal_destroy(journal);
5383 return err;
5384}
5385
5386
5387static void ext4_update_super(struct super_block *sb)
5388{
5389 struct ext4_sb_info *sbi = EXT4_SB(sb);
5390 struct ext4_super_block *es = sbi->s_es;
5391 struct buffer_head *sbh = sbi->s_sbh;
5392
5393 lock_buffer(sbh);
5394
5395
5396
5397
5398
5399
5400
5401
5402
5403
5404 if (!(sb->s_flags & SB_RDONLY))
5405 ext4_update_tstamp(es, s_wtime);
5406 es->s_kbytes_written =
5407 cpu_to_le64(sbi->s_kbytes_written +
5408 ((part_stat_read(sb->s_bdev, sectors[STAT_WRITE]) -
5409 sbi->s_sectors_written_start) >> 1));
5410 if (percpu_counter_initialized(&sbi->s_freeclusters_counter))
5411 ext4_free_blocks_count_set(es,
5412 EXT4_C2B(sbi, percpu_counter_sum_positive(
5413 &sbi->s_freeclusters_counter)));
5414 if (percpu_counter_initialized(&sbi->s_freeinodes_counter))
5415 es->s_free_inodes_count =
5416 cpu_to_le32(percpu_counter_sum_positive(
5417 &sbi->s_freeinodes_counter));
5418
5419 spin_lock(&sbi->s_error_lock);
5420 if (sbi->s_add_error_count > 0) {
5421 es->s_state |= cpu_to_le16(EXT4_ERROR_FS);
5422 if (!es->s_first_error_time && !es->s_first_error_time_hi) {
5423 __ext4_update_tstamp(&es->s_first_error_time,
5424 &es->s_first_error_time_hi,
5425 sbi->s_first_error_time);
5426 strncpy(es->s_first_error_func, sbi->s_first_error_func,
5427 sizeof(es->s_first_error_func));
5428 es->s_first_error_line =
5429 cpu_to_le32(sbi->s_first_error_line);
5430 es->s_first_error_ino =
5431 cpu_to_le32(sbi->s_first_error_ino);
5432 es->s_first_error_block =
5433 cpu_to_le64(sbi->s_first_error_block);
5434 es->s_first_error_errcode =
5435 ext4_errno_to_code(sbi->s_first_error_code);
5436 }
5437 __ext4_update_tstamp(&es->s_last_error_time,
5438 &es->s_last_error_time_hi,
5439 sbi->s_last_error_time);
5440 strncpy(es->s_last_error_func, sbi->s_last_error_func,
5441 sizeof(es->s_last_error_func));
5442 es->s_last_error_line = cpu_to_le32(sbi->s_last_error_line);
5443 es->s_last_error_ino = cpu_to_le32(sbi->s_last_error_ino);
5444 es->s_last_error_block = cpu_to_le64(sbi->s_last_error_block);
5445 es->s_last_error_errcode =
5446 ext4_errno_to_code(sbi->s_last_error_code);
5447
5448
5449
5450
5451 if (!es->s_error_count)
5452 mod_timer(&sbi->s_err_report, jiffies + 24*60*60*HZ);
5453 le32_add_cpu(&es->s_error_count, sbi->s_add_error_count);
5454 sbi->s_add_error_count = 0;
5455 }
5456 spin_unlock(&sbi->s_error_lock);
5457
5458 ext4_superblock_csum_set(sb);
5459 unlock_buffer(sbh);
5460}
5461
5462static int ext4_commit_super(struct super_block *sb)
5463{
5464 struct buffer_head *sbh = EXT4_SB(sb)->s_sbh;
5465 int error = 0;
5466
5467 if (!sbh)
5468 return -EINVAL;
5469 if (block_device_ejected(sb))
5470 return -ENODEV;
5471
5472 ext4_update_super(sb);
5473
5474 if (buffer_write_io_error(sbh) || !buffer_uptodate(sbh)) {
5475
5476
5477
5478
5479
5480
5481
5482
5483 ext4_msg(sb, KERN_ERR, "previous I/O error to "
5484 "superblock detected");
5485 clear_buffer_write_io_error(sbh);
5486 set_buffer_uptodate(sbh);
5487 }
5488 BUFFER_TRACE(sbh, "marking dirty");
5489 mark_buffer_dirty(sbh);
5490 error = __sync_dirty_buffer(sbh,
5491 REQ_SYNC | (test_opt(sb, BARRIER) ? REQ_FUA : 0));
5492 if (buffer_write_io_error(sbh)) {
5493 ext4_msg(sb, KERN_ERR, "I/O error while writing "
5494 "superblock");
5495 clear_buffer_write_io_error(sbh);
5496 set_buffer_uptodate(sbh);
5497 }
5498 return error;
5499}
5500
5501
5502
5503
5504
5505
5506static int ext4_mark_recovery_complete(struct super_block *sb,
5507 struct ext4_super_block *es)
5508{
5509 int err;
5510 journal_t *journal = EXT4_SB(sb)->s_journal;
5511
5512 if (!ext4_has_feature_journal(sb)) {
5513 if (journal != NULL) {
5514 ext4_error(sb, "Journal got removed while the fs was "
5515 "mounted!");
5516 return -EFSCORRUPTED;
5517 }
5518 return 0;
5519 }
5520 jbd2_journal_lock_updates(journal);
5521 err = jbd2_journal_flush(journal, 0);
5522 if (err < 0)
5523 goto out;
5524
5525 if (sb_rdonly(sb) && (ext4_has_feature_journal_needs_recovery(sb) ||
5526 ext4_has_feature_orphan_present(sb))) {
5527 if (!ext4_orphan_file_empty(sb)) {
5528 ext4_error(sb, "Orphan file not empty on read-only fs.");
5529 err = -EFSCORRUPTED;
5530 goto out;
5531 }
5532 ext4_clear_feature_journal_needs_recovery(sb);
5533 ext4_clear_feature_orphan_present(sb);
5534 ext4_commit_super(sb);
5535 }
5536out:
5537 jbd2_journal_unlock_updates(journal);
5538 return err;
5539}
5540
5541
5542
5543
5544
5545
5546static int ext4_clear_journal_err(struct super_block *sb,
5547 struct ext4_super_block *es)
5548{
5549 journal_t *journal;
5550 int j_errno;
5551 const char *errstr;
5552
5553 if (!ext4_has_feature_journal(sb)) {
5554 ext4_error(sb, "Journal got removed while the fs was mounted!");
5555 return -EFSCORRUPTED;
5556 }
5557
5558 journal = EXT4_SB(sb)->s_journal;
5559
5560
5561
5562
5563
5564
5565 j_errno = jbd2_journal_errno(journal);
5566 if (j_errno) {
5567 char nbuf[16];
5568
5569 errstr = ext4_decode_error(sb, j_errno, nbuf);
5570 ext4_warning(sb, "Filesystem error recorded "
5571 "from previous mount: %s", errstr);
5572 ext4_warning(sb, "Marking fs in need of filesystem check.");
5573
5574 EXT4_SB(sb)->s_mount_state |= EXT4_ERROR_FS;
5575 es->s_state |= cpu_to_le16(EXT4_ERROR_FS);
5576 ext4_commit_super(sb);
5577
5578 jbd2_journal_clear_err(journal);
5579 jbd2_journal_update_sb_errno(journal);
5580 }
5581 return 0;
5582}
5583
5584
5585
5586
5587
5588int ext4_force_commit(struct super_block *sb)
5589{
5590 journal_t *journal;
5591
5592 if (sb_rdonly(sb))
5593 return 0;
5594
5595 journal = EXT4_SB(sb)->s_journal;
5596 return ext4_journal_force_commit(journal);
5597}
5598
5599static int ext4_sync_fs(struct super_block *sb, int wait)
5600{
5601 int ret = 0;
5602 tid_t target;
5603 bool needs_barrier = false;
5604 struct ext4_sb_info *sbi = EXT4_SB(sb);
5605
5606 if (unlikely(ext4_forced_shutdown(sbi)))
5607 return 0;
5608
5609 trace_ext4_sync_fs(sb, wait);
5610 flush_workqueue(sbi->rsv_conversion_wq);
5611
5612
5613
5614
5615 dquot_writeback_dquots(sb, -1);
5616
5617
5618
5619
5620
5621 if (sbi->s_journal) {
5622 target = jbd2_get_latest_transaction(sbi->s_journal);
5623 if (wait && sbi->s_journal->j_flags & JBD2_BARRIER &&
5624 !jbd2_trans_will_send_data_barrier(sbi->s_journal, target))
5625 needs_barrier = true;
5626
5627 if (jbd2_journal_start_commit(sbi->s_journal, &target)) {
5628 if (wait)
5629 ret = jbd2_log_wait_commit(sbi->s_journal,
5630 target);
5631 }
5632 } else if (wait && test_opt(sb, BARRIER))
5633 needs_barrier = true;
5634 if (needs_barrier) {
5635 int err;
5636 err = blkdev_issue_flush(sb->s_bdev);
5637 if (!ret)
5638 ret = err;
5639 }
5640
5641 return ret;
5642}
5643
5644
5645
5646
5647
5648
5649
5650
5651
5652static int ext4_freeze(struct super_block *sb)
5653{
5654 int error = 0;
5655 journal_t *journal;
5656
5657 if (sb_rdonly(sb))
5658 return 0;
5659
5660 journal = EXT4_SB(sb)->s_journal;
5661
5662 if (journal) {
5663
5664 jbd2_journal_lock_updates(journal);
5665
5666
5667
5668
5669
5670 error = jbd2_journal_flush(journal, 0);
5671 if (error < 0)
5672 goto out;
5673
5674
5675 ext4_clear_feature_journal_needs_recovery(sb);
5676 if (ext4_orphan_file_empty(sb))
5677 ext4_clear_feature_orphan_present(sb);
5678 }
5679
5680 error = ext4_commit_super(sb);
5681out:
5682 if (journal)
5683
5684 jbd2_journal_unlock_updates(journal);
5685 return error;
5686}
5687
5688
5689
5690
5691
5692static int ext4_unfreeze(struct super_block *sb)
5693{
5694 if (sb_rdonly(sb) || ext4_forced_shutdown(EXT4_SB(sb)))
5695 return 0;
5696
5697 if (EXT4_SB(sb)->s_journal) {
5698
5699 ext4_set_feature_journal_needs_recovery(sb);
5700 if (ext4_has_feature_orphan_file(sb))
5701 ext4_set_feature_orphan_present(sb);
5702 }
5703
5704 ext4_commit_super(sb);
5705 return 0;
5706}
5707
5708
5709
5710
5711struct ext4_mount_options {
5712 unsigned long s_mount_opt;
5713 unsigned long s_mount_opt2;
5714 kuid_t s_resuid;
5715 kgid_t s_resgid;
5716 unsigned long s_commit_interval;
5717 u32 s_min_batch_time, s_max_batch_time;
5718#ifdef CONFIG_QUOTA
5719 int s_jquota_fmt;
5720 char *s_qf_names[EXT4_MAXQUOTAS];
5721#endif
5722};
5723
5724static int ext4_remount(struct super_block *sb, int *flags, char *data)
5725{
5726 struct ext4_super_block *es;
5727 struct ext4_sb_info *sbi = EXT4_SB(sb);
5728 unsigned long old_sb_flags, vfs_flags;
5729 struct ext4_mount_options old_opts;
5730 int enable_quota = 0;
5731 ext4_group_t g;
5732 int err = 0;
5733#ifdef CONFIG_QUOTA
5734 int i, j;
5735 char *to_free[EXT4_MAXQUOTAS];
5736#endif
5737 char *orig_data = kstrdup(data, GFP_KERNEL);
5738 struct ext4_parsed_options parsed_opts;
5739
5740 parsed_opts.journal_ioprio = DEFAULT_JOURNAL_IOPRIO;
5741 parsed_opts.journal_devnum = 0;
5742
5743 if (data && !orig_data)
5744 return -ENOMEM;
5745
5746
5747 old_sb_flags = sb->s_flags;
5748 old_opts.s_mount_opt = sbi->s_mount_opt;
5749 old_opts.s_mount_opt2 = sbi->s_mount_opt2;
5750 old_opts.s_resuid = sbi->s_resuid;
5751 old_opts.s_resgid = sbi->s_resgid;
5752 old_opts.s_commit_interval = sbi->s_commit_interval;
5753 old_opts.s_min_batch_time = sbi->s_min_batch_time;
5754 old_opts.s_max_batch_time = sbi->s_max_batch_time;
5755#ifdef CONFIG_QUOTA
5756 old_opts.s_jquota_fmt = sbi->s_jquota_fmt;
5757 for (i = 0; i < EXT4_MAXQUOTAS; i++)
5758 if (sbi->s_qf_names[i]) {
5759 char *qf_name = get_qf_name(sb, sbi, i);
5760
5761 old_opts.s_qf_names[i] = kstrdup(qf_name, GFP_KERNEL);
5762 if (!old_opts.s_qf_names[i]) {
5763 for (j = 0; j < i; j++)
5764 kfree(old_opts.s_qf_names[j]);
5765 kfree(orig_data);
5766 return -ENOMEM;
5767 }
5768 } else
5769 old_opts.s_qf_names[i] = NULL;
5770#endif
5771 if (sbi->s_journal && sbi->s_journal->j_task->io_context)
5772 parsed_opts.journal_ioprio =
5773 sbi->s_journal->j_task->io_context->ioprio;
5774
5775
5776
5777
5778
5779
5780 vfs_flags = SB_LAZYTIME | SB_I_VERSION;
5781 sb->s_flags = (sb->s_flags & ~vfs_flags) | (*flags & vfs_flags);
5782
5783 if (!parse_options(data, sb, &parsed_opts, 1)) {
5784 err = -EINVAL;
5785 goto restore_opts;
5786 }
5787
5788 if ((old_opts.s_mount_opt & EXT4_MOUNT_JOURNAL_CHECKSUM) ^
5789 test_opt(sb, JOURNAL_CHECKSUM)) {
5790 ext4_msg(sb, KERN_ERR, "changing journal_checksum "
5791 "during remount not supported; ignoring");
5792 sbi->s_mount_opt ^= EXT4_MOUNT_JOURNAL_CHECKSUM;
5793 }
5794
5795 if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA) {
5796 if (test_opt2(sb, EXPLICIT_DELALLOC)) {
5797 ext4_msg(sb, KERN_ERR, "can't mount with "
5798 "both data=journal and delalloc");
5799 err = -EINVAL;
5800 goto restore_opts;
5801 }
5802 if (test_opt(sb, DIOREAD_NOLOCK)) {
5803 ext4_msg(sb, KERN_ERR, "can't mount with "
5804 "both data=journal and dioread_nolock");
5805 err = -EINVAL;
5806 goto restore_opts;
5807 }
5808 } else if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_ORDERED_DATA) {
5809 if (test_opt(sb, JOURNAL_ASYNC_COMMIT)) {
5810 ext4_msg(sb, KERN_ERR, "can't mount with "
5811 "journal_async_commit in data=ordered mode");
5812 err = -EINVAL;
5813 goto restore_opts;
5814 }
5815 }
5816
5817 if ((sbi->s_mount_opt ^ old_opts.s_mount_opt) & EXT4_MOUNT_NO_MBCACHE) {
5818 ext4_msg(sb, KERN_ERR, "can't enable nombcache during remount");
5819 err = -EINVAL;
5820 goto restore_opts;
5821 }
5822
5823 if (ext4_test_mount_flag(sb, EXT4_MF_FS_ABORTED))
5824 ext4_abort(sb, EXT4_ERR_ESHUTDOWN, "Abort forced by user");
5825
5826 sb->s_flags = (sb->s_flags & ~SB_POSIXACL) |
5827 (test_opt(sb, POSIX_ACL) ? SB_POSIXACL : 0);
5828
5829 es = sbi->s_es;
5830
5831 if (sbi->s_journal) {
5832 ext4_init_journal_params(sb, sbi->s_journal);
5833 set_task_ioprio(sbi->s_journal->j_task, parsed_opts.journal_ioprio);
5834 }
5835
5836
5837 flush_work(&sbi->s_error_work);
5838
5839 if ((bool)(*flags & SB_RDONLY) != sb_rdonly(sb)) {
5840 if (ext4_test_mount_flag(sb, EXT4_MF_FS_ABORTED)) {
5841 err = -EROFS;
5842 goto restore_opts;
5843 }
5844
5845 if (*flags & SB_RDONLY) {
5846 err = sync_filesystem(sb);
5847 if (err < 0)
5848 goto restore_opts;
5849 err = dquot_suspend(sb, -1);
5850 if (err < 0)
5851 goto restore_opts;
5852
5853
5854
5855
5856
5857 sb->s_flags |= SB_RDONLY;
5858
5859
5860
5861
5862
5863
5864 if (!(es->s_state & cpu_to_le16(EXT4_VALID_FS)) &&
5865 (sbi->s_mount_state & EXT4_VALID_FS))
5866 es->s_state = cpu_to_le16(sbi->s_mount_state);
5867
5868 if (sbi->s_journal) {
5869
5870
5871
5872
5873 ext4_mark_recovery_complete(sb, es);
5874 }
5875 } else {
5876
5877 if (ext4_has_feature_readonly(sb) ||
5878 !ext4_feature_set_ok(sb, 0)) {
5879 err = -EROFS;
5880 goto restore_opts;
5881 }
5882
5883
5884
5885
5886 for (g = 0; g < sbi->s_groups_count; g++) {
5887 struct ext4_group_desc *gdp =
5888 ext4_get_group_desc(sb, g, NULL);
5889
5890 if (!ext4_group_desc_csum_verify(sb, g, gdp)) {
5891 ext4_msg(sb, KERN_ERR,
5892 "ext4_remount: Checksum for group %u failed (%u!=%u)",
5893 g, le16_to_cpu(ext4_group_desc_csum(sb, g, gdp)),
5894 le16_to_cpu(gdp->bg_checksum));
5895 err = -EFSBADCRC;
5896 goto restore_opts;
5897 }
5898 }
5899
5900
5901
5902
5903
5904
5905 if (es->s_last_orphan || !ext4_orphan_file_empty(sb)) {
5906 ext4_msg(sb, KERN_WARNING, "Couldn't "
5907 "remount RDWR because of unprocessed "
5908 "orphan inode list. Please "
5909 "umount/remount instead");
5910 err = -EINVAL;
5911 goto restore_opts;
5912 }
5913
5914
5915
5916
5917
5918
5919
5920 if (sbi->s_journal) {
5921 err = ext4_clear_journal_err(sb, es);
5922 if (err)
5923 goto restore_opts;
5924 }
5925 sbi->s_mount_state = le16_to_cpu(es->s_state);
5926
5927 err = ext4_setup_super(sb, es, 0);
5928 if (err)
5929 goto restore_opts;
5930
5931 sb->s_flags &= ~SB_RDONLY;
5932 if (ext4_has_feature_mmp(sb))
5933 if (ext4_multi_mount_protect(sb,
5934 le64_to_cpu(es->s_mmp_block))) {
5935 err = -EROFS;
5936 goto restore_opts;
5937 }
5938 enable_quota = 1;
5939 }
5940 }
5941
5942
5943
5944
5945
5946 if (sb_rdonly(sb) || !test_opt(sb, INIT_INODE_TABLE))
5947 ext4_unregister_li_request(sb);
5948 else {
5949 ext4_group_t first_not_zeroed;
5950 first_not_zeroed = ext4_has_uninit_itable(sb);
5951 ext4_register_li_request(sb, first_not_zeroed);
5952 }
5953
5954
5955
5956
5957
5958
5959 if (test_opt(sb, BLOCK_VALIDITY) && !sbi->s_system_blks) {
5960 err = ext4_setup_system_zone(sb);
5961 if (err)
5962 goto restore_opts;
5963 }
5964
5965 if (sbi->s_journal == NULL && !(old_sb_flags & SB_RDONLY)) {
5966 err = ext4_commit_super(sb);
5967 if (err)
5968 goto restore_opts;
5969 }
5970
5971#ifdef CONFIG_QUOTA
5972
5973 for (i = 0; i < EXT4_MAXQUOTAS; i++)
5974 kfree(old_opts.s_qf_names[i]);
5975 if (enable_quota) {
5976 if (sb_any_quota_suspended(sb))
5977 dquot_resume(sb, -1);
5978 else if (ext4_has_feature_quota(sb)) {
5979 err = ext4_enable_quotas(sb);
5980 if (err)
5981 goto restore_opts;
5982 }
5983 }
5984#endif
5985 if (!test_opt(sb, BLOCK_VALIDITY) && sbi->s_system_blks)
5986 ext4_release_system_zone(sb);
5987
5988 if (!ext4_has_feature_mmp(sb) || sb_rdonly(sb))
5989 ext4_stop_mmpd(sbi);
5990
5991
5992
5993
5994
5995
5996 *flags = (*flags & ~vfs_flags) | (sb->s_flags & vfs_flags);
5997
5998 ext4_msg(sb, KERN_INFO, "re-mounted. Opts: %s. Quota mode: %s.",
5999 orig_data, ext4_quota_mode(sb));
6000 kfree(orig_data);
6001 return 0;
6002
6003restore_opts:
6004 sb->s_flags = old_sb_flags;
6005 sbi->s_mount_opt = old_opts.s_mount_opt;
6006 sbi->s_mount_opt2 = old_opts.s_mount_opt2;
6007 sbi->s_resuid = old_opts.s_resuid;
6008 sbi->s_resgid = old_opts.s_resgid;
6009 sbi->s_commit_interval = old_opts.s_commit_interval;
6010 sbi->s_min_batch_time = old_opts.s_min_batch_time;
6011 sbi->s_max_batch_time = old_opts.s_max_batch_time;
6012 if (!test_opt(sb, BLOCK_VALIDITY) && sbi->s_system_blks)
6013 ext4_release_system_zone(sb);
6014#ifdef CONFIG_QUOTA
6015 sbi->s_jquota_fmt = old_opts.s_jquota_fmt;
6016 for (i = 0; i < EXT4_MAXQUOTAS; i++) {
6017 to_free[i] = get_qf_name(sb, sbi, i);
6018 rcu_assign_pointer(sbi->s_qf_names[i], old_opts.s_qf_names[i]);
6019 }
6020 synchronize_rcu();
6021 for (i = 0; i < EXT4_MAXQUOTAS; i++)
6022 kfree(to_free[i]);
6023#endif
6024 if (!ext4_has_feature_mmp(sb) || sb_rdonly(sb))
6025 ext4_stop_mmpd(sbi);
6026 kfree(orig_data);
6027 return err;
6028}
6029
6030#ifdef CONFIG_QUOTA
6031static int ext4_statfs_project(struct super_block *sb,
6032 kprojid_t projid, struct kstatfs *buf)
6033{
6034 struct kqid qid;
6035 struct dquot *dquot;
6036 u64 limit;
6037 u64 curblock;
6038
6039 qid = make_kqid_projid(projid);
6040 dquot = dqget(sb, qid);
6041 if (IS_ERR(dquot))
6042 return PTR_ERR(dquot);
6043 spin_lock(&dquot->dq_dqb_lock);
6044
6045 limit = min_not_zero(dquot->dq_dqb.dqb_bsoftlimit,
6046 dquot->dq_dqb.dqb_bhardlimit);
6047 limit >>= sb->s_blocksize_bits;
6048
6049 if (limit && buf->f_blocks > limit) {
6050 curblock = (dquot->dq_dqb.dqb_curspace +
6051 dquot->dq_dqb.dqb_rsvspace) >> sb->s_blocksize_bits;
6052 buf->f_blocks = limit;
6053 buf->f_bfree = buf->f_bavail =
6054 (buf->f_blocks > curblock) ?
6055 (buf->f_blocks - curblock) : 0;
6056 }
6057
6058 limit = min_not_zero(dquot->dq_dqb.dqb_isoftlimit,
6059 dquot->dq_dqb.dqb_ihardlimit);
6060 if (limit && buf->f_files > limit) {
6061 buf->f_files = limit;
6062 buf->f_ffree =
6063 (buf->f_files > dquot->dq_dqb.dqb_curinodes) ?
6064 (buf->f_files - dquot->dq_dqb.dqb_curinodes) : 0;
6065 }
6066
6067 spin_unlock(&dquot->dq_dqb_lock);
6068 dqput(dquot);
6069 return 0;
6070}
6071#endif
6072
6073static int ext4_statfs(struct dentry *dentry, struct kstatfs *buf)
6074{
6075 struct super_block *sb = dentry->d_sb;
6076 struct ext4_sb_info *sbi = EXT4_SB(sb);
6077 struct ext4_super_block *es = sbi->s_es;
6078 ext4_fsblk_t overhead = 0, resv_blocks;
6079 s64 bfree;
6080 resv_blocks = EXT4_C2B(sbi, atomic64_read(&sbi->s_resv_clusters));
6081
6082 if (!test_opt(sb, MINIX_DF))
6083 overhead = sbi->s_overhead;
6084
6085 buf->f_type = EXT4_SUPER_MAGIC;
6086 buf->f_bsize = sb->s_blocksize;
6087 buf->f_blocks = ext4_blocks_count(es) - EXT4_C2B(sbi, overhead);
6088 bfree = percpu_counter_sum_positive(&sbi->s_freeclusters_counter) -
6089 percpu_counter_sum_positive(&sbi->s_dirtyclusters_counter);
6090
6091 buf->f_bfree = EXT4_C2B(sbi, max_t(s64, bfree, 0));
6092 buf->f_bavail = buf->f_bfree -
6093 (ext4_r_blocks_count(es) + resv_blocks);
6094 if (buf->f_bfree < (ext4_r_blocks_count(es) + resv_blocks))
6095 buf->f_bavail = 0;
6096 buf->f_files = le32_to_cpu(es->s_inodes_count);
6097 buf->f_ffree = percpu_counter_sum_positive(&sbi->s_freeinodes_counter);
6098 buf->f_namelen = EXT4_NAME_LEN;
6099 buf->f_fsid = uuid_to_fsid(es->s_uuid);
6100
6101#ifdef CONFIG_QUOTA
6102 if (ext4_test_inode_flag(dentry->d_inode, EXT4_INODE_PROJINHERIT) &&
6103 sb_has_quota_limits_enabled(sb, PRJQUOTA))
6104 ext4_statfs_project(sb, EXT4_I(dentry->d_inode)->i_projid, buf);
6105#endif
6106 return 0;
6107}
6108
6109
6110#ifdef CONFIG_QUOTA
6111
6112
6113
6114
6115
6116static inline struct inode *dquot_to_inode(struct dquot *dquot)
6117{
6118 return sb_dqopt(dquot->dq_sb)->files[dquot->dq_id.type];
6119}
6120
6121static int ext4_write_dquot(struct dquot *dquot)
6122{
6123 int ret, err;
6124 handle_t *handle;
6125 struct inode *inode;
6126
6127 inode = dquot_to_inode(dquot);
6128 handle = ext4_journal_start(inode, EXT4_HT_QUOTA,
6129 EXT4_QUOTA_TRANS_BLOCKS(dquot->dq_sb));
6130 if (IS_ERR(handle))
6131 return PTR_ERR(handle);
6132 ret = dquot_commit(dquot);
6133 err = ext4_journal_stop(handle);
6134 if (!ret)
6135 ret = err;
6136 return ret;
6137}
6138
6139static int ext4_acquire_dquot(struct dquot *dquot)
6140{
6141 int ret, err;
6142 handle_t *handle;
6143
6144 handle = ext4_journal_start(dquot_to_inode(dquot), EXT4_HT_QUOTA,
6145 EXT4_QUOTA_INIT_BLOCKS(dquot->dq_sb));
6146 if (IS_ERR(handle))
6147 return PTR_ERR(handle);
6148 ret = dquot_acquire(dquot);
6149 err = ext4_journal_stop(handle);
6150 if (!ret)
6151 ret = err;
6152 return ret;
6153}
6154
6155static int ext4_release_dquot(struct dquot *dquot)
6156{
6157 int ret, err;
6158 handle_t *handle;
6159
6160 handle = ext4_journal_start(dquot_to_inode(dquot), EXT4_HT_QUOTA,
6161 EXT4_QUOTA_DEL_BLOCKS(dquot->dq_sb));
6162 if (IS_ERR(handle)) {
6163
6164 dquot_release(dquot);
6165 return PTR_ERR(handle);
6166 }
6167 ret = dquot_release(dquot);
6168 err = ext4_journal_stop(handle);
6169 if (!ret)
6170 ret = err;
6171 return ret;
6172}
6173
6174static int ext4_mark_dquot_dirty(struct dquot *dquot)
6175{
6176 struct super_block *sb = dquot->dq_sb;
6177
6178 if (ext4_is_quota_journalled(sb)) {
6179 dquot_mark_dquot_dirty(dquot);
6180 return ext4_write_dquot(dquot);
6181 } else {
6182 return dquot_mark_dquot_dirty(dquot);
6183 }
6184}
6185
6186static int ext4_write_info(struct super_block *sb, int type)
6187{
6188 int ret, err;
6189 handle_t *handle;
6190
6191
6192 handle = ext4_journal_start(d_inode(sb->s_root), EXT4_HT_QUOTA, 2);
6193 if (IS_ERR(handle))
6194 return PTR_ERR(handle);
6195 ret = dquot_commit_info(sb, type);
6196 err = ext4_journal_stop(handle);
6197 if (!ret)
6198 ret = err;
6199 return ret;
6200}
6201
6202static void lockdep_set_quota_inode(struct inode *inode, int subclass)
6203{
6204 struct ext4_inode_info *ei = EXT4_I(inode);
6205
6206
6207
6208
6209
6210
6211
6212 (void) ei;
6213 lockdep_set_subclass(&ei->i_data_sem, subclass);
6214}
6215
6216
6217
6218
6219static int ext4_quota_on(struct super_block *sb, int type, int format_id,
6220 const struct path *path)
6221{
6222 int err;
6223
6224 if (!test_opt(sb, QUOTA))
6225 return -EINVAL;
6226
6227
6228 if (path->dentry->d_sb != sb)
6229 return -EXDEV;
6230
6231
6232 if (IS_NOQUOTA(d_inode(path->dentry)))
6233 return -EBUSY;
6234
6235
6236 if (EXT4_SB(sb)->s_qf_names[type]) {
6237
6238 if (path->dentry->d_parent != sb->s_root)
6239 ext4_msg(sb, KERN_WARNING,
6240 "Quota file not on filesystem root. "
6241 "Journaled quota will not work");
6242 sb_dqopt(sb)->flags |= DQUOT_NOLIST_DIRTY;
6243 } else {
6244
6245
6246
6247
6248 sb_dqopt(sb)->flags &= ~DQUOT_NOLIST_DIRTY;
6249 }
6250
6251
6252
6253
6254
6255 if (EXT4_SB(sb)->s_journal &&
6256 ext4_should_journal_data(d_inode(path->dentry))) {
6257
6258
6259
6260
6261 jbd2_journal_lock_updates(EXT4_SB(sb)->s_journal);
6262 err = jbd2_journal_flush(EXT4_SB(sb)->s_journal, 0);
6263 jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal);
6264 if (err)
6265 return err;
6266 }
6267
6268 lockdep_set_quota_inode(path->dentry->d_inode, I_DATA_SEM_QUOTA);
6269 err = dquot_quota_on(sb, type, format_id, path);
6270 if (err) {
6271 lockdep_set_quota_inode(path->dentry->d_inode,
6272 I_DATA_SEM_NORMAL);
6273 } else {
6274 struct inode *inode = d_inode(path->dentry);
6275 handle_t *handle;
6276
6277
6278
6279
6280
6281
6282 inode_lock(inode);
6283 handle = ext4_journal_start(inode, EXT4_HT_QUOTA, 1);
6284 if (IS_ERR(handle))
6285 goto unlock_inode;
6286 EXT4_I(inode)->i_flags |= EXT4_NOATIME_FL | EXT4_IMMUTABLE_FL;
6287 inode_set_flags(inode, S_NOATIME | S_IMMUTABLE,
6288 S_NOATIME | S_IMMUTABLE);
6289 err = ext4_mark_inode_dirty(handle, inode);
6290 ext4_journal_stop(handle);
6291 unlock_inode:
6292 inode_unlock(inode);
6293 }
6294 return err;
6295}
6296
6297static int ext4_quota_enable(struct super_block *sb, int type, int format_id,
6298 unsigned int flags)
6299{
6300 int err;
6301 struct inode *qf_inode;
6302 unsigned long qf_inums[EXT4_MAXQUOTAS] = {
6303 le32_to_cpu(EXT4_SB(sb)->s_es->s_usr_quota_inum),
6304 le32_to_cpu(EXT4_SB(sb)->s_es->s_grp_quota_inum),
6305 le32_to_cpu(EXT4_SB(sb)->s_es->s_prj_quota_inum)
6306 };
6307
6308 BUG_ON(!ext4_has_feature_quota(sb));
6309
6310 if (!qf_inums[type])
6311 return -EPERM;
6312
6313 qf_inode = ext4_iget(sb, qf_inums[type], EXT4_IGET_SPECIAL);
6314 if (IS_ERR(qf_inode)) {
6315 ext4_error(sb, "Bad quota inode # %lu", qf_inums[type]);
6316 return PTR_ERR(qf_inode);
6317 }
6318
6319
6320 qf_inode->i_flags |= S_NOQUOTA;
6321 lockdep_set_quota_inode(qf_inode, I_DATA_SEM_QUOTA);
6322 err = dquot_load_quota_inode(qf_inode, type, format_id, flags);
6323 if (err)
6324 lockdep_set_quota_inode(qf_inode, I_DATA_SEM_NORMAL);
6325 iput(qf_inode);
6326
6327 return err;
6328}
6329
6330
6331int ext4_enable_quotas(struct super_block *sb)
6332{
6333 int type, err = 0;
6334 unsigned long qf_inums[EXT4_MAXQUOTAS] = {
6335 le32_to_cpu(EXT4_SB(sb)->s_es->s_usr_quota_inum),
6336 le32_to_cpu(EXT4_SB(sb)->s_es->s_grp_quota_inum),
6337 le32_to_cpu(EXT4_SB(sb)->s_es->s_prj_quota_inum)
6338 };
6339 bool quota_mopt[EXT4_MAXQUOTAS] = {
6340 test_opt(sb, USRQUOTA),
6341 test_opt(sb, GRPQUOTA),
6342 test_opt(sb, PRJQUOTA),
6343 };
6344
6345 sb_dqopt(sb)->flags |= DQUOT_QUOTA_SYS_FILE | DQUOT_NOLIST_DIRTY;
6346 for (type = 0; type < EXT4_MAXQUOTAS; type++) {
6347 if (qf_inums[type]) {
6348 err = ext4_quota_enable(sb, type, QFMT_VFS_V1,
6349 DQUOT_USAGE_ENABLED |
6350 (quota_mopt[type] ? DQUOT_LIMITS_ENABLED : 0));
6351 if (err) {
6352 ext4_warning(sb,
6353 "Failed to enable quota tracking "
6354 "(type=%d, err=%d). Please run "
6355 "e2fsck to fix.", type, err);
6356 for (type--; type >= 0; type--)
6357 dquot_quota_off(sb, type);
6358
6359 return err;
6360 }
6361 }
6362 }
6363 return 0;
6364}
6365
6366static int ext4_quota_off(struct super_block *sb, int type)
6367{
6368 struct inode *inode = sb_dqopt(sb)->files[type];
6369 handle_t *handle;
6370 int err;
6371
6372
6373
6374 if (test_opt(sb, DELALLOC))
6375 sync_filesystem(sb);
6376
6377 if (!inode || !igrab(inode))
6378 goto out;
6379
6380 err = dquot_quota_off(sb, type);
6381 if (err || ext4_has_feature_quota(sb))
6382 goto out_put;
6383
6384 inode_lock(inode);
6385
6386
6387
6388
6389
6390 handle = ext4_journal_start(inode, EXT4_HT_QUOTA, 1);
6391 if (IS_ERR(handle)) {
6392 err = PTR_ERR(handle);
6393 goto out_unlock;
6394 }
6395 EXT4_I(inode)->i_flags &= ~(EXT4_NOATIME_FL | EXT4_IMMUTABLE_FL);
6396 inode_set_flags(inode, 0, S_NOATIME | S_IMMUTABLE);
6397 inode->i_mtime = inode->i_ctime = current_time(inode);
6398 err = ext4_mark_inode_dirty(handle, inode);
6399 ext4_journal_stop(handle);
6400out_unlock:
6401 inode_unlock(inode);
6402out_put:
6403 lockdep_set_quota_inode(inode, I_DATA_SEM_NORMAL);
6404 iput(inode);
6405 return err;
6406out:
6407 return dquot_quota_off(sb, type);
6408}
6409
6410
6411
6412
6413
6414static ssize_t ext4_quota_read(struct super_block *sb, int type, char *data,
6415 size_t len, loff_t off)
6416{
6417 struct inode *inode = sb_dqopt(sb)->files[type];
6418 ext4_lblk_t blk = off >> EXT4_BLOCK_SIZE_BITS(sb);
6419 int offset = off & (sb->s_blocksize - 1);
6420 int tocopy;
6421 size_t toread;
6422 struct buffer_head *bh;
6423 loff_t i_size = i_size_read(inode);
6424
6425 if (off > i_size)
6426 return 0;
6427 if (off+len > i_size)
6428 len = i_size-off;
6429 toread = len;
6430 while (toread > 0) {
6431 tocopy = sb->s_blocksize - offset < toread ?
6432 sb->s_blocksize - offset : toread;
6433 bh = ext4_bread(NULL, inode, blk, 0);
6434 if (IS_ERR(bh))
6435 return PTR_ERR(bh);
6436 if (!bh)
6437 memset(data, 0, tocopy);
6438 else
6439 memcpy(data, bh->b_data+offset, tocopy);
6440 brelse(bh);
6441 offset = 0;
6442 toread -= tocopy;
6443 data += tocopy;
6444 blk++;
6445 }
6446 return len;
6447}
6448
6449
6450
6451static ssize_t ext4_quota_write(struct super_block *sb, int type,
6452 const char *data, size_t len, loff_t off)
6453{
6454 struct inode *inode = sb_dqopt(sb)->files[type];
6455 ext4_lblk_t blk = off >> EXT4_BLOCK_SIZE_BITS(sb);
6456 int err = 0, err2 = 0, offset = off & (sb->s_blocksize - 1);
6457 int retries = 0;
6458 struct buffer_head *bh;
6459 handle_t *handle = journal_current_handle();
6460
6461 if (EXT4_SB(sb)->s_journal && !handle) {
6462 ext4_msg(sb, KERN_WARNING, "Quota write (off=%llu, len=%llu)"
6463 " cancelled because transaction is not started",
6464 (unsigned long long)off, (unsigned long long)len);
6465 return -EIO;
6466 }
6467
6468
6469
6470
6471 if (sb->s_blocksize - offset < len) {
6472 ext4_msg(sb, KERN_WARNING, "Quota write (off=%llu, len=%llu)"
6473 " cancelled because not block aligned",
6474 (unsigned long long)off, (unsigned long long)len);
6475 return -EIO;
6476 }
6477
6478 do {
6479 bh = ext4_bread(handle, inode, blk,
6480 EXT4_GET_BLOCKS_CREATE |
6481 EXT4_GET_BLOCKS_METADATA_NOFAIL);
6482 } while (PTR_ERR(bh) == -ENOSPC &&
6483 ext4_should_retry_alloc(inode->i_sb, &retries));
6484 if (IS_ERR(bh))
6485 return PTR_ERR(bh);
6486 if (!bh)
6487 goto out;
6488 BUFFER_TRACE(bh, "get write access");
6489 err = ext4_journal_get_write_access(handle, sb, bh, EXT4_JTR_NONE);
6490 if (err) {
6491 brelse(bh);
6492 return err;
6493 }
6494 lock_buffer(bh);
6495 memcpy(bh->b_data+offset, data, len);
6496 flush_dcache_page(bh->b_page);
6497 unlock_buffer(bh);
6498 err = ext4_handle_dirty_metadata(handle, NULL, bh);
6499 brelse(bh);
6500out:
6501 if (inode->i_size < off + len) {
6502 i_size_write(inode, off + len);
6503 EXT4_I(inode)->i_disksize = inode->i_size;
6504 err2 = ext4_mark_inode_dirty(handle, inode);
6505 if (unlikely(err2 && !err))
6506 err = err2;
6507 }
6508 return err ? err : len;
6509}
6510#endif
6511
6512static struct dentry *ext4_mount(struct file_system_type *fs_type, int flags,
6513 const char *dev_name, void *data)
6514{
6515 return mount_bdev(fs_type, flags, dev_name, data, ext4_fill_super);
6516}
6517
6518#if !defined(CONFIG_EXT2_FS) && !defined(CONFIG_EXT2_FS_MODULE) && defined(CONFIG_EXT4_USE_FOR_EXT2)
6519static inline void register_as_ext2(void)
6520{
6521 int err = register_filesystem(&ext2_fs_type);
6522 if (err)
6523 printk(KERN_WARNING
6524 "EXT4-fs: Unable to register as ext2 (%d)\n", err);
6525}
6526
6527static inline void unregister_as_ext2(void)
6528{
6529 unregister_filesystem(&ext2_fs_type);
6530}
6531
6532static inline int ext2_feature_set_ok(struct super_block *sb)
6533{
6534 if (ext4_has_unknown_ext2_incompat_features(sb))
6535 return 0;
6536 if (sb_rdonly(sb))
6537 return 1;
6538 if (ext4_has_unknown_ext2_ro_compat_features(sb))
6539 return 0;
6540 return 1;
6541}
6542#else
6543static inline void register_as_ext2(void) { }
6544static inline void unregister_as_ext2(void) { }
6545static inline int ext2_feature_set_ok(struct super_block *sb) { return 0; }
6546#endif
6547
6548static inline void register_as_ext3(void)
6549{
6550 int err = register_filesystem(&ext3_fs_type);
6551 if (err)
6552 printk(KERN_WARNING
6553 "EXT4-fs: Unable to register as ext3 (%d)\n", err);
6554}
6555
6556static inline void unregister_as_ext3(void)
6557{
6558 unregister_filesystem(&ext3_fs_type);
6559}
6560
6561static inline int ext3_feature_set_ok(struct super_block *sb)
6562{
6563 if (ext4_has_unknown_ext3_incompat_features(sb))
6564 return 0;
6565 if (!ext4_has_feature_journal(sb))
6566 return 0;
6567 if (sb_rdonly(sb))
6568 return 1;
6569 if (ext4_has_unknown_ext3_ro_compat_features(sb))
6570 return 0;
6571 return 1;
6572}
6573
6574static struct file_system_type ext4_fs_type = {
6575 .owner = THIS_MODULE,
6576 .name = "ext4",
6577 .mount = ext4_mount,
6578 .kill_sb = kill_block_super,
6579 .fs_flags = FS_REQUIRES_DEV | FS_ALLOW_IDMAP,
6580};
6581MODULE_ALIAS_FS("ext4");
6582
6583
6584wait_queue_head_t ext4__ioend_wq[EXT4_WQ_HASH_SZ];
6585
6586static int __init ext4_init_fs(void)
6587{
6588 int i, err;
6589
6590 ratelimit_state_init(&ext4_mount_msg_ratelimit, 30 * HZ, 64);
6591 ext4_li_info = NULL;
6592
6593
6594 ext4_check_flag_values();
6595
6596 for (i = 0; i < EXT4_WQ_HASH_SZ; i++)
6597 init_waitqueue_head(&ext4__ioend_wq[i]);
6598
6599 err = ext4_init_es();
6600 if (err)
6601 return err;
6602
6603 err = ext4_init_pending();
6604 if (err)
6605 goto out7;
6606
6607 err = ext4_init_post_read_processing();
6608 if (err)
6609 goto out6;
6610
6611 err = ext4_init_pageio();
6612 if (err)
6613 goto out5;
6614
6615 err = ext4_init_system_zone();
6616 if (err)
6617 goto out4;
6618
6619 err = ext4_init_sysfs();
6620 if (err)
6621 goto out3;
6622
6623 err = ext4_init_mballoc();
6624 if (err)
6625 goto out2;
6626 err = init_inodecache();
6627 if (err)
6628 goto out1;
6629
6630 err = ext4_fc_init_dentry_cache();
6631 if (err)
6632 goto out05;
6633
6634 register_as_ext3();
6635 register_as_ext2();
6636 err = register_filesystem(&ext4_fs_type);
6637 if (err)
6638 goto out;
6639
6640 return 0;
6641out:
6642 unregister_as_ext2();
6643 unregister_as_ext3();
6644out05:
6645 destroy_inodecache();
6646out1:
6647 ext4_exit_mballoc();
6648out2:
6649 ext4_exit_sysfs();
6650out3:
6651 ext4_exit_system_zone();
6652out4:
6653 ext4_exit_pageio();
6654out5:
6655 ext4_exit_post_read_processing();
6656out6:
6657 ext4_exit_pending();
6658out7:
6659 ext4_exit_es();
6660
6661 return err;
6662}
6663
6664static void __exit ext4_exit_fs(void)
6665{
6666 ext4_destroy_lazyinit_thread();
6667 unregister_as_ext2();
6668 unregister_as_ext3();
6669 unregister_filesystem(&ext4_fs_type);
6670 destroy_inodecache();
6671 ext4_exit_mballoc();
6672 ext4_exit_sysfs();
6673 ext4_exit_system_zone();
6674 ext4_exit_pageio();
6675 ext4_exit_post_read_processing();
6676 ext4_exit_es();
6677 ext4_exit_pending();
6678}
6679
6680MODULE_AUTHOR("Remy Card, Stephen Tweedie, Andrew Morton, Andreas Dilger, Theodore Ts'o and others");
6681MODULE_DESCRIPTION("Fourth Extended Filesystem");
6682MODULE_LICENSE("GPL");
6683MODULE_SOFTDEP("pre: crc32c");
6684module_init(ext4_init_fs)
6685module_exit(ext4_exit_fs)
6686