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