Line data Source code
1 : // SPDX-License-Identifier: GPL-2.0
2 : /*
3 : * Copyright (c) 2000-2005 Silicon Graphics, Inc.
4 : * All Rights Reserved.
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_log_priv.h"
25 : #include "xfs_error.h"
26 : #include "xfs_quota.h"
27 : #include "xfs_fsops.h"
28 : #include "xfs_icache.h"
29 : #include "xfs_sysfs.h"
30 : #include "xfs_rmap_btree.h"
31 : #include "xfs_refcount_btree.h"
32 : #include "xfs_reflink.h"
33 : #include "xfs_extent_busy.h"
34 : #include "xfs_health.h"
35 : #include "xfs_trace.h"
36 : #include "xfs_ag.h"
37 : #include "scrub/stats.h"
38 :
39 : static DEFINE_MUTEX(xfs_uuid_table_mutex);
40 : static int xfs_uuid_table_size;
41 : static uuid_t *xfs_uuid_table;
42 :
43 : void
44 12 : xfs_uuid_table_free(void)
45 : {
46 12 : if (xfs_uuid_table_size == 0)
47 : return;
48 12 : kmem_free(xfs_uuid_table);
49 12 : xfs_uuid_table = NULL;
50 12 : xfs_uuid_table_size = 0;
51 : }
52 :
53 : /*
54 : * See if the UUID is unique among mounted XFS filesystems.
55 : * Mount fails if UUID is nil or a FS with the same UUID is already mounted.
56 : */
57 : STATIC int
58 24119 : xfs_uuid_mount(
59 : struct xfs_mount *mp)
60 : {
61 24119 : uuid_t *uuid = &mp->m_sb.sb_uuid;
62 24119 : int hole, i;
63 :
64 : /* Publish UUID in struct super_block */
65 24119 : uuid_copy(&mp->m_super->s_uuid, uuid);
66 :
67 24119 : if (xfs_has_nouuid(mp))
68 : return 0;
69 :
70 24115 : if (uuid_is_null(uuid)) {
71 0 : xfs_warn(mp, "Filesystem has null UUID - can't mount");
72 0 : return -EINVAL;
73 : }
74 :
75 24115 : mutex_lock(&xfs_uuid_table_mutex);
76 105007 : for (i = 0, hole = -1; i < xfs_uuid_table_size; i++) {
77 56781 : if (uuid_is_null(&xfs_uuid_table[i])) {
78 34997 : hole = i;
79 34997 : continue;
80 : }
81 21784 : if (uuid_equal(uuid, &xfs_uuid_table[i]))
82 4 : goto out_duplicate;
83 : }
84 :
85 24111 : if (hole < 0) {
86 72 : xfs_uuid_table = krealloc(xfs_uuid_table,
87 36 : (xfs_uuid_table_size + 1) * sizeof(*xfs_uuid_table),
88 : GFP_KERNEL | __GFP_NOFAIL);
89 36 : hole = xfs_uuid_table_size++;
90 : }
91 24111 : xfs_uuid_table[hole] = *uuid;
92 24111 : mutex_unlock(&xfs_uuid_table_mutex);
93 :
94 24111 : return 0;
95 :
96 : out_duplicate:
97 4 : mutex_unlock(&xfs_uuid_table_mutex);
98 4 : xfs_warn(mp, "Filesystem has duplicate UUID %pU - can't mount", uuid);
99 4 : return -EINVAL;
100 : }
101 :
102 : STATIC void
103 24122 : xfs_uuid_unmount(
104 : struct xfs_mount *mp)
105 : {
106 24122 : uuid_t *uuid = &mp->m_sb.sb_uuid;
107 24122 : int i;
108 :
109 24122 : if (xfs_has_nouuid(mp))
110 : return;
111 :
112 24118 : mutex_lock(&xfs_uuid_table_mutex);
113 60645 : for (i = 0; i < xfs_uuid_table_size; i++) {
114 36527 : if (uuid_is_null(&xfs_uuid_table[i]))
115 9816 : continue;
116 26711 : if (!uuid_equal(uuid, &xfs_uuid_table[i]))
117 2593 : continue;
118 24118 : memset(&xfs_uuid_table[i], 0, sizeof(uuid_t));
119 24118 : break;
120 : }
121 24118 : ASSERT(i < xfs_uuid_table_size);
122 24118 : mutex_unlock(&xfs_uuid_table_mutex);
123 : }
124 :
125 : /*
126 : * Check size of device based on the (data/realtime) block count.
127 : * Note: this check is used by the growfs code as well as mount.
128 : */
129 : int
130 48616 : xfs_sb_validate_fsb_count(
131 : xfs_sb_t *sbp,
132 : uint64_t nblocks)
133 : {
134 48616 : ASSERT(PAGE_SHIFT >= sbp->sb_blocklog);
135 48616 : ASSERT(sbp->sb_blocklog >= BBSHIFT);
136 :
137 : /* Limited by ULONG_MAX of page cache index */
138 48616 : if (nblocks >> (PAGE_SHIFT - sbp->sb_blocklog) > ULONG_MAX)
139 : return -EFBIG;
140 48616 : return 0;
141 : }
142 :
143 : /*
144 : * xfs_readsb
145 : *
146 : * Does the initial read of the superblock.
147 : */
148 : int
149 24157 : xfs_readsb(
150 : struct xfs_mount *mp,
151 : int flags)
152 : {
153 24157 : unsigned int sector_size;
154 24157 : struct xfs_buf *bp;
155 24157 : struct xfs_sb *sbp = &mp->m_sb;
156 24157 : int error;
157 24157 : int loud = !(flags & XFS_MFSI_QUIET);
158 24157 : const struct xfs_buf_ops *buf_ops;
159 :
160 24157 : ASSERT(mp->m_sb_bp == NULL);
161 24157 : ASSERT(mp->m_ddev_targp != NULL);
162 :
163 : /*
164 : * For the initial read, we must guess at the sector
165 : * size based on the block device. It's enough to
166 : * get the sb_sectsize out of the superblock and
167 : * then reread with the proper length.
168 : * We don't verify it yet, because it may not be complete.
169 : */
170 24157 : sector_size = xfs_getsize_buftarg(mp->m_ddev_targp);
171 : buf_ops = NULL;
172 :
173 : /*
174 : * Allocate a (locked) buffer to hold the superblock. This will be kept
175 : * around at all times to optimize access to the superblock. Therefore,
176 : * set XBF_NO_IOACCT to make sure it doesn't hold the buftarg count
177 : * elevated.
178 : */
179 24157 : reread:
180 48312 : error = xfs_buf_read_uncached(mp->m_ddev_targp, XFS_SB_DADDR,
181 48312 : BTOBB(sector_size), XBF_NO_IOACCT, &bp,
182 : buf_ops);
183 48312 : if (error) {
184 16 : if (loud)
185 16 : xfs_warn(mp, "SB validate failed with error %d.", error);
186 : /* bad CRC means corrupted metadata */
187 16 : if (error == -EFSBADCRC)
188 4 : error = -EFSCORRUPTED;
189 16 : return error;
190 : }
191 :
192 : /*
193 : * Initialize the mount structure from the superblock.
194 : */
195 48296 : xfs_sb_from_disk(sbp, bp->b_addr);
196 :
197 : /*
198 : * If we haven't validated the superblock, do so now before we try
199 : * to check the sector size and reread the superblock appropriately.
200 : */
201 48296 : if (sbp->sb_magicnum != XFS_SB_MAGIC) {
202 0 : if (loud)
203 0 : xfs_warn(mp, "Invalid superblock magic number");
204 0 : error = -EINVAL;
205 0 : goto release_buf;
206 : }
207 :
208 : /*
209 : * We must be able to do sector-sized and sector-aligned IO.
210 : */
211 48296 : if (sector_size > sbp->sb_sectsize) {
212 0 : if (loud)
213 0 : xfs_warn(mp, "device supports %u byte sectors (not %u)",
214 : sector_size, sbp->sb_sectsize);
215 0 : error = -ENOSYS;
216 0 : goto release_buf;
217 : }
218 :
219 48296 : if (buf_ops == NULL) {
220 : /*
221 : * Re-read the superblock so the buffer is correctly sized,
222 : * and properly verified.
223 : */
224 24155 : xfs_buf_relse(bp);
225 24155 : sector_size = sbp->sb_sectsize;
226 24155 : buf_ops = loud ? &xfs_sb_buf_ops : &xfs_sb_quiet_buf_ops;
227 24155 : goto reread;
228 : }
229 :
230 24141 : mp->m_features |= xfs_sb_version_to_features(sbp);
231 24141 : xfs_reinit_percpu_counters(mp);
232 :
233 : /* no need to be quiet anymore, so reset the buf ops */
234 24141 : bp->b_ops = &xfs_sb_buf_ops;
235 :
236 24141 : mp->m_sb_bp = bp;
237 24141 : xfs_buf_unlock(bp);
238 24141 : return 0;
239 :
240 0 : release_buf:
241 0 : xfs_buf_relse(bp);
242 0 : return error;
243 : }
244 :
245 : /*
246 : * If the sunit/swidth change would move the precomputed root inode value, we
247 : * must reject the ondisk change because repair will stumble over that.
248 : * However, we allow the mount to proceed because we never rejected this
249 : * combination before. Returns true to update the sb, false otherwise.
250 : */
251 : static inline int
252 14 : xfs_check_new_dalign(
253 : struct xfs_mount *mp,
254 : int new_dalign,
255 : bool *update_sb)
256 : {
257 14 : struct xfs_sb *sbp = &mp->m_sb;
258 14 : xfs_ino_t calc_ino;
259 :
260 14 : calc_ino = xfs_ialloc_calc_rootino(mp, new_dalign);
261 14 : trace_xfs_check_new_dalign(mp, new_dalign, calc_ino);
262 :
263 14 : if (sbp->sb_rootino == calc_ino) {
264 10 : *update_sb = true;
265 10 : return 0;
266 : }
267 :
268 4 : xfs_warn(mp,
269 : "Cannot change stripe alignment; would require moving root inode.");
270 :
271 : /*
272 : * XXX: Next time we add a new incompat feature, this should start
273 : * returning -EINVAL to fail the mount. Until then, spit out a warning
274 : * that we're ignoring the administrator's instructions.
275 : */
276 4 : xfs_warn(mp, "Skipping superblock stripe alignment update.");
277 4 : *update_sb = false;
278 4 : return 0;
279 : }
280 :
281 : /*
282 : * If we were provided with new sunit/swidth values as mount options, make sure
283 : * that they pass basic alignment and superblock feature checks, and convert
284 : * them into the same units (FSB) that everything else expects. This step
285 : * /must/ be done before computing the inode geometry.
286 : */
287 : STATIC int
288 24125 : xfs_validate_new_dalign(
289 : struct xfs_mount *mp)
290 : {
291 24125 : if (mp->m_dalign == 0)
292 : return 0;
293 :
294 : /*
295 : * If stripe unit and stripe width are not multiples
296 : * of the fs blocksize turn off alignment.
297 : */
298 22 : if ((BBTOB(mp->m_dalign) & mp->m_blockmask) ||
299 20 : (BBTOB(mp->m_swidth) & mp->m_blockmask)) {
300 2 : xfs_warn(mp,
301 : "alignment check failed: sunit/swidth vs. blocksize(%d)",
302 : mp->m_sb.sb_blocksize);
303 2 : return -EINVAL;
304 : }
305 :
306 : /*
307 : * Convert the stripe unit and width to FSBs.
308 : */
309 20 : mp->m_dalign = XFS_BB_TO_FSBT(mp, mp->m_dalign);
310 20 : if (mp->m_dalign && (mp->m_sb.sb_agblocks % mp->m_dalign)) {
311 4 : xfs_warn(mp,
312 : "alignment check failed: sunit/swidth vs. agsize(%d)",
313 : mp->m_sb.sb_agblocks);
314 4 : return -EINVAL;
315 : }
316 :
317 16 : if (!mp->m_dalign) {
318 0 : xfs_warn(mp,
319 : "alignment check failed: sunit(%d) less than bsize(%d)",
320 : mp->m_dalign, mp->m_sb.sb_blocksize);
321 0 : return -EINVAL;
322 : }
323 :
324 16 : mp->m_swidth = XFS_BB_TO_FSBT(mp, mp->m_swidth);
325 :
326 16 : if (!xfs_has_dalign(mp)) {
327 0 : xfs_warn(mp,
328 : "cannot change alignment: superblock does not support data alignment");
329 0 : return -EINVAL;
330 : }
331 :
332 : return 0;
333 : }
334 :
335 : /* Update alignment values based on mount options and sb values. */
336 : STATIC int
337 24119 : xfs_update_alignment(
338 : struct xfs_mount *mp)
339 : {
340 24119 : struct xfs_sb *sbp = &mp->m_sb;
341 :
342 24119 : if (mp->m_dalign) {
343 16 : bool update_sb;
344 16 : int error;
345 :
346 16 : if (sbp->sb_unit == mp->m_dalign &&
347 : sbp->sb_width == mp->m_swidth)
348 6 : return 0;
349 :
350 14 : error = xfs_check_new_dalign(mp, mp->m_dalign, &update_sb);
351 14 : if (error || !update_sb)
352 : return error;
353 :
354 10 : sbp->sb_unit = mp->m_dalign;
355 10 : sbp->sb_width = mp->m_swidth;
356 10 : mp->m_update_sb = true;
357 24103 : } else if (!xfs_has_noalign(mp) && xfs_has_dalign(mp)) {
358 92 : mp->m_dalign = sbp->sb_unit;
359 92 : mp->m_swidth = sbp->sb_width;
360 : }
361 :
362 : return 0;
363 : }
364 :
365 : /*
366 : * precalculate the low space thresholds for dynamic speculative preallocation.
367 : */
368 : void
369 24241 : xfs_set_low_space_thresholds(
370 : struct xfs_mount *mp)
371 : {
372 24241 : uint64_t dblocks = mp->m_sb.sb_dblocks;
373 24241 : uint64_t rtexts = mp->m_sb.sb_rextents;
374 24241 : int i;
375 :
376 24241 : do_div(dblocks, 100);
377 24241 : do_div(rtexts, 100);
378 :
379 145446 : for (i = 0; i < XFS_LOWSP_MAX; i++) {
380 121205 : mp->m_low_space[i] = dblocks * (i + 1);
381 121205 : mp->m_low_rtexts[i] = rtexts * (i + 1);
382 : }
383 24241 : }
384 :
385 : /*
386 : * Check that the data (and log if separate) is an ok size.
387 : */
388 : STATIC int
389 24115 : xfs_check_sizes(
390 : struct xfs_mount *mp)
391 : {
392 24115 : struct xfs_buf *bp;
393 24115 : xfs_daddr_t d;
394 24115 : int error;
395 :
396 24115 : d = (xfs_daddr_t)XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks);
397 24115 : if (XFS_BB_TO_FSB(mp, d) != mp->m_sb.sb_dblocks) {
398 0 : xfs_warn(mp, "filesystem size mismatch detected");
399 0 : return -EFBIG;
400 : }
401 24115 : error = xfs_buf_read_uncached(mp->m_ddev_targp,
402 24115 : d - XFS_FSS_TO_BB(mp, 1),
403 : XFS_FSS_TO_BB(mp, 1), 0, &bp, NULL);
404 24115 : if (error) {
405 0 : xfs_warn(mp, "last sector read failed");
406 0 : return error;
407 : }
408 24115 : xfs_buf_relse(bp);
409 :
410 24115 : if (mp->m_logdev_targp == mp->m_ddev_targp)
411 : return 0;
412 :
413 2 : d = (xfs_daddr_t)XFS_FSB_TO_BB(mp, mp->m_sb.sb_logblocks);
414 2 : if (XFS_BB_TO_FSB(mp, d) != mp->m_sb.sb_logblocks) {
415 0 : xfs_warn(mp, "log size mismatch detected");
416 0 : return -EFBIG;
417 : }
418 2 : error = xfs_buf_read_uncached(mp->m_logdev_targp,
419 2 : d - XFS_FSB_TO_BB(mp, 1),
420 : XFS_FSB_TO_BB(mp, 1), 0, &bp, NULL);
421 2 : if (error) {
422 0 : xfs_warn(mp, "log device read failed");
423 0 : return error;
424 : }
425 2 : xfs_buf_relse(bp);
426 2 : return 0;
427 : }
428 :
429 : /*
430 : * Clear the quotaflags in memory and in the superblock.
431 : */
432 : int
433 34 : xfs_mount_reset_sbqflags(
434 : struct xfs_mount *mp)
435 : {
436 34 : mp->m_qflags = 0;
437 :
438 : /* It is OK to look at sb_qflags in the mount path without m_sb_lock. */
439 34 : if (mp->m_sb.sb_qflags == 0)
440 : return 0;
441 34 : spin_lock(&mp->m_sb_lock);
442 34 : mp->m_sb.sb_qflags = 0;
443 34 : spin_unlock(&mp->m_sb_lock);
444 :
445 34 : if (!xfs_fs_writable(mp, SB_FREEZE_WRITE))
446 : return 0;
447 :
448 34 : return xfs_sync_sb(mp, false);
449 : }
450 :
451 : uint64_t
452 4 : xfs_default_resblks(xfs_mount_t *mp)
453 : {
454 21920 : uint64_t resblks;
455 :
456 : /*
457 : * We default to 5% or 8192 fsbs of space reserved, whichever is
458 : * smaller. This is intended to cover concurrent allocation
459 : * transactions when we initially hit enospc. These each require a 4
460 : * block reservation. Hence by default we cover roughly 2000 concurrent
461 : * allocation reservations.
462 : */
463 21920 : resblks = mp->m_sb.sb_dblocks;
464 21920 : do_div(resblks, 20);
465 21920 : resblks = min_t(uint64_t, resblks, 8192);
466 21920 : return resblks;
467 : }
468 :
469 : /* Ensure the summary counts are correct. */
470 : STATIC int
471 24103 : xfs_check_summary_counts(
472 : struct xfs_mount *mp)
473 : {
474 24103 : int error = 0;
475 :
476 : /*
477 : * The AG0 superblock verifier rejects in-progress filesystems,
478 : * so we should never see the flag set this far into mounting.
479 : */
480 24103 : if (mp->m_sb.sb_inprogress) {
481 0 : xfs_err(mp, "sb_inprogress set after log recovery??");
482 0 : WARN_ON(1);
483 0 : return -EFSCORRUPTED;
484 : }
485 :
486 : /*
487 : * Now the log is mounted, we know if it was an unclean shutdown or
488 : * not. If it was, with the first phase of recovery has completed, we
489 : * have consistent AG blocks on disk. We have not recovered EFIs yet,
490 : * but they are recovered transactionally in the second recovery phase
491 : * later.
492 : *
493 : * If the log was clean when we mounted, we can check the summary
494 : * counters. If any of them are obviously incorrect, we can recompute
495 : * them from the AGF headers in the next step.
496 : */
497 48206 : if (xfs_is_clean(mp) &&
498 25616 : (mp->m_sb.sb_fdblocks > mp->m_sb.sb_dblocks ||
499 12806 : !xfs_verify_icount(mp, mp->m_sb.sb_icount) ||
500 12806 : mp->m_sb.sb_ifree > mp->m_sb.sb_icount)) {
501 6 : xfs_fs_mark_sick(mp, XFS_SICK_FS_COUNTERS);
502 6 : xfs_fs_mark_checked(mp, XFS_SICK_FS_COUNTERS);
503 : }
504 :
505 : /*
506 : * We can safely re-initialise incore superblock counters from the
507 : * per-ag data. These may not be correct if the filesystem was not
508 : * cleanly unmounted, so we waited for recovery to finish before doing
509 : * this.
510 : *
511 : * If the filesystem was cleanly unmounted or the previous check did
512 : * not flag anything weird, then we can trust the values in the
513 : * superblock to be correct and we don't need to do anything here.
514 : * Otherwise, recalculate the summary counters.
515 : */
516 61010 : if ((xfs_has_lazysbcount(mp) && !xfs_is_clean(mp)) ||
517 : xfs_fs_has_sickness(mp, XFS_SICK_FS_COUNTERS)) {
518 11299 : error = xfs_initialize_perag_data(mp, mp->m_sb.sb_agcount);
519 11299 : if (error)
520 : return error;
521 : }
522 :
523 : /*
524 : * Older kernels misused sb_frextents to reflect both incore
525 : * reservations made by running transactions and the actual count of
526 : * free rt extents in the ondisk metadata. Transactions committed
527 : * during runtime can therefore contain a superblock update that
528 : * undercounts the number of free rt extents tracked in the rt bitmap.
529 : * A clean unmount record will have the correct frextents value since
530 : * there can be no other transactions running at that point.
531 : *
532 : * If we're mounting the rt volume after recovering the log, recompute
533 : * frextents from the rtbitmap file to fix the inconsistency.
534 : */
535 24282 : if (xfs_has_realtime(mp) && !xfs_is_clean(mp)) {
536 0 : error = xfs_rtalloc_reinit_frextents(mp);
537 0 : if (error)
538 0 : return error;
539 : }
540 :
541 : return 0;
542 : }
543 :
544 : static void
545 24082 : xfs_unmount_check(
546 : struct xfs_mount *mp)
547 : {
548 48164 : if (xfs_is_shutdown(mp))
549 : return;
550 :
551 24670 : if (percpu_counter_sum(&mp->m_ifree) >
552 12335 : percpu_counter_sum(&mp->m_icount)) {
553 0 : xfs_alert(mp, "ifree/icount mismatch at unmount");
554 0 : xfs_fs_mark_sick(mp, XFS_SICK_FS_COUNTERS);
555 : }
556 : }
557 :
558 : /*
559 : * Flush and reclaim dirty inodes in preparation for unmount. Inodes and
560 : * internal inode structures can be sitting in the CIL and AIL at this point,
561 : * so we need to unpin them, write them back and/or reclaim them before unmount
562 : * can proceed. In other words, callers are required to have inactivated all
563 : * inodes.
564 : *
565 : * An inode cluster that has been freed can have its buffer still pinned in
566 : * memory because the transaction is still sitting in a iclog. The stale inodes
567 : * on that buffer will be pinned to the buffer until the transaction hits the
568 : * disk and the callbacks run. Pushing the AIL will skip the stale inodes and
569 : * may never see the pinned buffer, so nothing will push out the iclog and
570 : * unpin the buffer.
571 : *
572 : * Hence we need to force the log to unpin everything first. However, log
573 : * forces don't wait for the discards they issue to complete, so we have to
574 : * explicitly wait for them to complete here as well.
575 : *
576 : * Then we can tell the world we are unmounting so that error handling knows
577 : * that the filesystem is going away and we should error out anything that we
578 : * have been retrying in the background. This will prevent never-ending
579 : * retries in AIL pushing from hanging the unmount.
580 : *
581 : * Finally, we can push the AIL to clean all the remaining dirty objects, then
582 : * reclaim the remaining inodes that are still in memory at this point in time.
583 : */
584 : static void
585 24110 : xfs_unmount_flush_inodes(
586 : struct xfs_mount *mp)
587 : {
588 24110 : xfs_log_force(mp, XFS_LOG_SYNC);
589 24110 : xfs_extent_busy_wait_all(mp);
590 24110 : flush_workqueue(xfs_discard_wq);
591 :
592 24110 : set_bit(XFS_OPSTATE_UNMOUNTING, &mp->m_opstate);
593 :
594 24110 : xfs_ail_push_all_sync(mp->m_ail);
595 24110 : xfs_inodegc_stop(mp);
596 24110 : cancel_delayed_work_sync(&mp->m_reclaim_work);
597 24110 : xfs_reclaim_inodes(mp);
598 24110 : xfs_health_unmount(mp);
599 24110 : }
600 :
601 : static void
602 24119 : xfs_mount_setup_inode_geom(
603 : struct xfs_mount *mp)
604 : {
605 24119 : struct xfs_ino_geometry *igeo = M_IGEO(mp);
606 :
607 24119 : igeo->attr_fork_offset = xfs_bmap_compute_attr_offset(mp);
608 24163 : ASSERT(igeo->attr_fork_offset < XFS_LITINO(mp));
609 :
610 24119 : xfs_ialloc_setup_geometry(mp);
611 24119 : }
612 :
613 : /* Compute maximum possible height for per-AG btree types for this fs. */
614 : static inline void
615 : xfs_agbtree_compute_maxlevels(
616 : struct xfs_mount *mp)
617 : {
618 24119 : unsigned int levels;
619 :
620 24119 : levels = max(mp->m_alloc_maxlevels, M_IGEO(mp)->inobt_maxlevels);
621 24119 : levels = max(levels, mp->m_rmap_maxlevels);
622 24119 : mp->m_agbtree_maxlevels = max(levels, mp->m_refc_maxlevels);
623 : }
624 :
625 : /*
626 : * This function does the following on an initial mount of a file system:
627 : * - reads the superblock from disk and init the mount struct
628 : * - if we're a 32-bit kernel, do a size check on the superblock
629 : * so we don't mount terabyte filesystems
630 : * - init mount struct realtime fields
631 : * - allocate inode hash table for fs
632 : * - init directory manager
633 : * - perform recovery and init the log manager
634 : */
635 : int
636 24125 : xfs_mountfs(
637 : struct xfs_mount *mp)
638 : {
639 24125 : struct xfs_sb *sbp = &(mp->m_sb);
640 24125 : struct xfs_inode *rip;
641 24125 : struct xfs_ino_geometry *igeo = M_IGEO(mp);
642 24125 : uint64_t resblks;
643 24125 : uint quotamount = 0;
644 24125 : uint quotaflags = 0;
645 24125 : int error = 0;
646 :
647 24125 : xfs_sb_mount_common(mp, sbp);
648 :
649 : /*
650 : * Check for a mismatched features2 values. Older kernels read & wrote
651 : * into the wrong sb offset for sb_features2 on some platforms due to
652 : * xfs_sb_t not being 64bit size aligned when sb_features2 was added,
653 : * which made older superblock reading/writing routines swap it as a
654 : * 64-bit value.
655 : *
656 : * For backwards compatibility, we make both slots equal.
657 : *
658 : * If we detect a mismatched field, we OR the set bits into the existing
659 : * features2 field in case it has already been modified; we don't want
660 : * to lose any features. We then update the bad location with the ORed
661 : * value so that older kernels will see any features2 flags. The
662 : * superblock writeback code ensures the new sb_features2 is copied to
663 : * sb_bad_features2 before it is logged or written to disk.
664 : */
665 24125 : if (xfs_sb_has_mismatched_features2(sbp)) {
666 4 : xfs_warn(mp, "correcting sb_features alignment problem");
667 4 : sbp->sb_features2 |= sbp->sb_bad_features2;
668 4 : mp->m_update_sb = true;
669 : }
670 :
671 :
672 : /* always use v2 inodes by default now */
673 24125 : if (!(mp->m_sb.sb_versionnum & XFS_SB_VERSION_NLINKBIT)) {
674 0 : mp->m_sb.sb_versionnum |= XFS_SB_VERSION_NLINKBIT;
675 0 : mp->m_features |= XFS_FEAT_NLINK;
676 0 : mp->m_update_sb = true;
677 : }
678 :
679 : /*
680 : * If we were given new sunit/swidth options, do some basic validation
681 : * checks and convert the incore dalign and swidth values to the
682 : * same units (FSB) that everything else uses. This /must/ happen
683 : * before computing the inode geometry.
684 : */
685 24125 : error = xfs_validate_new_dalign(mp);
686 24125 : if (error)
687 6 : goto out;
688 :
689 24119 : xfs_alloc_compute_maxlevels(mp);
690 24119 : xfs_bmap_compute_maxlevels(mp, XFS_DATA_FORK);
691 24119 : xfs_bmap_compute_maxlevels(mp, XFS_ATTR_FORK);
692 24119 : xfs_mount_setup_inode_geom(mp);
693 24119 : xfs_rmapbt_compute_maxlevels(mp);
694 24119 : xfs_refcountbt_compute_maxlevels(mp);
695 :
696 24119 : xfs_agbtree_compute_maxlevels(mp);
697 :
698 : /*
699 : * Check if sb_agblocks is aligned at stripe boundary. If sb_agblocks
700 : * is NOT aligned turn off m_dalign since allocator alignment is within
701 : * an ag, therefore ag has to be aligned at stripe boundary. Note that
702 : * we must compute the free space and rmap btree geometry before doing
703 : * this.
704 : */
705 24119 : error = xfs_update_alignment(mp);
706 24119 : if (error)
707 0 : goto out;
708 :
709 : /* enable fail_at_unmount as default */
710 24119 : mp->m_fail_unmount = true;
711 :
712 24119 : error = xfs_sysfs_init(&mp->m_kobj, &xfs_mp_ktype,
713 24119 : NULL, mp->m_super->s_id);
714 24119 : if (error)
715 0 : goto out;
716 :
717 24119 : error = xfs_sysfs_init(&mp->m_stats.xs_kobj, &xfs_stats_ktype,
718 : &mp->m_kobj, "stats");
719 24119 : if (error)
720 0 : goto out_remove_sysfs;
721 :
722 24119 : xchk_stats_register(mp->m_scrub_stats, mp->m_debugfs);
723 :
724 24119 : error = xfs_error_sysfs_init(mp);
725 24119 : if (error)
726 0 : goto out_remove_scrub_stats;
727 :
728 24119 : error = xfs_errortag_init(mp);
729 24119 : if (error)
730 0 : goto out_remove_error_sysfs;
731 :
732 24119 : error = xfs_uuid_mount(mp);
733 24119 : if (error)
734 4 : goto out_remove_errortag;
735 :
736 : /*
737 : * Update the preferred write size based on the information from the
738 : * on-disk superblock.
739 : */
740 24115 : mp->m_allocsize_log =
741 24115 : max_t(uint32_t, sbp->sb_blocklog, mp->m_allocsize_log);
742 24115 : mp->m_allocsize_blocks = 1U << (mp->m_allocsize_log - sbp->sb_blocklog);
743 :
744 : /* set the low space thresholds for dynamic preallocation */
745 24115 : xfs_set_low_space_thresholds(mp);
746 :
747 : /*
748 : * If enabled, sparse inode chunk alignment is expected to match the
749 : * cluster size. Full inode chunk alignment must match the chunk size,
750 : * but that is checked on sb read verification...
751 : */
752 24115 : if (xfs_has_sparseinodes(mp) &&
753 24073 : mp->m_sb.sb_spino_align !=
754 24073 : XFS_B_TO_FSBT(mp, igeo->inode_cluster_size_raw)) {
755 0 : xfs_warn(mp,
756 : "Sparse inode block alignment (%u) must match cluster size (%llu).",
757 : mp->m_sb.sb_spino_align,
758 : XFS_B_TO_FSBT(mp, igeo->inode_cluster_size_raw));
759 0 : error = -EINVAL;
760 0 : goto out_remove_uuid;
761 : }
762 :
763 : /*
764 : * Check that the data (and log if separate) is an ok size.
765 : */
766 24115 : error = xfs_check_sizes(mp);
767 24115 : if (error)
768 0 : goto out_remove_uuid;
769 :
770 : /*
771 : * Initialize realtime fields in the mount structure
772 : */
773 24115 : error = xfs_rtmount_init(mp);
774 24115 : if (error) {
775 0 : xfs_warn(mp, "RT mount failed");
776 0 : goto out_remove_uuid;
777 : }
778 :
779 : /*
780 : * Copies the low order bits of the timestamp and the randomly
781 : * set "sequence" number out of a UUID.
782 : */
783 24115 : mp->m_fixedfsid[0] =
784 24115 : (get_unaligned_be16(&sbp->sb_uuid.b[8]) << 16) |
785 24115 : get_unaligned_be16(&sbp->sb_uuid.b[4]);
786 24115 : mp->m_fixedfsid[1] = get_unaligned_be32(&sbp->sb_uuid.b[0]);
787 :
788 24115 : error = xfs_da_mount(mp);
789 24115 : if (error) {
790 0 : xfs_warn(mp, "Failed dir/attr init: %d", error);
791 0 : goto out_remove_uuid;
792 : }
793 :
794 : /*
795 : * Initialize the precomputed transaction reservations values.
796 : */
797 24115 : xfs_trans_init(mp);
798 :
799 : /*
800 : * Allocate and initialize the per-ag data.
801 : */
802 24115 : error = xfs_initialize_perag(mp, sbp->sb_agcount, mp->m_sb.sb_dblocks,
803 : &mp->m_maxagi);
804 24115 : if (error) {
805 0 : xfs_warn(mp, "Failed per-ag init: %d", error);
806 0 : goto out_free_dir;
807 : }
808 :
809 24115 : if (XFS_IS_CORRUPT(mp, !sbp->sb_logblocks)) {
810 0 : xfs_warn(mp, "no log defined");
811 0 : error = -EFSCORRUPTED;
812 0 : goto out_free_perag;
813 : }
814 :
815 24115 : error = xfs_inodegc_register_shrinker(mp);
816 24115 : if (error)
817 0 : goto out_fail_wait;
818 :
819 : /*
820 : * Log's mount-time initialization. The first part of recovery can place
821 : * some items on the AIL, to be handled when recovery is finished or
822 : * cancelled.
823 : */
824 24115 : error = xfs_log_mount(mp, mp->m_logdev_targp,
825 24115 : XFS_FSB_TO_DADDR(mp, sbp->sb_logstart),
826 24115 : XFS_FSB_TO_BB(mp, sbp->sb_logblocks));
827 24115 : if (error) {
828 8 : xfs_warn(mp, "log mount failed");
829 8 : goto out_inodegc_shrinker;
830 : }
831 :
832 : /* Enable background inode inactivation workers. */
833 24107 : xfs_inodegc_start(mp);
834 24107 : xfs_blockgc_start(mp);
835 :
836 : /*
837 : * Now that we've recovered any pending superblock feature bit
838 : * additions, we can finish setting up the attr2 behaviour for the
839 : * mount. The noattr2 option overrides the superblock flag, so only
840 : * check the superblock feature flag if the mount option is not set.
841 : */
842 24107 : if (xfs_has_noattr2(mp)) {
843 2 : mp->m_features &= ~XFS_FEAT_ATTR2;
844 24105 : } else if (!xfs_has_attr2(mp) &&
845 6 : (mp->m_sb.sb_features2 & XFS_SB_VERSION2_ATTR2BIT)) {
846 4 : mp->m_features |= XFS_FEAT_ATTR2;
847 : }
848 :
849 : /*
850 : * Get and sanity-check the root inode.
851 : * Save the pointer to it in the mount structure.
852 : */
853 24107 : error = xfs_iget(mp, NULL, sbp->sb_rootino, XFS_IGET_UNTRUSTED,
854 : XFS_ILOCK_EXCL, &rip);
855 24107 : if (error) {
856 4 : xfs_warn(mp,
857 : "Failed to read root inode 0x%llx, error %d",
858 : sbp->sb_rootino, -error);
859 4 : goto out_log_dealloc;
860 : }
861 :
862 24103 : ASSERT(rip != NULL);
863 :
864 24103 : if (XFS_IS_CORRUPT(mp, !S_ISDIR(VFS_I(rip)->i_mode))) {
865 0 : xfs_warn(mp, "corrupted root inode %llu: not a directory",
866 : (unsigned long long)rip->i_ino);
867 0 : xfs_iunlock(rip, XFS_ILOCK_EXCL);
868 0 : error = -EFSCORRUPTED;
869 0 : goto out_rele_rip;
870 : }
871 24103 : mp->m_rootip = rip; /* save it */
872 :
873 24103 : xfs_iunlock(rip, XFS_ILOCK_EXCL);
874 :
875 : /*
876 : * Initialize realtime inode pointers in the mount structure
877 : */
878 24103 : error = xfs_rtmount_inodes(mp);
879 24103 : if (error) {
880 : /*
881 : * Free up the root inode.
882 : */
883 0 : xfs_warn(mp, "failed to read RT inodes");
884 0 : goto out_rele_rip;
885 : }
886 :
887 : /* Make sure the summary counts are ok. */
888 24103 : error = xfs_check_summary_counts(mp);
889 24103 : if (error)
890 2 : goto out_rtunmount;
891 :
892 : /*
893 : * If this is a read-only mount defer the superblock updates until
894 : * the next remount into writeable mode. Otherwise we would never
895 : * perform the update e.g. for the root filesystem.
896 : */
897 24115 : if (mp->m_update_sb && !xfs_is_readonly(mp)) {
898 12 : error = xfs_sync_sb(mp, false);
899 12 : if (error) {
900 0 : xfs_warn(mp, "failed to write sb changes");
901 0 : goto out_rtunmount;
902 : }
903 : }
904 :
905 : /*
906 : * Initialise the XFS quota management subsystem for this mount
907 : */
908 24101 : if (XFS_IS_QUOTA_ON(mp)) {
909 22077 : error = xfs_qm_newmount(mp, "amount, "aflags);
910 22077 : if (error)
911 2 : goto out_rtunmount;
912 : } else {
913 : /*
914 : * If a file system had quotas running earlier, but decided to
915 : * mount without -o uquota/pquota/gquota options, revoke the
916 : * quotachecked license.
917 : */
918 2024 : if (mp->m_sb.sb_qflags & XFS_ALL_QUOTA_ACCT) {
919 34 : xfs_notice(mp, "resetting quota flags");
920 34 : error = xfs_mount_reset_sbqflags(mp);
921 34 : if (error)
922 0 : goto out_rtunmount;
923 : }
924 : }
925 :
926 : /*
927 : * Finish recovering the file system. This part needed to be delayed
928 : * until after the root and real-time bitmap inodes were consistently
929 : * read in. Temporarily create per-AG space reservations for metadata
930 : * btree shape changes because space freeing transactions (for inode
931 : * inactivation) require the per-AG reservation in lieu of reserving
932 : * blocks.
933 : */
934 24099 : error = xfs_fs_reserve_ag_blocks(mp);
935 24099 : if (error && error == -ENOSPC)
936 0 : xfs_warn(mp,
937 : "ENOSPC reserving per-AG metadata pool, log recovery may fail.");
938 24099 : error = xfs_log_mount_finish(mp);
939 24099 : xfs_fs_unreserve_ag_blocks(mp);
940 24099 : if (error) {
941 2 : xfs_warn(mp, "log mount finish failed");
942 2 : goto out_rtunmount;
943 : }
944 :
945 : /*
946 : * Now the log is fully replayed, we can transition to full read-only
947 : * mode for read-only mounts. This will sync all the metadata and clean
948 : * the log so that the recovery we just performed does not have to be
949 : * replayed again on the next mount.
950 : *
951 : * We use the same quiesce mechanism as the rw->ro remount, as they are
952 : * semantically identical operations.
953 : */
954 48194 : if (xfs_is_readonly(mp) && !xfs_has_norecovery(mp))
955 2171 : xfs_log_clean(mp);
956 :
957 : /*
958 : * Complete the quota initialisation, post-log-replay component.
959 : */
960 24097 : if (quotamount) {
961 3162 : ASSERT(mp->m_qflags == 0);
962 3162 : mp->m_qflags = quotaflags;
963 :
964 3162 : xfs_qm_mount_quotas(mp);
965 : }
966 :
967 : /*
968 : * Now we are mounted, reserve a small amount of unused space for
969 : * privileged transactions. This is needed so that transaction
970 : * space required for critical operations can dip into this pool
971 : * when at ENOSPC. This is needed for operations like create with
972 : * attr, unwritten extent conversion at ENOSPC, etc. Data allocations
973 : * are not allowed to use this reserved space.
974 : *
975 : * This may drive us straight to ENOSPC on mount, but that implies
976 : * we were already there on the last unmount. Warn if this occurs.
977 : */
978 48194 : if (!xfs_is_readonly(mp)) {
979 21916 : resblks = xfs_default_resblks(mp);
980 21916 : error = xfs_reserve_blocks(mp, &resblks, NULL);
981 21916 : if (error)
982 0 : xfs_warn(mp,
983 : "Unable to allocate reserve blocks. Continuing without reserve pool.");
984 :
985 : /* Reserve AG blocks for future btree expansion. */
986 21916 : error = xfs_fs_reserve_ag_blocks(mp);
987 21916 : if (error && error != -ENOSPC)
988 22 : goto out_agresv;
989 : }
990 :
991 : return 0;
992 :
993 : out_agresv:
994 22 : xfs_fs_unreserve_ag_blocks(mp);
995 22 : xfs_qm_unmount_quotas(mp);
996 28 : out_rtunmount:
997 28 : xfs_rtunmount_inodes(mp);
998 28 : out_rele_rip:
999 28 : xfs_irele(rip);
1000 : /* Clean out dquots that might be in memory after quotacheck. */
1001 28 : xfs_qm_unmount(mp);
1002 :
1003 : /*
1004 : * Inactivate all inodes that might still be in memory after a log
1005 : * intent recovery failure so that reclaim can free them. Metadata
1006 : * inodes and the root directory shouldn't need inactivation, but the
1007 : * mount failed for some reason, so pull down all the state and flee.
1008 : */
1009 28 : xfs_inodegc_flush(mp);
1010 :
1011 : /*
1012 : * Flush all inode reclamation work and flush the log.
1013 : * We have to do this /after/ rtunmount and qm_unmount because those
1014 : * two will have scheduled delayed reclaim for the rt/quota inodes.
1015 : *
1016 : * This is slightly different from the unmountfs call sequence
1017 : * because we could be tearing down a partially set up mount. In
1018 : * particular, if log_mount_finish fails we bail out without calling
1019 : * qm_unmount_quotas and therefore rely on qm_unmount to release the
1020 : * quota inodes.
1021 : */
1022 28 : xfs_unmount_flush_inodes(mp);
1023 32 : out_log_dealloc:
1024 32 : xfs_log_mount_cancel(mp);
1025 40 : out_inodegc_shrinker:
1026 40 : unregister_shrinker(&mp->m_inodegc_shrinker);
1027 40 : out_fail_wait:
1028 40 : if (mp->m_logdev_targp && mp->m_logdev_targp != mp->m_ddev_targp)
1029 0 : xfs_buftarg_drain(mp->m_logdev_targp);
1030 40 : xfs_buftarg_drain(mp->m_ddev_targp);
1031 40 : out_free_perag:
1032 40 : xfs_free_perag(mp);
1033 40 : out_free_dir:
1034 40 : xfs_da_unmount(mp);
1035 40 : out_remove_uuid:
1036 40 : xfs_uuid_unmount(mp);
1037 44 : out_remove_errortag:
1038 44 : xfs_errortag_del(mp);
1039 44 : out_remove_error_sysfs:
1040 44 : xfs_error_sysfs_del(mp);
1041 44 : out_remove_scrub_stats:
1042 44 : xchk_stats_unregister(mp->m_scrub_stats);
1043 44 : xfs_sysfs_del(&mp->m_stats.xs_kobj);
1044 44 : out_remove_sysfs:
1045 44 : xfs_sysfs_del(&mp->m_kobj);
1046 : out:
1047 : return error;
1048 : }
1049 :
1050 : /*
1051 : * This flushes out the inodes,dquots and the superblock, unmounts the
1052 : * log and makes sure that incore structures are freed.
1053 : */
1054 : void
1055 24082 : xfs_unmountfs(
1056 : struct xfs_mount *mp)
1057 : {
1058 24082 : uint64_t resblks;
1059 24082 : int error;
1060 :
1061 : /*
1062 : * Perform all on-disk metadata updates required to inactivate inodes
1063 : * that the VFS evicted earlier in the unmount process. Freeing inodes
1064 : * and discarding CoW fork preallocations can cause shape changes to
1065 : * the free inode and refcount btrees, respectively, so we must finish
1066 : * this before we discard the metadata space reservations. Metadata
1067 : * inodes and the root directory do not require inactivation.
1068 : */
1069 24082 : xfs_inodegc_flush(mp);
1070 :
1071 24082 : xfs_blockgc_stop(mp);
1072 24082 : xfs_fs_unreserve_ag_blocks(mp);
1073 24082 : xfs_qm_unmount_quotas(mp);
1074 24082 : xfs_rtunmount_inodes(mp);
1075 24082 : xfs_irele(mp->m_rootip);
1076 :
1077 24082 : xfs_unmount_flush_inodes(mp);
1078 :
1079 24082 : xfs_qm_unmount(mp);
1080 :
1081 : /*
1082 : * Unreserve any blocks we have so that when we unmount we don't account
1083 : * the reserved free space as used. This is really only necessary for
1084 : * lazy superblock counting because it trusts the incore superblock
1085 : * counters to be absolutely correct on clean unmount.
1086 : *
1087 : * We don't bother correcting this elsewhere for lazy superblock
1088 : * counting because on mount of an unclean filesystem we reconstruct the
1089 : * correct counter value and this is irrelevant.
1090 : *
1091 : * For non-lazy counter filesystems, this doesn't matter at all because
1092 : * we only every apply deltas to the superblock and hence the incore
1093 : * value does not matter....
1094 : */
1095 24082 : resblks = 0;
1096 24082 : error = xfs_reserve_blocks(mp, &resblks, NULL);
1097 24082 : if (error)
1098 0 : xfs_warn(mp, "Unable to free reserved block pool. "
1099 : "Freespace may not be correct on next mount.");
1100 24082 : xfs_unmount_check(mp);
1101 :
1102 24082 : xfs_log_unmount(mp);
1103 24082 : xfs_da_unmount(mp);
1104 24082 : xfs_uuid_unmount(mp);
1105 :
1106 : #if defined(DEBUG)
1107 24082 : xfs_errortag_clearall(mp);
1108 : #endif
1109 24082 : unregister_shrinker(&mp->m_inodegc_shrinker);
1110 24082 : xfs_free_perag(mp);
1111 :
1112 24082 : xfs_errortag_del(mp);
1113 24082 : xfs_error_sysfs_del(mp);
1114 24082 : xchk_stats_unregister(mp->m_scrub_stats);
1115 24082 : xfs_sysfs_del(&mp->m_stats.xs_kobj);
1116 24082 : xfs_sysfs_del(&mp->m_kobj);
1117 24082 : }
1118 :
1119 : /*
1120 : * Determine whether modifications can proceed. The caller specifies the minimum
1121 : * freeze level for which modifications should not be allowed. This allows
1122 : * certain operations to proceed while the freeze sequence is in progress, if
1123 : * necessary.
1124 : */
1125 : bool
1126 10500 : xfs_fs_writable(
1127 : struct xfs_mount *mp,
1128 : int level)
1129 : {
1130 10500 : ASSERT(level > SB_UNFROZEN);
1131 20904 : if ((mp->m_super->s_writers.frozen >= level) ||
1132 10404 : xfs_is_shutdown(mp) || xfs_is_readonly(mp))
1133 96 : return false;
1134 :
1135 : return true;
1136 : }
1137 :
1138 : /* Adjust m_fdblocks or m_frextents. */
1139 : int
1140 1379864507 : xfs_mod_freecounter(
1141 : struct xfs_mount *mp,
1142 : struct percpu_counter *counter,
1143 : int64_t delta,
1144 : bool rsvd)
1145 : {
1146 1379864507 : int64_t lcounter;
1147 1379864507 : long long res_used;
1148 1379864507 : uint64_t set_aside = 0;
1149 1379864507 : s32 batch;
1150 1379864507 : bool has_resv_pool;
1151 :
1152 1379864507 : ASSERT(counter == &mp->m_fdblocks || counter == &mp->m_frextents);
1153 1379864507 : has_resv_pool = (counter == &mp->m_fdblocks);
1154 1379864507 : if (rsvd)
1155 60214790 : ASSERT(has_resv_pool);
1156 :
1157 1379864507 : if (delta > 0) {
1158 : /*
1159 : * If the reserve pool is depleted, put blocks back into it
1160 : * first. Most of the time the pool is full.
1161 : */
1162 695006156 : if (likely(!has_resv_pool ||
1163 : mp->m_resblks == mp->m_resblks_avail)) {
1164 694823192 : percpu_counter_add(counter, delta);
1165 694823192 : return 0;
1166 : }
1167 :
1168 182964 : spin_lock(&mp->m_sb_lock);
1169 182965 : res_used = (long long)(mp->m_resblks - mp->m_resblks_avail);
1170 :
1171 182965 : if (res_used > delta) {
1172 38671 : mp->m_resblks_avail += delta;
1173 : } else {
1174 144294 : delta -= res_used;
1175 144294 : mp->m_resblks_avail = mp->m_resblks;
1176 144294 : percpu_counter_add(counter, delta);
1177 : }
1178 182965 : spin_unlock(&mp->m_sb_lock);
1179 182965 : return 0;
1180 : }
1181 :
1182 : /*
1183 : * Taking blocks away, need to be more accurate the closer we
1184 : * are to zero.
1185 : *
1186 : * If the counter has a value of less than 2 * max batch size,
1187 : * then make everything serialise as we are real close to
1188 : * ENOSPC.
1189 : */
1190 684858351 : if (__percpu_counter_compare(counter, 2 * XFS_FDBLOCKS_BATCH,
1191 : XFS_FDBLOCKS_BATCH) < 0)
1192 : batch = 1;
1193 : else
1194 670981505 : batch = XFS_FDBLOCKS_BATCH;
1195 :
1196 : /*
1197 : * Set aside allocbt blocks because these blocks are tracked as free
1198 : * space but not available for allocation. Technically this means that a
1199 : * single reservation cannot consume all remaining free space, but the
1200 : * ratio of allocbt blocks to usable free blocks should be rather small.
1201 : * The tradeoff without this is that filesystems that maintain high
1202 : * perag block reservations can over reserve physical block availability
1203 : * and fail physical allocation, which leads to much more serious
1204 : * problems (i.e. transaction abort, pagecache discards, etc.) than
1205 : * slightly premature -ENOSPC.
1206 : */
1207 684875866 : if (has_resv_pool)
1208 676026083 : set_aside = xfs_fdblocks_unavailable(mp);
1209 684875866 : percpu_counter_add_batch(counter, delta, batch);
1210 684883386 : if (__percpu_counter_compare(counter, set_aside,
1211 : XFS_FDBLOCKS_BATCH) >= 0) {
1212 : /* we had space! */
1213 : return 0;
1214 : }
1215 :
1216 : /*
1217 : * lock up the sb for dipping into reserves before releasing the space
1218 : * that took us to ENOSPC.
1219 : */
1220 7939332 : spin_lock(&mp->m_sb_lock);
1221 7939523 : percpu_counter_add(counter, -delta);
1222 7939523 : if (!has_resv_pool || !rsvd)
1223 7820652 : goto fdblocks_enospc;
1224 :
1225 118871 : lcounter = (long long)mp->m_resblks_avail + delta;
1226 118871 : if (lcounter >= 0) {
1227 114832 : mp->m_resblks_avail = lcounter;
1228 114832 : spin_unlock(&mp->m_sb_lock);
1229 114832 : return 0;
1230 : }
1231 4039 : xfs_warn_once(mp,
1232 : "Reserve blocks depleted! Consider increasing reserve pool size.");
1233 :
1234 7824691 : fdblocks_enospc:
1235 7824691 : spin_unlock(&mp->m_sb_lock);
1236 7824691 : return -ENOSPC;
1237 : }
1238 :
1239 : /*
1240 : * Used to free the superblock along various error paths.
1241 : */
1242 : void
1243 24148 : xfs_freesb(
1244 : struct xfs_mount *mp)
1245 : {
1246 24148 : struct xfs_buf *bp = mp->m_sb_bp;
1247 :
1248 24148 : xfs_buf_lock(bp);
1249 24148 : mp->m_sb_bp = NULL;
1250 24148 : xfs_buf_relse(bp);
1251 24148 : }
1252 :
1253 : /*
1254 : * If the underlying (data/log/rt) device is readonly, there are some
1255 : * operations that cannot proceed.
1256 : */
1257 : int
1258 14427 : xfs_dev_is_read_only(
1259 : struct xfs_mount *mp,
1260 : char *message)
1261 : {
1262 28850 : if (xfs_readonly_buftarg(mp->m_ddev_targp) ||
1263 14423 : xfs_readonly_buftarg(mp->m_logdev_targp) ||
1264 14423 : (mp->m_rtdev_targp && xfs_readonly_buftarg(mp->m_rtdev_targp))) {
1265 4 : xfs_notice(mp, "%s required on read-only device.", message);
1266 4 : xfs_notice(mp, "write access unavailable, cannot proceed.");
1267 4 : return -EROFS;
1268 : }
1269 : return 0;
1270 : }
1271 :
1272 : /* Force the summary counters to be recalculated at next mount. */
1273 : void
1274 215946 : xfs_force_summary_recalc(
1275 : struct xfs_mount *mp)
1276 : {
1277 215946 : if (!xfs_has_lazysbcount(mp))
1278 : return;
1279 :
1280 215946 : xfs_fs_mark_sick(mp, XFS_SICK_FS_COUNTERS);
1281 215948 : xfs_fs_mark_checked(mp, XFS_SICK_FS_COUNTERS);
1282 : }
1283 :
1284 : /*
1285 : * Enable a log incompat feature flag in the primary superblock. The caller
1286 : * cannot have any other transactions in progress.
1287 : */
1288 : int
1289 107417 : xfs_add_incompat_log_feature(
1290 : struct xfs_mount *mp,
1291 : uint32_t feature)
1292 : {
1293 107417 : struct xfs_dsb *dsb;
1294 107417 : int error;
1295 :
1296 214835 : ASSERT(hweight32(feature) == 1);
1297 107418 : ASSERT(!(feature & XFS_SB_FEAT_INCOMPAT_LOG_UNKNOWN));
1298 :
1299 : /*
1300 : * Force the log to disk and kick the background AIL thread to reduce
1301 : * the chances that the bwrite will stall waiting for the AIL to unpin
1302 : * the primary superblock buffer. This isn't a data integrity
1303 : * operation, so we don't need a synchronous push.
1304 : */
1305 107418 : error = xfs_log_force(mp, XFS_LOG_SYNC);
1306 107410 : if (error)
1307 : return error;
1308 107401 : xfs_ail_push_all(mp->m_ail);
1309 :
1310 : /*
1311 : * Lock the primary superblock buffer to serialize all callers that
1312 : * are trying to set feature bits.
1313 : */
1314 107415 : xfs_buf_lock(mp->m_sb_bp);
1315 107428 : xfs_buf_hold(mp->m_sb_bp);
1316 :
1317 214856 : if (xfs_is_shutdown(mp)) {
1318 0 : error = -EIO;
1319 0 : goto rele;
1320 : }
1321 :
1322 107428 : if (xfs_sb_has_incompat_log_feature(&mp->m_sb, feature))
1323 54450 : goto rele;
1324 :
1325 : /*
1326 : * Write the primary superblock to disk immediately, because we need
1327 : * the log_incompat bit to be set in the primary super now to protect
1328 : * the log items that we're going to commit later.
1329 : */
1330 52978 : dsb = mp->m_sb_bp->b_addr;
1331 52978 : xfs_sb_to_disk(dsb, &mp->m_sb);
1332 52978 : dsb->sb_features_log_incompat |= cpu_to_be32(feature);
1333 52978 : error = xfs_bwrite(mp->m_sb_bp);
1334 52978 : if (error)
1335 177 : goto shutdown;
1336 :
1337 : /*
1338 : * Add the feature bits to the incore superblock before we unlock the
1339 : * buffer.
1340 : */
1341 52801 : xfs_sb_add_incompat_log_features(&mp->m_sb, feature);
1342 52801 : xfs_buf_relse(mp->m_sb_bp);
1343 :
1344 : /* Log the superblock to disk. */
1345 52801 : return xfs_sync_sb(mp, false);
1346 : shutdown:
1347 177 : xfs_force_shutdown(mp, SHUTDOWN_META_IO_ERROR);
1348 54627 : rele:
1349 54627 : xfs_buf_relse(mp->m_sb_bp);
1350 54627 : return error;
1351 : }
1352 :
1353 : /*
1354 : * Clear all the log incompat flags from the superblock.
1355 : *
1356 : * The caller cannot be in a transaction, must ensure that the log does not
1357 : * contain any log items protected by any log incompat bit, and must ensure
1358 : * that there are no other threads that depend on the state of the log incompat
1359 : * feature flags in the primary super.
1360 : *
1361 : * Returns true if the superblock is dirty.
1362 : */
1363 : bool
1364 74441 : xfs_clear_incompat_log_features(
1365 : struct xfs_mount *mp,
1366 : uint32_t features)
1367 : {
1368 74441 : bool ret = false;
1369 :
1370 74441 : if (!xfs_has_crc(mp) ||
1371 57025 : !xfs_sb_has_incompat_log_feature(&mp->m_sb, features) ||
1372 : xfs_is_shutdown(mp))
1373 : return false;
1374 :
1375 : /*
1376 : * Update the incore superblock. We synchronize on the primary super
1377 : * buffer lock to be consistent with the add function, though at least
1378 : * in theory this shouldn't be necessary.
1379 : */
1380 47134 : xfs_buf_lock(mp->m_sb_bp);
1381 47134 : xfs_buf_hold(mp->m_sb_bp);
1382 :
1383 47134 : if (xfs_sb_has_incompat_log_feature(&mp->m_sb, features)) {
1384 47134 : xfs_sb_remove_incompat_log_features(&mp->m_sb, features);
1385 47134 : ret = true;
1386 : }
1387 :
1388 47134 : xfs_buf_relse(mp->m_sb_bp);
1389 47134 : return ret;
1390 : }
1391 :
1392 : /*
1393 : * Update the in-core delayed block counter.
1394 : *
1395 : * We prefer to update the counter without having to take a spinlock for every
1396 : * counter update (i.e. batching). Each change to delayed allocation
1397 : * reservations can change can easily exceed the default percpu counter
1398 : * batching, so we use a larger batch factor here.
1399 : *
1400 : * Note that we don't currently have any callers requiring fast summation
1401 : * (e.g. percpu_counter_read) so we can use a big batch value here.
1402 : */
1403 : #define XFS_DELALLOC_BATCH (4096)
1404 : void
1405 52404951 : xfs_mod_delalloc(
1406 : struct xfs_mount *mp,
1407 : int64_t delta)
1408 : {
1409 52404951 : percpu_counter_add_batch(&mp->m_delalloc_blks, delta,
1410 : XFS_DELALLOC_BATCH);
1411 52404333 : }
|
