1
2
3
4
5
6#include "xfs.h"
7#include "xfs_fs.h"
8#include "xfs_shared.h"
9#include "xfs_format.h"
10#include "xfs_log_format.h"
11#include "xfs_trans_resv.h"
12#include "xfs_bit.h"
13#include "xfs_sb.h"
14#include "xfs_mount.h"
15#include "xfs_inode.h"
16#include "xfs_dir2.h"
17#include "xfs_ialloc.h"
18#include "xfs_alloc.h"
19#include "xfs_rtalloc.h"
20#include "xfs_bmap.h"
21#include "xfs_trans.h"
22#include "xfs_trans_priv.h"
23#include "xfs_log.h"
24#include "xfs_error.h"
25#include "xfs_quota.h"
26#include "xfs_fsops.h"
27#include "xfs_icache.h"
28#include "xfs_sysfs.h"
29#include "xfs_rmap_btree.h"
30#include "xfs_refcount_btree.h"
31#include "xfs_reflink.h"
32#include "xfs_extent_busy.h"
33#include "xfs_health.h"
34#include "xfs_trace.h"
35#include "xfs_ag.h"
36
37static DEFINE_MUTEX(xfs_uuid_table_mutex);
38static int xfs_uuid_table_size;
39static uuid_t *xfs_uuid_table;
40
41void
42xfs_uuid_table_free(void)
43{
44 if (xfs_uuid_table_size == 0)
45 return;
46 kmem_free(xfs_uuid_table);
47 xfs_uuid_table = NULL;
48 xfs_uuid_table_size = 0;
49}
50
51
52
53
54
55STATIC int
56xfs_uuid_mount(
57 struct xfs_mount *mp)
58{
59 uuid_t *uuid = &mp->m_sb.sb_uuid;
60 int hole, i;
61
62
63 uuid_copy(&mp->m_super->s_uuid, uuid);
64
65 if (xfs_has_nouuid(mp))
66 return 0;
67
68 if (uuid_is_null(uuid)) {
69 xfs_warn(mp, "Filesystem has null UUID - can't mount");
70 return -EINVAL;
71 }
72
73 mutex_lock(&xfs_uuid_table_mutex);
74 for (i = 0, hole = -1; i < xfs_uuid_table_size; i++) {
75 if (uuid_is_null(&xfs_uuid_table[i])) {
76 hole = i;
77 continue;
78 }
79 if (uuid_equal(uuid, &xfs_uuid_table[i]))
80 goto out_duplicate;
81 }
82
83 if (hole < 0) {
84 xfs_uuid_table = krealloc(xfs_uuid_table,
85 (xfs_uuid_table_size + 1) * sizeof(*xfs_uuid_table),
86 GFP_KERNEL | __GFP_NOFAIL);
87 hole = xfs_uuid_table_size++;
88 }
89 xfs_uuid_table[hole] = *uuid;
90 mutex_unlock(&xfs_uuid_table_mutex);
91
92 return 0;
93
94 out_duplicate:
95 mutex_unlock(&xfs_uuid_table_mutex);
96 xfs_warn(mp, "Filesystem has duplicate UUID %pU - can't mount", uuid);
97 return -EINVAL;
98}
99
100STATIC void
101xfs_uuid_unmount(
102 struct xfs_mount *mp)
103{
104 uuid_t *uuid = &mp->m_sb.sb_uuid;
105 int i;
106
107 if (xfs_has_nouuid(mp))
108 return;
109
110 mutex_lock(&xfs_uuid_table_mutex);
111 for (i = 0; i < xfs_uuid_table_size; i++) {
112 if (uuid_is_null(&xfs_uuid_table[i]))
113 continue;
114 if (!uuid_equal(uuid, &xfs_uuid_table[i]))
115 continue;
116 memset(&xfs_uuid_table[i], 0, sizeof(uuid_t));
117 break;
118 }
119 ASSERT(i < xfs_uuid_table_size);
120 mutex_unlock(&xfs_uuid_table_mutex);
121}
122
123
124
125
126
127int
128xfs_sb_validate_fsb_count(
129 xfs_sb_t *sbp,
130 uint64_t nblocks)
131{
132 ASSERT(PAGE_SHIFT >= sbp->sb_blocklog);
133 ASSERT(sbp->sb_blocklog >= BBSHIFT);
134
135
136 if (nblocks >> (PAGE_SHIFT - sbp->sb_blocklog) > ULONG_MAX)
137 return -EFBIG;
138 return 0;
139}
140
141
142
143
144
145
146int
147xfs_readsb(
148 struct xfs_mount *mp,
149 int flags)
150{
151 unsigned int sector_size;
152 struct xfs_buf *bp;
153 struct xfs_sb *sbp = &mp->m_sb;
154 int error;
155 int loud = !(flags & XFS_MFSI_QUIET);
156 const struct xfs_buf_ops *buf_ops;
157
158 ASSERT(mp->m_sb_bp == NULL);
159 ASSERT(mp->m_ddev_targp != NULL);
160
161
162
163
164
165
166
167
168 sector_size = xfs_getsize_buftarg(mp->m_ddev_targp);
169 buf_ops = NULL;
170
171
172
173
174
175
176
177reread:
178 error = xfs_buf_read_uncached(mp->m_ddev_targp, XFS_SB_DADDR,
179 BTOBB(sector_size), XBF_NO_IOACCT, &bp,
180 buf_ops);
181 if (error) {
182 if (loud)
183 xfs_warn(mp, "SB validate failed with error %d.", error);
184
185 if (error == -EFSBADCRC)
186 error = -EFSCORRUPTED;
187 return error;
188 }
189
190
191
192
193 xfs_sb_from_disk(sbp, bp->b_addr);
194
195
196
197
198
199 if (sbp->sb_magicnum != XFS_SB_MAGIC) {
200 if (loud)
201 xfs_warn(mp, "Invalid superblock magic number");
202 error = -EINVAL;
203 goto release_buf;
204 }
205
206
207
208
209 if (sector_size > sbp->sb_sectsize) {
210 if (loud)
211 xfs_warn(mp, "device supports %u byte sectors (not %u)",
212 sector_size, sbp->sb_sectsize);
213 error = -ENOSYS;
214 goto release_buf;
215 }
216
217 if (buf_ops == NULL) {
218
219
220
221
222 xfs_buf_relse(bp);
223 sector_size = sbp->sb_sectsize;
224 buf_ops = loud ? &xfs_sb_buf_ops : &xfs_sb_quiet_buf_ops;
225 goto reread;
226 }
227
228 mp->m_features |= xfs_sb_version_to_features(sbp);
229 xfs_reinit_percpu_counters(mp);
230
231
232 bp->b_ops = &xfs_sb_buf_ops;
233
234 mp->m_sb_bp = bp;
235 xfs_buf_unlock(bp);
236 return 0;
237
238release_buf:
239 xfs_buf_relse(bp);
240 return error;
241}
242
243
244
245
246
247
248
249static inline int
250xfs_check_new_dalign(
251 struct xfs_mount *mp,
252 int new_dalign,
253 bool *update_sb)
254{
255 struct xfs_sb *sbp = &mp->m_sb;
256 xfs_ino_t calc_ino;
257
258 calc_ino = xfs_ialloc_calc_rootino(mp, new_dalign);
259 trace_xfs_check_new_dalign(mp, new_dalign, calc_ino);
260
261 if (sbp->sb_rootino == calc_ino) {
262 *update_sb = true;
263 return 0;
264 }
265
266 xfs_warn(mp,
267"Cannot change stripe alignment; would require moving root inode.");
268
269
270
271
272
273
274 xfs_warn(mp, "Skipping superblock stripe alignment update.");
275 *update_sb = false;
276 return 0;
277}
278
279
280
281
282
283
284
285STATIC int
286xfs_validate_new_dalign(
287 struct xfs_mount *mp)
288{
289 if (mp->m_dalign == 0)
290 return 0;
291
292
293
294
295
296 if ((BBTOB(mp->m_dalign) & mp->m_blockmask) ||
297 (BBTOB(mp->m_swidth) & mp->m_blockmask)) {
298 xfs_warn(mp,
299 "alignment check failed: sunit/swidth vs. blocksize(%d)",
300 mp->m_sb.sb_blocksize);
301 return -EINVAL;
302 } else {
303
304
305
306 mp->m_dalign = XFS_BB_TO_FSBT(mp, mp->m_dalign);
307 if (mp->m_dalign && (mp->m_sb.sb_agblocks % mp->m_dalign)) {
308 xfs_warn(mp,
309 "alignment check failed: sunit/swidth vs. agsize(%d)",
310 mp->m_sb.sb_agblocks);
311 return -EINVAL;
312 } else if (mp->m_dalign) {
313 mp->m_swidth = XFS_BB_TO_FSBT(mp, mp->m_swidth);
314 } else {
315 xfs_warn(mp,
316 "alignment check failed: sunit(%d) less than bsize(%d)",
317 mp->m_dalign, mp->m_sb.sb_blocksize);
318 return -EINVAL;
319 }
320 }
321
322 if (!xfs_has_dalign(mp)) {
323 xfs_warn(mp,
324"cannot change alignment: superblock does not support data alignment");
325 return -EINVAL;
326 }
327
328 return 0;
329}
330
331
332STATIC int
333xfs_update_alignment(
334 struct xfs_mount *mp)
335{
336 struct xfs_sb *sbp = &mp->m_sb;
337
338 if (mp->m_dalign) {
339 bool update_sb;
340 int error;
341
342 if (sbp->sb_unit == mp->m_dalign &&
343 sbp->sb_width == mp->m_swidth)
344 return 0;
345
346 error = xfs_check_new_dalign(mp, mp->m_dalign, &update_sb);
347 if (error || !update_sb)
348 return error;
349
350 sbp->sb_unit = mp->m_dalign;
351 sbp->sb_width = mp->m_swidth;
352 mp->m_update_sb = true;
353 } else if (!xfs_has_noalign(mp) && xfs_has_dalign(mp)) {
354 mp->m_dalign = sbp->sb_unit;
355 mp->m_swidth = sbp->sb_width;
356 }
357
358 return 0;
359}
360
361
362
363
364void
365xfs_set_low_space_thresholds(
366 struct xfs_mount *mp)
367{
368 uint64_t dblocks = mp->m_sb.sb_dblocks;
369 uint64_t rtexts = mp->m_sb.sb_rextents;
370 int i;
371
372 do_div(dblocks, 100);
373 do_div(rtexts, 100);
374
375 for (i = 0; i < XFS_LOWSP_MAX; i++) {
376 mp->m_low_space[i] = dblocks * (i + 1);
377 mp->m_low_rtexts[i] = rtexts * (i + 1);
378 }
379}
380
381
382
383
384STATIC int
385xfs_check_sizes(
386 struct xfs_mount *mp)
387{
388 struct xfs_buf *bp;
389 xfs_daddr_t d;
390 int error;
391
392 d = (xfs_daddr_t)XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks);
393 if (XFS_BB_TO_FSB(mp, d) != mp->m_sb.sb_dblocks) {
394 xfs_warn(mp, "filesystem size mismatch detected");
395 return -EFBIG;
396 }
397 error = xfs_buf_read_uncached(mp->m_ddev_targp,
398 d - XFS_FSS_TO_BB(mp, 1),
399 XFS_FSS_TO_BB(mp, 1), 0, &bp, NULL);
400 if (error) {
401 xfs_warn(mp, "last sector read failed");
402 return error;
403 }
404 xfs_buf_relse(bp);
405
406 if (mp->m_logdev_targp == mp->m_ddev_targp)
407 return 0;
408
409 d = (xfs_daddr_t)XFS_FSB_TO_BB(mp, mp->m_sb.sb_logblocks);
410 if (XFS_BB_TO_FSB(mp, d) != mp->m_sb.sb_logblocks) {
411 xfs_warn(mp, "log size mismatch detected");
412 return -EFBIG;
413 }
414 error = xfs_buf_read_uncached(mp->m_logdev_targp,
415 d - XFS_FSB_TO_BB(mp, 1),
416 XFS_FSB_TO_BB(mp, 1), 0, &bp, NULL);
417 if (error) {
418 xfs_warn(mp, "log device read failed");
419 return error;
420 }
421 xfs_buf_relse(bp);
422 return 0;
423}
424
425
426
427
428int
429xfs_mount_reset_sbqflags(
430 struct xfs_mount *mp)
431{
432 mp->m_qflags = 0;
433
434
435 if (mp->m_sb.sb_qflags == 0)
436 return 0;
437 spin_lock(&mp->m_sb_lock);
438 mp->m_sb.sb_qflags = 0;
439 spin_unlock(&mp->m_sb_lock);
440
441 if (!xfs_fs_writable(mp, SB_FREEZE_WRITE))
442 return 0;
443
444 return xfs_sync_sb(mp, false);
445}
446
447uint64_t
448xfs_default_resblks(xfs_mount_t *mp)
449{
450 uint64_t resblks;
451
452
453
454
455
456
457
458
459 resblks = mp->m_sb.sb_dblocks;
460 do_div(resblks, 20);
461 resblks = min_t(uint64_t, resblks, 8192);
462 return resblks;
463}
464
465
466STATIC int
467xfs_check_summary_counts(
468 struct xfs_mount *mp)
469{
470
471
472
473
474 if (mp->m_sb.sb_inprogress) {
475 xfs_err(mp, "sb_inprogress set after log recovery??");
476 WARN_ON(1);
477 return -EFSCORRUPTED;
478 }
479
480
481
482
483
484
485
486
487
488
489
490
491 if (xfs_is_clean(mp) &&
492 (mp->m_sb.sb_fdblocks > mp->m_sb.sb_dblocks ||
493 !xfs_verify_icount(mp, mp->m_sb.sb_icount) ||
494 mp->m_sb.sb_ifree > mp->m_sb.sb_icount))
495 xfs_fs_mark_sick(mp, XFS_SICK_FS_COUNTERS);
496
497
498
499
500
501
502
503
504
505
506
507
508 if ((!xfs_has_lazysbcount(mp) || xfs_is_clean(mp)) &&
509 !xfs_fs_has_sickness(mp, XFS_SICK_FS_COUNTERS))
510 return 0;
511
512 return xfs_initialize_perag_data(mp, mp->m_sb.sb_agcount);
513}
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541static void
542xfs_unmount_flush_inodes(
543 struct xfs_mount *mp)
544{
545 xfs_log_force(mp, XFS_LOG_SYNC);
546 xfs_extent_busy_wait_all(mp);
547 flush_workqueue(xfs_discard_wq);
548
549 set_bit(XFS_OPSTATE_UNMOUNTING, &mp->m_opstate);
550
551 xfs_ail_push_all_sync(mp->m_ail);
552 xfs_inodegc_stop(mp);
553 cancel_delayed_work_sync(&mp->m_reclaim_work);
554 xfs_reclaim_inodes(mp);
555 xfs_health_unmount(mp);
556}
557
558static void
559xfs_mount_setup_inode_geom(
560 struct xfs_mount *mp)
561{
562 struct xfs_ino_geometry *igeo = M_IGEO(mp);
563
564 igeo->attr_fork_offset = xfs_bmap_compute_attr_offset(mp);
565 ASSERT(igeo->attr_fork_offset < XFS_LITINO(mp));
566
567 xfs_ialloc_setup_geometry(mp);
568}
569
570
571
572
573
574
575
576
577
578
579
580int
581xfs_mountfs(
582 struct xfs_mount *mp)
583{
584 struct xfs_sb *sbp = &(mp->m_sb);
585 struct xfs_inode *rip;
586 struct xfs_ino_geometry *igeo = M_IGEO(mp);
587 uint64_t resblks;
588 uint quotamount = 0;
589 uint quotaflags = 0;
590 int error = 0;
591
592 xfs_sb_mount_common(mp, sbp);
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610 if (xfs_sb_has_mismatched_features2(sbp)) {
611 xfs_warn(mp, "correcting sb_features alignment problem");
612 sbp->sb_features2 |= sbp->sb_bad_features2;
613 mp->m_update_sb = true;
614 }
615
616
617
618 if (!(mp->m_sb.sb_versionnum & XFS_SB_VERSION_NLINKBIT)) {
619 mp->m_sb.sb_versionnum |= XFS_SB_VERSION_NLINKBIT;
620 mp->m_features |= XFS_FEAT_NLINK;
621 mp->m_update_sb = true;
622 }
623
624
625
626
627
628
629
630 error = xfs_validate_new_dalign(mp);
631 if (error)
632 goto out;
633
634 xfs_alloc_compute_maxlevels(mp);
635 xfs_bmap_compute_maxlevels(mp, XFS_DATA_FORK);
636 xfs_bmap_compute_maxlevels(mp, XFS_ATTR_FORK);
637 xfs_mount_setup_inode_geom(mp);
638 xfs_rmapbt_compute_maxlevels(mp);
639 xfs_refcountbt_compute_maxlevels(mp);
640
641
642
643
644
645
646
647
648 error = xfs_update_alignment(mp);
649 if (error)
650 goto out;
651
652
653 mp->m_fail_unmount = true;
654
655 error = xfs_sysfs_init(&mp->m_kobj, &xfs_mp_ktype,
656 NULL, mp->m_super->s_id);
657 if (error)
658 goto out;
659
660 error = xfs_sysfs_init(&mp->m_stats.xs_kobj, &xfs_stats_ktype,
661 &mp->m_kobj, "stats");
662 if (error)
663 goto out_remove_sysfs;
664
665 error = xfs_error_sysfs_init(mp);
666 if (error)
667 goto out_del_stats;
668
669 error = xfs_errortag_init(mp);
670 if (error)
671 goto out_remove_error_sysfs;
672
673 error = xfs_uuid_mount(mp);
674 if (error)
675 goto out_remove_errortag;
676
677
678
679
680
681 mp->m_allocsize_log =
682 max_t(uint32_t, sbp->sb_blocklog, mp->m_allocsize_log);
683 mp->m_allocsize_blocks = 1U << (mp->m_allocsize_log - sbp->sb_blocklog);
684
685
686 xfs_set_low_space_thresholds(mp);
687
688
689
690
691
692
693 if (xfs_has_sparseinodes(mp) &&
694 mp->m_sb.sb_spino_align !=
695 XFS_B_TO_FSBT(mp, igeo->inode_cluster_size_raw)) {
696 xfs_warn(mp,
697 "Sparse inode block alignment (%u) must match cluster size (%llu).",
698 mp->m_sb.sb_spino_align,
699 XFS_B_TO_FSBT(mp, igeo->inode_cluster_size_raw));
700 error = -EINVAL;
701 goto out_remove_uuid;
702 }
703
704
705
706
707 error = xfs_check_sizes(mp);
708 if (error)
709 goto out_remove_uuid;
710
711
712
713
714 error = xfs_rtmount_init(mp);
715 if (error) {
716 xfs_warn(mp, "RT mount failed");
717 goto out_remove_uuid;
718 }
719
720
721
722
723
724 mp->m_fixedfsid[0] =
725 (get_unaligned_be16(&sbp->sb_uuid.b[8]) << 16) |
726 get_unaligned_be16(&sbp->sb_uuid.b[4]);
727 mp->m_fixedfsid[1] = get_unaligned_be32(&sbp->sb_uuid.b[0]);
728
729 error = xfs_da_mount(mp);
730 if (error) {
731 xfs_warn(mp, "Failed dir/attr init: %d", error);
732 goto out_remove_uuid;
733 }
734
735
736
737
738 xfs_trans_init(mp);
739
740
741
742
743 error = xfs_initialize_perag(mp, sbp->sb_agcount, &mp->m_maxagi);
744 if (error) {
745 xfs_warn(mp, "Failed per-ag init: %d", error);
746 goto out_free_dir;
747 }
748
749 if (XFS_IS_CORRUPT(mp, !sbp->sb_logblocks)) {
750 xfs_warn(mp, "no log defined");
751 error = -EFSCORRUPTED;
752 goto out_free_perag;
753 }
754
755 error = xfs_inodegc_register_shrinker(mp);
756 if (error)
757 goto out_fail_wait;
758
759
760
761
762
763
764 error = xfs_log_mount(mp, mp->m_logdev_targp,
765 XFS_FSB_TO_DADDR(mp, sbp->sb_logstart),
766 XFS_FSB_TO_BB(mp, sbp->sb_logblocks));
767 if (error) {
768 xfs_warn(mp, "log mount failed");
769 goto out_inodegc_shrinker;
770 }
771
772
773 error = xfs_check_summary_counts(mp);
774 if (error)
775 goto out_log_dealloc;
776
777
778 xfs_inodegc_start(mp);
779 xfs_blockgc_start(mp);
780
781
782
783
784
785
786
787 if (xfs_has_noattr2(mp)) {
788 mp->m_features &= ~XFS_FEAT_ATTR2;
789 } else if (!xfs_has_attr2(mp) &&
790 (mp->m_sb.sb_features2 & XFS_SB_VERSION2_ATTR2BIT)) {
791 mp->m_features |= XFS_FEAT_ATTR2;
792 }
793
794
795
796
797
798 error = xfs_iget(mp, NULL, sbp->sb_rootino, XFS_IGET_UNTRUSTED,
799 XFS_ILOCK_EXCL, &rip);
800 if (error) {
801 xfs_warn(mp,
802 "Failed to read root inode 0x%llx, error %d",
803 sbp->sb_rootino, -error);
804 goto out_log_dealloc;
805 }
806
807 ASSERT(rip != NULL);
808
809 if (XFS_IS_CORRUPT(mp, !S_ISDIR(VFS_I(rip)->i_mode))) {
810 xfs_warn(mp, "corrupted root inode %llu: not a directory",
811 (unsigned long long)rip->i_ino);
812 xfs_iunlock(rip, XFS_ILOCK_EXCL);
813 error = -EFSCORRUPTED;
814 goto out_rele_rip;
815 }
816 mp->m_rootip = rip;
817
818 xfs_iunlock(rip, XFS_ILOCK_EXCL);
819
820
821
822
823 error = xfs_rtmount_inodes(mp);
824 if (error) {
825
826
827
828 xfs_warn(mp, "failed to read RT inodes");
829 goto out_rele_rip;
830 }
831
832
833
834
835
836
837 if (mp->m_update_sb && !xfs_is_readonly(mp)) {
838 error = xfs_sync_sb(mp, false);
839 if (error) {
840 xfs_warn(mp, "failed to write sb changes");
841 goto out_rtunmount;
842 }
843 }
844
845
846
847
848 if (XFS_IS_QUOTA_ON(mp)) {
849 error = xfs_qm_newmount(mp, "amount, "aflags);
850 if (error)
851 goto out_rtunmount;
852 } else {
853
854
855
856
857
858 if (mp->m_sb.sb_qflags & XFS_ALL_QUOTA_ACCT) {
859 xfs_notice(mp, "resetting quota flags");
860 error = xfs_mount_reset_sbqflags(mp);
861 if (error)
862 goto out_rtunmount;
863 }
864 }
865
866
867
868
869
870
871
872
873
874 error = xfs_fs_reserve_ag_blocks(mp);
875 if (error && error == -ENOSPC)
876 xfs_warn(mp,
877 "ENOSPC reserving per-AG metadata pool, log recovery may fail.");
878 error = xfs_log_mount_finish(mp);
879 xfs_fs_unreserve_ag_blocks(mp);
880 if (error) {
881 xfs_warn(mp, "log mount finish failed");
882 goto out_rtunmount;
883 }
884
885
886
887
888
889
890
891
892
893
894 if (xfs_is_readonly(mp) && !xfs_has_norecovery(mp))
895 xfs_log_clean(mp);
896
897
898
899
900 if (quotamount) {
901 ASSERT(mp->m_qflags == 0);
902 mp->m_qflags = quotaflags;
903
904 xfs_qm_mount_quotas(mp);
905 }
906
907
908
909
910
911
912
913
914
915
916
917
918 if (!xfs_is_readonly(mp)) {
919 resblks = xfs_default_resblks(mp);
920 error = xfs_reserve_blocks(mp, &resblks, NULL);
921 if (error)
922 xfs_warn(mp,
923 "Unable to allocate reserve blocks. Continuing without reserve pool.");
924
925
926 error = xfs_reflink_recover_cow(mp);
927 if (error) {
928 xfs_err(mp,
929 "Error %d recovering leftover CoW allocations.", error);
930 xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
931 goto out_quota;
932 }
933
934
935 error = xfs_fs_reserve_ag_blocks(mp);
936 if (error && error != -ENOSPC)
937 goto out_agresv;
938 }
939
940 return 0;
941
942 out_agresv:
943 xfs_fs_unreserve_ag_blocks(mp);
944 out_quota:
945 xfs_qm_unmount_quotas(mp);
946 out_rtunmount:
947 xfs_rtunmount_inodes(mp);
948 out_rele_rip:
949 xfs_irele(rip);
950
951 xfs_qm_unmount(mp);
952
953
954
955
956
957
958
959 xfs_inodegc_flush(mp);
960
961
962
963
964
965
966
967
968
969
970
971
972 xfs_unmount_flush_inodes(mp);
973 out_log_dealloc:
974 xfs_log_mount_cancel(mp);
975 out_inodegc_shrinker:
976 unregister_shrinker(&mp->m_inodegc_shrinker);
977 out_fail_wait:
978 if (mp->m_logdev_targp && mp->m_logdev_targp != mp->m_ddev_targp)
979 xfs_buftarg_drain(mp->m_logdev_targp);
980 xfs_buftarg_drain(mp->m_ddev_targp);
981 out_free_perag:
982 xfs_free_perag(mp);
983 out_free_dir:
984 xfs_da_unmount(mp);
985 out_remove_uuid:
986 xfs_uuid_unmount(mp);
987 out_remove_errortag:
988 xfs_errortag_del(mp);
989 out_remove_error_sysfs:
990 xfs_error_sysfs_del(mp);
991 out_del_stats:
992 xfs_sysfs_del(&mp->m_stats.xs_kobj);
993 out_remove_sysfs:
994 xfs_sysfs_del(&mp->m_kobj);
995 out:
996 return error;
997}
998
999
1000
1001
1002
1003void
1004xfs_unmountfs(
1005 struct xfs_mount *mp)
1006{
1007 uint64_t resblks;
1008 int error;
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018 xfs_inodegc_flush(mp);
1019
1020 xfs_blockgc_stop(mp);
1021 xfs_fs_unreserve_ag_blocks(mp);
1022 xfs_qm_unmount_quotas(mp);
1023 xfs_rtunmount_inodes(mp);
1024 xfs_irele(mp->m_rootip);
1025
1026 xfs_unmount_flush_inodes(mp);
1027
1028 xfs_qm_unmount(mp);
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044 resblks = 0;
1045 error = xfs_reserve_blocks(mp, &resblks, NULL);
1046 if (error)
1047 xfs_warn(mp, "Unable to free reserved block pool. "
1048 "Freespace may not be correct on next mount.");
1049
1050 xfs_log_unmount(mp);
1051 xfs_da_unmount(mp);
1052 xfs_uuid_unmount(mp);
1053
1054#if defined(DEBUG)
1055 xfs_errortag_clearall(mp);
1056#endif
1057 unregister_shrinker(&mp->m_inodegc_shrinker);
1058 xfs_free_perag(mp);
1059
1060 xfs_errortag_del(mp);
1061 xfs_error_sysfs_del(mp);
1062 xfs_sysfs_del(&mp->m_stats.xs_kobj);
1063 xfs_sysfs_del(&mp->m_kobj);
1064}
1065
1066
1067
1068
1069
1070
1071
1072bool
1073xfs_fs_writable(
1074 struct xfs_mount *mp,
1075 int level)
1076{
1077 ASSERT(level > SB_UNFROZEN);
1078 if ((mp->m_super->s_writers.frozen >= level) ||
1079 xfs_is_shutdown(mp) || xfs_is_readonly(mp))
1080 return false;
1081
1082 return true;
1083}
1084
1085int
1086xfs_mod_fdblocks(
1087 struct xfs_mount *mp,
1088 int64_t delta,
1089 bool rsvd)
1090{
1091 int64_t lcounter;
1092 long long res_used;
1093 s32 batch;
1094 uint64_t set_aside;
1095
1096 if (delta > 0) {
1097
1098
1099
1100
1101 if (likely(mp->m_resblks == mp->m_resblks_avail)) {
1102 percpu_counter_add(&mp->m_fdblocks, delta);
1103 return 0;
1104 }
1105
1106 spin_lock(&mp->m_sb_lock);
1107 res_used = (long long)(mp->m_resblks - mp->m_resblks_avail);
1108
1109 if (res_used > delta) {
1110 mp->m_resblks_avail += delta;
1111 } else {
1112 delta -= res_used;
1113 mp->m_resblks_avail = mp->m_resblks;
1114 percpu_counter_add(&mp->m_fdblocks, delta);
1115 }
1116 spin_unlock(&mp->m_sb_lock);
1117 return 0;
1118 }
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128 if (__percpu_counter_compare(&mp->m_fdblocks, 2 * XFS_FDBLOCKS_BATCH,
1129 XFS_FDBLOCKS_BATCH) < 0)
1130 batch = 1;
1131 else
1132 batch = XFS_FDBLOCKS_BATCH;
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145 set_aside = mp->m_alloc_set_aside + atomic64_read(&mp->m_allocbt_blks);
1146 percpu_counter_add_batch(&mp->m_fdblocks, delta, batch);
1147 if (__percpu_counter_compare(&mp->m_fdblocks, set_aside,
1148 XFS_FDBLOCKS_BATCH) >= 0) {
1149
1150 return 0;
1151 }
1152
1153
1154
1155
1156
1157 spin_lock(&mp->m_sb_lock);
1158 percpu_counter_add(&mp->m_fdblocks, -delta);
1159 if (!rsvd)
1160 goto fdblocks_enospc;
1161
1162 lcounter = (long long)mp->m_resblks_avail + delta;
1163 if (lcounter >= 0) {
1164 mp->m_resblks_avail = lcounter;
1165 spin_unlock(&mp->m_sb_lock);
1166 return 0;
1167 }
1168 xfs_warn_once(mp,
1169"Reserve blocks depleted! Consider increasing reserve pool size.");
1170
1171fdblocks_enospc:
1172 spin_unlock(&mp->m_sb_lock);
1173 return -ENOSPC;
1174}
1175
1176int
1177xfs_mod_frextents(
1178 struct xfs_mount *mp,
1179 int64_t delta)
1180{
1181 int64_t lcounter;
1182 int ret = 0;
1183
1184 spin_lock(&mp->m_sb_lock);
1185 lcounter = mp->m_sb.sb_frextents + delta;
1186 if (lcounter < 0)
1187 ret = -ENOSPC;
1188 else
1189 mp->m_sb.sb_frextents = lcounter;
1190 spin_unlock(&mp->m_sb_lock);
1191 return ret;
1192}
1193
1194
1195
1196
1197void
1198xfs_freesb(
1199 struct xfs_mount *mp)
1200{
1201 struct xfs_buf *bp = mp->m_sb_bp;
1202
1203 xfs_buf_lock(bp);
1204 mp->m_sb_bp = NULL;
1205 xfs_buf_relse(bp);
1206}
1207
1208
1209
1210
1211
1212int
1213xfs_dev_is_read_only(
1214 struct xfs_mount *mp,
1215 char *message)
1216{
1217 if (xfs_readonly_buftarg(mp->m_ddev_targp) ||
1218 xfs_readonly_buftarg(mp->m_logdev_targp) ||
1219 (mp->m_rtdev_targp && xfs_readonly_buftarg(mp->m_rtdev_targp))) {
1220 xfs_notice(mp, "%s required on read-only device.", message);
1221 xfs_notice(mp, "write access unavailable, cannot proceed.");
1222 return -EROFS;
1223 }
1224 return 0;
1225}
1226
1227
1228void
1229xfs_force_summary_recalc(
1230 struct xfs_mount *mp)
1231{
1232 if (!xfs_has_lazysbcount(mp))
1233 return;
1234
1235 xfs_fs_mark_sick(mp, XFS_SICK_FS_COUNTERS);
1236}
1237
1238
1239
1240
1241
1242int
1243xfs_add_incompat_log_feature(
1244 struct xfs_mount *mp,
1245 uint32_t feature)
1246{
1247 struct xfs_dsb *dsb;
1248 int error;
1249
1250 ASSERT(hweight32(feature) == 1);
1251 ASSERT(!(feature & XFS_SB_FEAT_INCOMPAT_LOG_UNKNOWN));
1252
1253
1254
1255
1256
1257
1258
1259 error = xfs_log_force(mp, XFS_LOG_SYNC);
1260 if (error)
1261 return error;
1262 xfs_ail_push_all(mp->m_ail);
1263
1264
1265
1266
1267
1268 xfs_buf_lock(mp->m_sb_bp);
1269 xfs_buf_hold(mp->m_sb_bp);
1270
1271 if (xfs_is_shutdown(mp)) {
1272 error = -EIO;
1273 goto rele;
1274 }
1275
1276 if (xfs_sb_has_incompat_log_feature(&mp->m_sb, feature))
1277 goto rele;
1278
1279
1280
1281
1282
1283
1284 dsb = mp->m_sb_bp->b_addr;
1285 xfs_sb_to_disk(dsb, &mp->m_sb);
1286 dsb->sb_features_log_incompat |= cpu_to_be32(feature);
1287 error = xfs_bwrite(mp->m_sb_bp);
1288 if (error)
1289 goto shutdown;
1290
1291
1292
1293
1294
1295 xfs_sb_add_incompat_log_features(&mp->m_sb, feature);
1296 xfs_buf_relse(mp->m_sb_bp);
1297
1298
1299 return xfs_sync_sb(mp, false);
1300shutdown:
1301 xfs_force_shutdown(mp, SHUTDOWN_META_IO_ERROR);
1302rele:
1303 xfs_buf_relse(mp->m_sb_bp);
1304 return error;
1305}
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317bool
1318xfs_clear_incompat_log_features(
1319 struct xfs_mount *mp)
1320{
1321 bool ret = false;
1322
1323 if (!xfs_has_crc(mp) ||
1324 !xfs_sb_has_incompat_log_feature(&mp->m_sb,
1325 XFS_SB_FEAT_INCOMPAT_LOG_ALL) ||
1326 xfs_is_shutdown(mp))
1327 return false;
1328
1329
1330
1331
1332
1333
1334 xfs_buf_lock(mp->m_sb_bp);
1335 xfs_buf_hold(mp->m_sb_bp);
1336
1337 if (xfs_sb_has_incompat_log_feature(&mp->m_sb,
1338 XFS_SB_FEAT_INCOMPAT_LOG_ALL)) {
1339 xfs_info(mp, "Clearing log incompat feature flags.");
1340 xfs_sb_remove_incompat_log_features(&mp->m_sb);
1341 ret = true;
1342 }
1343
1344 xfs_buf_relse(mp->m_sb_bp);
1345 return ret;
1346}
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359#define XFS_DELALLOC_BATCH (4096)
1360void
1361xfs_mod_delalloc(
1362 struct xfs_mount *mp,
1363 int64_t delta)
1364{
1365 percpu_counter_add_batch(&mp->m_delalloc_blks, delta,
1366 XFS_DELALLOC_BATCH);
1367}
1368