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