~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/xfs/xfs_mount.c

Version: ~ [ linux-5.8 ] ~ [ linux-5.7.14 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.57 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.138 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.193 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.232 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.232 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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_error.h"
 25 #include "xfs_quota.h"
 26 #include "xfs_fsops.h"
 27 #include "xfs_icache.h"
 28 #include "xfs_sysfs.h"
 29 #include "xfs_rmap_btree.h"
 30 #include "xfs_refcount_btree.h"
 31 #include "xfs_reflink.h"
 32 #include "xfs_extent_busy.h"
 33 #include "xfs_health.h"
 34 #include "xfs_trace.h"
 35 
 36 static DEFINE_MUTEX(xfs_uuid_table_mutex);
 37 static int xfs_uuid_table_size;
 38 static uuid_t *xfs_uuid_table;
 39 
 40 void
 41 xfs_uuid_table_free(void)
 42 {
 43         if (xfs_uuid_table_size == 0)
 44                 return;
 45         kmem_free(xfs_uuid_table);
 46         xfs_uuid_table = NULL;
 47         xfs_uuid_table_size = 0;
 48 }
 49 
 50 /*
 51  * See if the UUID is unique among mounted XFS filesystems.
 52  * Mount fails if UUID is nil or a FS with the same UUID is already mounted.
 53  */
 54 STATIC int
 55 xfs_uuid_mount(
 56         struct xfs_mount        *mp)
 57 {
 58         uuid_t                  *uuid = &mp->m_sb.sb_uuid;
 59         int                     hole, i;
 60 
 61         /* Publish UUID in struct super_block */
 62         uuid_copy(&mp->m_super->s_uuid, uuid);
 63 
 64         if (mp->m_flags & XFS_MOUNT_NOUUID)
 65                 return 0;
 66 
 67         if (uuid_is_null(uuid)) {
 68                 xfs_warn(mp, "Filesystem has null UUID - can't mount");
 69                 return -EINVAL;
 70         }
 71 
 72         mutex_lock(&xfs_uuid_table_mutex);
 73         for (i = 0, hole = -1; i < xfs_uuid_table_size; i++) {
 74                 if (uuid_is_null(&xfs_uuid_table[i])) {
 75                         hole = i;
 76                         continue;
 77                 }
 78                 if (uuid_equal(uuid, &xfs_uuid_table[i]))
 79                         goto out_duplicate;
 80         }
 81 
 82         if (hole < 0) {
 83                 xfs_uuid_table = kmem_realloc(xfs_uuid_table,
 84                         (xfs_uuid_table_size + 1) * sizeof(*xfs_uuid_table),
 85                         0);
 86                 hole = xfs_uuid_table_size++;
 87         }
 88         xfs_uuid_table[hole] = *uuid;
 89         mutex_unlock(&xfs_uuid_table_mutex);
 90 
 91         return 0;
 92 
 93  out_duplicate:
 94         mutex_unlock(&xfs_uuid_table_mutex);
 95         xfs_warn(mp, "Filesystem has duplicate UUID %pU - can't mount", uuid);
 96         return -EINVAL;
 97 }
 98 
 99 STATIC void
100 xfs_uuid_unmount(
101         struct xfs_mount        *mp)
102 {
103         uuid_t                  *uuid = &mp->m_sb.sb_uuid;
104         int                     i;
105 
106         if (mp->m_flags & XFS_MOUNT_NOUUID)
107                 return;
108 
109         mutex_lock(&xfs_uuid_table_mutex);
110         for (i = 0; i < xfs_uuid_table_size; i++) {
111                 if (uuid_is_null(&xfs_uuid_table[i]))
112                         continue;
113                 if (!uuid_equal(uuid, &xfs_uuid_table[i]))
114                         continue;
115                 memset(&xfs_uuid_table[i], 0, sizeof(uuid_t));
116                 break;
117         }
118         ASSERT(i < xfs_uuid_table_size);
119         mutex_unlock(&xfs_uuid_table_mutex);
120 }
121 
122 
123 STATIC void
124 __xfs_free_perag(
125         struct rcu_head *head)
126 {
127         struct xfs_perag *pag = container_of(head, struct xfs_perag, rcu_head);
128 
129         ASSERT(atomic_read(&pag->pag_ref) == 0);
130         kmem_free(pag);
131 }
132 
133 /*
134  * Free up the per-ag resources associated with the mount structure.
135  */
136 STATIC void
137 xfs_free_perag(
138         xfs_mount_t     *mp)
139 {
140         xfs_agnumber_t  agno;
141         struct xfs_perag *pag;
142 
143         for (agno = 0; agno < mp->m_sb.sb_agcount; agno++) {
144                 spin_lock(&mp->m_perag_lock);
145                 pag = radix_tree_delete(&mp->m_perag_tree, agno);
146                 spin_unlock(&mp->m_perag_lock);
147                 ASSERT(pag);
148                 ASSERT(atomic_read(&pag->pag_ref) == 0);
149                 xfs_iunlink_destroy(pag);
150                 xfs_buf_hash_destroy(pag);
151                 mutex_destroy(&pag->pag_ici_reclaim_lock);
152                 call_rcu(&pag->rcu_head, __xfs_free_perag);
153         }
154 }
155 
156 /*
157  * Check size of device based on the (data/realtime) block count.
158  * Note: this check is used by the growfs code as well as mount.
159  */
160 int
161 xfs_sb_validate_fsb_count(
162         xfs_sb_t        *sbp,
163         uint64_t        nblocks)
164 {
165         ASSERT(PAGE_SHIFT >= sbp->sb_blocklog);
166         ASSERT(sbp->sb_blocklog >= BBSHIFT);
167 
168         /* Limited by ULONG_MAX of page cache index */
169         if (nblocks >> (PAGE_SHIFT - sbp->sb_blocklog) > ULONG_MAX)
170                 return -EFBIG;
171         return 0;
172 }
173 
174 int
175 xfs_initialize_perag(
176         xfs_mount_t     *mp,
177         xfs_agnumber_t  agcount,
178         xfs_agnumber_t  *maxagi)
179 {
180         xfs_agnumber_t  index;
181         xfs_agnumber_t  first_initialised = NULLAGNUMBER;
182         xfs_perag_t     *pag;
183         int             error = -ENOMEM;
184 
185         /*
186          * Walk the current per-ag tree so we don't try to initialise AGs
187          * that already exist (growfs case). Allocate and insert all the
188          * AGs we don't find ready for initialisation.
189          */
190         for (index = 0; index < agcount; index++) {
191                 pag = xfs_perag_get(mp, index);
192                 if (pag) {
193                         xfs_perag_put(pag);
194                         continue;
195                 }
196 
197                 pag = kmem_zalloc(sizeof(*pag), KM_MAYFAIL);
198                 if (!pag)
199                         goto out_unwind_new_pags;
200                 pag->pag_agno = index;
201                 pag->pag_mount = mp;
202                 spin_lock_init(&pag->pag_ici_lock);
203                 mutex_init(&pag->pag_ici_reclaim_lock);
204                 INIT_RADIX_TREE(&pag->pag_ici_root, GFP_ATOMIC);
205                 if (xfs_buf_hash_init(pag))
206                         goto out_free_pag;
207                 init_waitqueue_head(&pag->pagb_wait);
208                 spin_lock_init(&pag->pagb_lock);
209                 pag->pagb_count = 0;
210                 pag->pagb_tree = RB_ROOT;
211 
212                 if (radix_tree_preload(GFP_NOFS))
213                         goto out_hash_destroy;
214 
215                 spin_lock(&mp->m_perag_lock);
216                 if (radix_tree_insert(&mp->m_perag_tree, index, pag)) {
217                         WARN_ON_ONCE(1);
218                         spin_unlock(&mp->m_perag_lock);
219                         radix_tree_preload_end();
220                         error = -EEXIST;
221                         goto out_hash_destroy;
222                 }
223                 spin_unlock(&mp->m_perag_lock);
224                 radix_tree_preload_end();
225                 /* first new pag is fully initialized */
226                 if (first_initialised == NULLAGNUMBER)
227                         first_initialised = index;
228                 error = xfs_iunlink_init(pag);
229                 if (error)
230                         goto out_hash_destroy;
231                 spin_lock_init(&pag->pag_state_lock);
232         }
233 
234         index = xfs_set_inode_alloc(mp, agcount);
235 
236         if (maxagi)
237                 *maxagi = index;
238 
239         mp->m_ag_prealloc_blocks = xfs_prealloc_blocks(mp);
240         return 0;
241 
242 out_hash_destroy:
243         xfs_buf_hash_destroy(pag);
244 out_free_pag:
245         mutex_destroy(&pag->pag_ici_reclaim_lock);
246         kmem_free(pag);
247 out_unwind_new_pags:
248         /* unwind any prior newly initialized pags */
249         for (index = first_initialised; index < agcount; index++) {
250                 pag = radix_tree_delete(&mp->m_perag_tree, index);
251                 if (!pag)
252                         break;
253                 xfs_buf_hash_destroy(pag);
254                 xfs_iunlink_destroy(pag);
255                 mutex_destroy(&pag->pag_ici_reclaim_lock);
256                 kmem_free(pag);
257         }
258         return error;
259 }
260 
261 /*
262  * xfs_readsb
263  *
264  * Does the initial read of the superblock.
265  */
266 int
267 xfs_readsb(
268         struct xfs_mount *mp,
269         int             flags)
270 {
271         unsigned int    sector_size;
272         struct xfs_buf  *bp;
273         struct xfs_sb   *sbp = &mp->m_sb;
274         int             error;
275         int             loud = !(flags & XFS_MFSI_QUIET);
276         const struct xfs_buf_ops *buf_ops;
277 
278         ASSERT(mp->m_sb_bp == NULL);
279         ASSERT(mp->m_ddev_targp != NULL);
280 
281         /*
282          * For the initial read, we must guess at the sector
283          * size based on the block device.  It's enough to
284          * get the sb_sectsize out of the superblock and
285          * then reread with the proper length.
286          * We don't verify it yet, because it may not be complete.
287          */
288         sector_size = xfs_getsize_buftarg(mp->m_ddev_targp);
289         buf_ops = NULL;
290 
291         /*
292          * Allocate a (locked) buffer to hold the superblock. This will be kept
293          * around at all times to optimize access to the superblock. Therefore,
294          * set XBF_NO_IOACCT to make sure it doesn't hold the buftarg count
295          * elevated.
296          */
297 reread:
298         error = xfs_buf_read_uncached(mp->m_ddev_targp, XFS_SB_DADDR,
299                                       BTOBB(sector_size), XBF_NO_IOACCT, &bp,
300                                       buf_ops);
301         if (error) {
302                 if (loud)
303                         xfs_warn(mp, "SB validate failed with error %d.", error);
304                 /* bad CRC means corrupted metadata */
305                 if (error == -EFSBADCRC)
306                         error = -EFSCORRUPTED;
307                 return error;
308         }
309 
310         /*
311          * Initialize the mount structure from the superblock.
312          */
313         xfs_sb_from_disk(sbp, bp->b_addr);
314 
315         /*
316          * If we haven't validated the superblock, do so now before we try
317          * to check the sector size and reread the superblock appropriately.
318          */
319         if (sbp->sb_magicnum != XFS_SB_MAGIC) {
320                 if (loud)
321                         xfs_warn(mp, "Invalid superblock magic number");
322                 error = -EINVAL;
323                 goto release_buf;
324         }
325 
326         /*
327          * We must be able to do sector-sized and sector-aligned IO.
328          */
329         if (sector_size > sbp->sb_sectsize) {
330                 if (loud)
331                         xfs_warn(mp, "device supports %u byte sectors (not %u)",
332                                 sector_size, sbp->sb_sectsize);
333                 error = -ENOSYS;
334                 goto release_buf;
335         }
336 
337         if (buf_ops == NULL) {
338                 /*
339                  * Re-read the superblock so the buffer is correctly sized,
340                  * and properly verified.
341                  */
342                 xfs_buf_relse(bp);
343                 sector_size = sbp->sb_sectsize;
344                 buf_ops = loud ? &xfs_sb_buf_ops : &xfs_sb_quiet_buf_ops;
345                 goto reread;
346         }
347 
348         xfs_reinit_percpu_counters(mp);
349 
350         /* no need to be quiet anymore, so reset the buf ops */
351         bp->b_ops = &xfs_sb_buf_ops;
352 
353         mp->m_sb_bp = bp;
354         xfs_buf_unlock(bp);
355         return 0;
356 
357 release_buf:
358         xfs_buf_relse(bp);
359         return error;
360 }
361 
362 /*
363  * If the sunit/swidth change would move the precomputed root inode value, we
364  * must reject the ondisk change because repair will stumble over that.
365  * However, we allow the mount to proceed because we never rejected this
366  * combination before.  Returns true to update the sb, false otherwise.
367  */
368 static inline int
369 xfs_check_new_dalign(
370         struct xfs_mount        *mp,
371         int                     new_dalign,
372         bool                    *update_sb)
373 {
374         struct xfs_sb           *sbp = &mp->m_sb;
375         xfs_ino_t               calc_ino;
376 
377         calc_ino = xfs_ialloc_calc_rootino(mp, new_dalign);
378         trace_xfs_check_new_dalign(mp, new_dalign, calc_ino);
379 
380         if (sbp->sb_rootino == calc_ino) {
381                 *update_sb = true;
382                 return 0;
383         }
384 
385         xfs_warn(mp,
386 "Cannot change stripe alignment; would require moving root inode.");
387 
388         /*
389          * XXX: Next time we add a new incompat feature, this should start
390          * returning -EINVAL to fail the mount.  Until then, spit out a warning
391          * that we're ignoring the administrator's instructions.
392          */
393         xfs_warn(mp, "Skipping superblock stripe alignment update.");
394         *update_sb = false;
395         return 0;
396 }
397 
398 /*
399  * If we were provided with new sunit/swidth values as mount options, make sure
400  * that they pass basic alignment and superblock feature checks, and convert
401  * them into the same units (FSB) that everything else expects.  This step
402  * /must/ be done before computing the inode geometry.
403  */
404 STATIC int
405 xfs_validate_new_dalign(
406         struct xfs_mount        *mp)
407 {
408         if (mp->m_dalign == 0)
409                 return 0;
410 
411         /*
412          * If stripe unit and stripe width are not multiples
413          * of the fs blocksize turn off alignment.
414          */
415         if ((BBTOB(mp->m_dalign) & mp->m_blockmask) ||
416             (BBTOB(mp->m_swidth) & mp->m_blockmask)) {
417                 xfs_warn(mp,
418         "alignment check failed: sunit/swidth vs. blocksize(%d)",
419                         mp->m_sb.sb_blocksize);
420                 return -EINVAL;
421         } else {
422                 /*
423                  * Convert the stripe unit and width to FSBs.
424                  */
425                 mp->m_dalign = XFS_BB_TO_FSBT(mp, mp->m_dalign);
426                 if (mp->m_dalign && (mp->m_sb.sb_agblocks % mp->m_dalign)) {
427                         xfs_warn(mp,
428                 "alignment check failed: sunit/swidth vs. agsize(%d)",
429                                  mp->m_sb.sb_agblocks);
430                         return -EINVAL;
431                 } else if (mp->m_dalign) {
432                         mp->m_swidth = XFS_BB_TO_FSBT(mp, mp->m_swidth);
433                 } else {
434                         xfs_warn(mp,
435                 "alignment check failed: sunit(%d) less than bsize(%d)",
436                                  mp->m_dalign, mp->m_sb.sb_blocksize);
437                         return -EINVAL;
438                 }
439         }
440 
441         if (!xfs_sb_version_hasdalign(&mp->m_sb)) {
442                 xfs_warn(mp,
443 "cannot change alignment: superblock does not support data alignment");
444                 return -EINVAL;
445         }
446 
447         return 0;
448 }
449 
450 /* Update alignment values based on mount options and sb values. */
451 STATIC int
452 xfs_update_alignment(
453         struct xfs_mount        *mp)
454 {
455         struct xfs_sb           *sbp = &mp->m_sb;
456 
457         if (mp->m_dalign) {
458                 bool            update_sb;
459                 int             error;
460 
461                 if (sbp->sb_unit == mp->m_dalign &&
462                     sbp->sb_width == mp->m_swidth)
463                         return 0;
464 
465                 error = xfs_check_new_dalign(mp, mp->m_dalign, &update_sb);
466                 if (error || !update_sb)
467                         return error;
468 
469                 sbp->sb_unit = mp->m_dalign;
470                 sbp->sb_width = mp->m_swidth;
471                 mp->m_update_sb = true;
472         } else if ((mp->m_flags & XFS_MOUNT_NOALIGN) != XFS_MOUNT_NOALIGN &&
473                     xfs_sb_version_hasdalign(&mp->m_sb)) {
474                 mp->m_dalign = sbp->sb_unit;
475                 mp->m_swidth = sbp->sb_width;
476         }
477 
478         return 0;
479 }
480 
481 /*
482  * precalculate the low space thresholds for dynamic speculative preallocation.
483  */
484 void
485 xfs_set_low_space_thresholds(
486         struct xfs_mount        *mp)
487 {
488         int i;
489 
490         for (i = 0; i < XFS_LOWSP_MAX; i++) {
491                 uint64_t space = mp->m_sb.sb_dblocks;
492 
493                 do_div(space, 100);
494                 mp->m_low_space[i] = space * (i + 1);
495         }
496 }
497 
498 /*
499  * Check that the data (and log if separate) is an ok size.
500  */
501 STATIC int
502 xfs_check_sizes(
503         struct xfs_mount *mp)
504 {
505         struct xfs_buf  *bp;
506         xfs_daddr_t     d;
507         int             error;
508 
509         d = (xfs_daddr_t)XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks);
510         if (XFS_BB_TO_FSB(mp, d) != mp->m_sb.sb_dblocks) {
511                 xfs_warn(mp, "filesystem size mismatch detected");
512                 return -EFBIG;
513         }
514         error = xfs_buf_read_uncached(mp->m_ddev_targp,
515                                         d - XFS_FSS_TO_BB(mp, 1),
516                                         XFS_FSS_TO_BB(mp, 1), 0, &bp, NULL);
517         if (error) {
518                 xfs_warn(mp, "last sector read failed");
519                 return error;
520         }
521         xfs_buf_relse(bp);
522 
523         if (mp->m_logdev_targp == mp->m_ddev_targp)
524                 return 0;
525 
526         d = (xfs_daddr_t)XFS_FSB_TO_BB(mp, mp->m_sb.sb_logblocks);
527         if (XFS_BB_TO_FSB(mp, d) != mp->m_sb.sb_logblocks) {
528                 xfs_warn(mp, "log size mismatch detected");
529                 return -EFBIG;
530         }
531         error = xfs_buf_read_uncached(mp->m_logdev_targp,
532                                         d - XFS_FSB_TO_BB(mp, 1),
533                                         XFS_FSB_TO_BB(mp, 1), 0, &bp, NULL);
534         if (error) {
535                 xfs_warn(mp, "log device read failed");
536                 return error;
537         }
538         xfs_buf_relse(bp);
539         return 0;
540 }
541 
542 /*
543  * Clear the quotaflags in memory and in the superblock.
544  */
545 int
546 xfs_mount_reset_sbqflags(
547         struct xfs_mount        *mp)
548 {
549         mp->m_qflags = 0;
550 
551         /* It is OK to look at sb_qflags in the mount path without m_sb_lock. */
552         if (mp->m_sb.sb_qflags == 0)
553                 return 0;
554         spin_lock(&mp->m_sb_lock);
555         mp->m_sb.sb_qflags = 0;
556         spin_unlock(&mp->m_sb_lock);
557 
558         if (!xfs_fs_writable(mp, SB_FREEZE_WRITE))
559                 return 0;
560 
561         return xfs_sync_sb(mp, false);
562 }
563 
564 uint64_t
565 xfs_default_resblks(xfs_mount_t *mp)
566 {
567         uint64_t resblks;
568 
569         /*
570          * We default to 5% or 8192 fsbs of space reserved, whichever is
571          * smaller.  This is intended to cover concurrent allocation
572          * transactions when we initially hit enospc. These each require a 4
573          * block reservation. Hence by default we cover roughly 2000 concurrent
574          * allocation reservations.
575          */
576         resblks = mp->m_sb.sb_dblocks;
577         do_div(resblks, 20);
578         resblks = min_t(uint64_t, resblks, 8192);
579         return resblks;
580 }
581 
582 /* Ensure the summary counts are correct. */
583 STATIC int
584 xfs_check_summary_counts(
585         struct xfs_mount        *mp)
586 {
587         /*
588          * The AG0 superblock verifier rejects in-progress filesystems,
589          * so we should never see the flag set this far into mounting.
590          */
591         if (mp->m_sb.sb_inprogress) {
592                 xfs_err(mp, "sb_inprogress set after log recovery??");
593                 WARN_ON(1);
594                 return -EFSCORRUPTED;
595         }
596 
597         /*
598          * Now the log is mounted, we know if it was an unclean shutdown or
599          * not. If it was, with the first phase of recovery has completed, we
600          * have consistent AG blocks on disk. We have not recovered EFIs yet,
601          * but they are recovered transactionally in the second recovery phase
602          * later.
603          *
604          * If the log was clean when we mounted, we can check the summary
605          * counters.  If any of them are obviously incorrect, we can recompute
606          * them from the AGF headers in the next step.
607          */
608         if (XFS_LAST_UNMOUNT_WAS_CLEAN(mp) &&
609             (mp->m_sb.sb_fdblocks > mp->m_sb.sb_dblocks ||
610              !xfs_verify_icount(mp, mp->m_sb.sb_icount) ||
611              mp->m_sb.sb_ifree > mp->m_sb.sb_icount))
612                 xfs_fs_mark_sick(mp, XFS_SICK_FS_COUNTERS);
613 
614         /*
615          * We can safely re-initialise incore superblock counters from the
616          * per-ag data. These may not be correct if the filesystem was not
617          * cleanly unmounted, so we waited for recovery to finish before doing
618          * this.
619          *
620          * If the filesystem was cleanly unmounted or the previous check did
621          * not flag anything weird, then we can trust the values in the
622          * superblock to be correct and we don't need to do anything here.
623          * Otherwise, recalculate the summary counters.
624          */
625         if ((!xfs_sb_version_haslazysbcount(&mp->m_sb) ||
626              XFS_LAST_UNMOUNT_WAS_CLEAN(mp)) &&
627             !xfs_fs_has_sickness(mp, XFS_SICK_FS_COUNTERS))
628                 return 0;
629 
630         return xfs_initialize_perag_data(mp, mp->m_sb.sb_agcount);
631 }
632 
633 /*
634  * This function does the following on an initial mount of a file system:
635  *      - reads the superblock from disk and init the mount struct
636  *      - if we're a 32-bit kernel, do a size check on the superblock
637  *              so we don't mount terabyte filesystems
638  *      - init mount struct realtime fields
639  *      - allocate inode hash table for fs
640  *      - init directory manager
641  *      - perform recovery and init the log manager
642  */
643 int
644 xfs_mountfs(
645         struct xfs_mount        *mp)
646 {
647         struct xfs_sb           *sbp = &(mp->m_sb);
648         struct xfs_inode        *rip;
649         struct xfs_ino_geometry *igeo = M_IGEO(mp);
650         uint64_t                resblks;
651         uint                    quotamount = 0;
652         uint                    quotaflags = 0;
653         int                     error = 0;
654 
655         xfs_sb_mount_common(mp, sbp);
656 
657         /*
658          * Check for a mismatched features2 values.  Older kernels read & wrote
659          * into the wrong sb offset for sb_features2 on some platforms due to
660          * xfs_sb_t not being 64bit size aligned when sb_features2 was added,
661          * which made older superblock reading/writing routines swap it as a
662          * 64-bit value.
663          *
664          * For backwards compatibility, we make both slots equal.
665          *
666          * If we detect a mismatched field, we OR the set bits into the existing
667          * features2 field in case it has already been modified; we don't want
668          * to lose any features.  We then update the bad location with the ORed
669          * value so that older kernels will see any features2 flags. The
670          * superblock writeback code ensures the new sb_features2 is copied to
671          * sb_bad_features2 before it is logged or written to disk.
672          */
673         if (xfs_sb_has_mismatched_features2(sbp)) {
674                 xfs_warn(mp, "correcting sb_features alignment problem");
675                 sbp->sb_features2 |= sbp->sb_bad_features2;
676                 mp->m_update_sb = true;
677 
678                 /*
679                  * Re-check for ATTR2 in case it was found in bad_features2
680                  * slot.
681                  */
682                 if (xfs_sb_version_hasattr2(&mp->m_sb) &&
683                    !(mp->m_flags & XFS_MOUNT_NOATTR2))
684                         mp->m_flags |= XFS_MOUNT_ATTR2;
685         }
686 
687         if (xfs_sb_version_hasattr2(&mp->m_sb) &&
688            (mp->m_flags & XFS_MOUNT_NOATTR2)) {
689                 xfs_sb_version_removeattr2(&mp->m_sb);
690                 mp->m_update_sb = true;
691 
692                 /* update sb_versionnum for the clearing of the morebits */
693                 if (!sbp->sb_features2)
694                         mp->m_update_sb = true;
695         }
696 
697         /* always use v2 inodes by default now */
698         if (!(mp->m_sb.sb_versionnum & XFS_SB_VERSION_NLINKBIT)) {
699                 mp->m_sb.sb_versionnum |= XFS_SB_VERSION_NLINKBIT;
700                 mp->m_update_sb = true;
701         }
702 
703         /*
704          * If we were given new sunit/swidth options, do some basic validation
705          * checks and convert the incore dalign and swidth values to the
706          * same units (FSB) that everything else uses.  This /must/ happen
707          * before computing the inode geometry.
708          */
709         error = xfs_validate_new_dalign(mp);
710         if (error)
711                 goto out;
712 
713         xfs_alloc_compute_maxlevels(mp);
714         xfs_bmap_compute_maxlevels(mp, XFS_DATA_FORK);
715         xfs_bmap_compute_maxlevels(mp, XFS_ATTR_FORK);
716         xfs_ialloc_setup_geometry(mp);
717         xfs_rmapbt_compute_maxlevels(mp);
718         xfs_refcountbt_compute_maxlevels(mp);
719 
720         /*
721          * Check if sb_agblocks is aligned at stripe boundary.  If sb_agblocks
722          * is NOT aligned turn off m_dalign since allocator alignment is within
723          * an ag, therefore ag has to be aligned at stripe boundary.  Note that
724          * we must compute the free space and rmap btree geometry before doing
725          * this.
726          */
727         error = xfs_update_alignment(mp);
728         if (error)
729                 goto out;
730 
731         /* enable fail_at_unmount as default */
732         mp->m_fail_unmount = true;
733 
734         error = xfs_sysfs_init(&mp->m_kobj, &xfs_mp_ktype,
735                                NULL, mp->m_super->s_id);
736         if (error)
737                 goto out;
738 
739         error = xfs_sysfs_init(&mp->m_stats.xs_kobj, &xfs_stats_ktype,
740                                &mp->m_kobj, "stats");
741         if (error)
742                 goto out_remove_sysfs;
743 
744         error = xfs_error_sysfs_init(mp);
745         if (error)
746                 goto out_del_stats;
747 
748         error = xfs_errortag_init(mp);
749         if (error)
750                 goto out_remove_error_sysfs;
751 
752         error = xfs_uuid_mount(mp);
753         if (error)
754                 goto out_remove_errortag;
755 
756         /*
757          * Update the preferred write size based on the information from the
758          * on-disk superblock.
759          */
760         mp->m_allocsize_log =
761                 max_t(uint32_t, sbp->sb_blocklog, mp->m_allocsize_log);
762         mp->m_allocsize_blocks = 1U << (mp->m_allocsize_log - sbp->sb_blocklog);
763 
764         /* set the low space thresholds for dynamic preallocation */
765         xfs_set_low_space_thresholds(mp);
766 
767         /*
768          * If enabled, sparse inode chunk alignment is expected to match the
769          * cluster size. Full inode chunk alignment must match the chunk size,
770          * but that is checked on sb read verification...
771          */
772         if (xfs_sb_version_hassparseinodes(&mp->m_sb) &&
773             mp->m_sb.sb_spino_align !=
774                         XFS_B_TO_FSBT(mp, igeo->inode_cluster_size_raw)) {
775                 xfs_warn(mp,
776         "Sparse inode block alignment (%u) must match cluster size (%llu).",
777                          mp->m_sb.sb_spino_align,
778                          XFS_B_TO_FSBT(mp, igeo->inode_cluster_size_raw));
779                 error = -EINVAL;
780                 goto out_remove_uuid;
781         }
782 
783         /*
784          * Check that the data (and log if separate) is an ok size.
785          */
786         error = xfs_check_sizes(mp);
787         if (error)
788                 goto out_remove_uuid;
789 
790         /*
791          * Initialize realtime fields in the mount structure
792          */
793         error = xfs_rtmount_init(mp);
794         if (error) {
795                 xfs_warn(mp, "RT mount failed");
796                 goto out_remove_uuid;
797         }
798 
799         /*
800          *  Copies the low order bits of the timestamp and the randomly
801          *  set "sequence" number out of a UUID.
802          */
803         mp->m_fixedfsid[0] =
804                 (get_unaligned_be16(&sbp->sb_uuid.b[8]) << 16) |
805                  get_unaligned_be16(&sbp->sb_uuid.b[4]);
806         mp->m_fixedfsid[1] = get_unaligned_be32(&sbp->sb_uuid.b[0]);
807 
808         error = xfs_da_mount(mp);
809         if (error) {
810                 xfs_warn(mp, "Failed dir/attr init: %d", error);
811                 goto out_remove_uuid;
812         }
813 
814         /*
815          * Initialize the precomputed transaction reservations values.
816          */
817         xfs_trans_init(mp);
818 
819         /*
820          * Allocate and initialize the per-ag data.
821          */
822         error = xfs_initialize_perag(mp, sbp->sb_agcount, &mp->m_maxagi);
823         if (error) {
824                 xfs_warn(mp, "Failed per-ag init: %d", error);
825                 goto out_free_dir;
826         }
827 
828         if (XFS_IS_CORRUPT(mp, !sbp->sb_logblocks)) {
829                 xfs_warn(mp, "no log defined");
830                 error = -EFSCORRUPTED;
831                 goto out_free_perag;
832         }
833 
834         /*
835          * Log's mount-time initialization. The first part of recovery can place
836          * some items on the AIL, to be handled when recovery is finished or
837          * cancelled.
838          */
839         error = xfs_log_mount(mp, mp->m_logdev_targp,
840                               XFS_FSB_TO_DADDR(mp, sbp->sb_logstart),
841                               XFS_FSB_TO_BB(mp, sbp->sb_logblocks));
842         if (error) {
843                 xfs_warn(mp, "log mount failed");
844                 goto out_fail_wait;
845         }
846 
847         /* Make sure the summary counts are ok. */
848         error = xfs_check_summary_counts(mp);
849         if (error)
850                 goto out_log_dealloc;
851 
852         /*
853          * Get and sanity-check the root inode.
854          * Save the pointer to it in the mount structure.
855          */
856         error = xfs_iget(mp, NULL, sbp->sb_rootino, XFS_IGET_UNTRUSTED,
857                          XFS_ILOCK_EXCL, &rip);
858         if (error) {
859                 xfs_warn(mp,
860                         "Failed to read root inode 0x%llx, error %d",
861                         sbp->sb_rootino, -error);
862                 goto out_log_dealloc;
863         }
864 
865         ASSERT(rip != NULL);
866 
867         if (XFS_IS_CORRUPT(mp, !S_ISDIR(VFS_I(rip)->i_mode))) {
868                 xfs_warn(mp, "corrupted root inode %llu: not a directory",
869                         (unsigned long long)rip->i_ino);
870                 xfs_iunlock(rip, XFS_ILOCK_EXCL);
871                 error = -EFSCORRUPTED;
872                 goto out_rele_rip;
873         }
874         mp->m_rootip = rip;     /* save it */
875 
876         xfs_iunlock(rip, XFS_ILOCK_EXCL);
877 
878         /*
879          * Initialize realtime inode pointers in the mount structure
880          */
881         error = xfs_rtmount_inodes(mp);
882         if (error) {
883                 /*
884                  * Free up the root inode.
885                  */
886                 xfs_warn(mp, "failed to read RT inodes");
887                 goto out_rele_rip;
888         }
889 
890         /*
891          * If this is a read-only mount defer the superblock updates until
892          * the next remount into writeable mode.  Otherwise we would never
893          * perform the update e.g. for the root filesystem.
894          */
895         if (mp->m_update_sb && !(mp->m_flags & XFS_MOUNT_RDONLY)) {
896                 error = xfs_sync_sb(mp, false);
897                 if (error) {
898                         xfs_warn(mp, "failed to write sb changes");
899                         goto out_rtunmount;
900                 }
901         }
902 
903         /*
904          * Initialise the XFS quota management subsystem for this mount
905          */
906         if (XFS_IS_QUOTA_RUNNING(mp)) {
907                 error = xfs_qm_newmount(mp, &quotamount, &quotaflags);
908                 if (error)
909                         goto out_rtunmount;
910         } else {
911                 ASSERT(!XFS_IS_QUOTA_ON(mp));
912 
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                 if (mp->m_sb.sb_qflags & XFS_ALL_QUOTA_ACCT) {
919                         xfs_notice(mp, "resetting quota flags");
920                         error = xfs_mount_reset_sbqflags(mp);
921                         if (error)
922                                 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.
930          */
931         error = xfs_log_mount_finish(mp);
932         if (error) {
933                 xfs_warn(mp, "log mount finish failed");
934                 goto out_rtunmount;
935         }
936 
937         /*
938          * Now the log is fully replayed, we can transition to full read-only
939          * mode for read-only mounts. This will sync all the metadata and clean
940          * the log so that the recovery we just performed does not have to be
941          * replayed again on the next mount.
942          *
943          * We use the same quiesce mechanism as the rw->ro remount, as they are
944          * semantically identical operations.
945          */
946         if ((mp->m_flags & (XFS_MOUNT_RDONLY|XFS_MOUNT_NORECOVERY)) ==
947                                                         XFS_MOUNT_RDONLY) {
948                 xfs_quiesce_attr(mp);
949         }
950 
951         /*
952          * Complete the quota initialisation, post-log-replay component.
953          */
954         if (quotamount) {
955                 ASSERT(mp->m_qflags == 0);
956                 mp->m_qflags = quotaflags;
957 
958                 xfs_qm_mount_quotas(mp);
959         }
960 
961         /*
962          * Now we are mounted, reserve a small amount of unused space for
963          * privileged transactions. This is needed so that transaction
964          * space required for critical operations can dip into this pool
965          * when at ENOSPC. This is needed for operations like create with
966          * attr, unwritten extent conversion at ENOSPC, etc. Data allocations
967          * are not allowed to use this reserved space.
968          *
969          * This may drive us straight to ENOSPC on mount, but that implies
970          * we were already there on the last unmount. Warn if this occurs.
971          */
972         if (!(mp->m_flags & XFS_MOUNT_RDONLY)) {
973                 resblks = xfs_default_resblks(mp);
974                 error = xfs_reserve_blocks(mp, &resblks, NULL);
975                 if (error)
976                         xfs_warn(mp,
977         "Unable to allocate reserve blocks. Continuing without reserve pool.");
978 
979                 /* Recover any CoW blocks that never got remapped. */
980                 error = xfs_reflink_recover_cow(mp);
981                 if (error) {
982                         xfs_err(mp,
983         "Error %d recovering leftover CoW allocations.", error);
984                         xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
985                         goto out_quota;
986                 }
987 
988                 /* Reserve AG blocks for future btree expansion. */
989                 error = xfs_fs_reserve_ag_blocks(mp);
990                 if (error && error != -ENOSPC)
991                         goto out_agresv;
992         }
993 
994         return 0;
995 
996  out_agresv:
997         xfs_fs_unreserve_ag_blocks(mp);
998  out_quota:
999         xfs_qm_unmount_quotas(mp);
1000  out_rtunmount:
1001         xfs_rtunmount_inodes(mp);
1002  out_rele_rip:
1003         xfs_irele(rip);
1004         /* Clean out dquots that might be in memory after quotacheck. */
1005         xfs_qm_unmount(mp);
1006         /*
1007          * Cancel all delayed reclaim work and reclaim the inodes directly.
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         cancel_delayed_work_sync(&mp->m_reclaim_work);
1018         xfs_reclaim_inodes(mp, SYNC_WAIT);
1019         xfs_health_unmount(mp);
1020  out_log_dealloc:
1021         mp->m_flags |= XFS_MOUNT_UNMOUNTING;
1022         xfs_log_mount_cancel(mp);
1023  out_fail_wait:
1024         if (mp->m_logdev_targp && mp->m_logdev_targp != mp->m_ddev_targp)
1025                 xfs_wait_buftarg(mp->m_logdev_targp);
1026         xfs_wait_buftarg(mp->m_ddev_targp);
1027  out_free_perag:
1028         xfs_free_perag(mp);
1029  out_free_dir:
1030         xfs_da_unmount(mp);
1031  out_remove_uuid:
1032         xfs_uuid_unmount(mp);
1033  out_remove_errortag:
1034         xfs_errortag_del(mp);
1035  out_remove_error_sysfs:
1036         xfs_error_sysfs_del(mp);
1037  out_del_stats:
1038         xfs_sysfs_del(&mp->m_stats.xs_kobj);
1039  out_remove_sysfs:
1040         xfs_sysfs_del(&mp->m_kobj);
1041  out:
1042         return error;
1043 }
1044 
1045 /*
1046  * This flushes out the inodes,dquots and the superblock, unmounts the
1047  * log and makes sure that incore structures are freed.
1048  */
1049 void
1050 xfs_unmountfs(
1051         struct xfs_mount        *mp)
1052 {
1053         uint64_t                resblks;
1054         int                     error;
1055 
1056         xfs_stop_block_reaping(mp);
1057         xfs_fs_unreserve_ag_blocks(mp);
1058         xfs_qm_unmount_quotas(mp);
1059         xfs_rtunmount_inodes(mp);
1060         xfs_irele(mp->m_rootip);
1061 
1062         /*
1063          * We can potentially deadlock here if we have an inode cluster
1064          * that has been freed has its buffer still pinned in memory because
1065          * the transaction is still sitting in a iclog. The stale inodes
1066          * on that buffer will have their flush locks held until the
1067          * transaction hits the disk and the callbacks run. the inode
1068          * flush takes the flush lock unconditionally and with nothing to
1069          * push out the iclog we will never get that unlocked. hence we
1070          * need to force the log first.
1071          */
1072         xfs_log_force(mp, XFS_LOG_SYNC);
1073 
1074         /*
1075          * Wait for all busy extents to be freed, including completion of
1076          * any discard operation.
1077          */
1078         xfs_extent_busy_wait_all(mp);
1079         flush_workqueue(xfs_discard_wq);
1080 
1081         /*
1082          * We now need to tell the world we are unmounting. This will allow
1083          * us to detect that the filesystem is going away and we should error
1084          * out anything that we have been retrying in the background. This will
1085          * prevent neverending retries in AIL pushing from hanging the unmount.
1086          */
1087         mp->m_flags |= XFS_MOUNT_UNMOUNTING;
1088 
1089         /*
1090          * Flush all pending changes from the AIL.
1091          */
1092         xfs_ail_push_all_sync(mp->m_ail);
1093 
1094         /*
1095          * And reclaim all inodes.  At this point there should be no dirty
1096          * inodes and none should be pinned or locked, but use synchronous
1097          * reclaim just to be sure. We can stop background inode reclaim
1098          * here as well if it is still running.
1099          */
1100         cancel_delayed_work_sync(&mp->m_reclaim_work);
1101         xfs_reclaim_inodes(mp, SYNC_WAIT);
1102         xfs_health_unmount(mp);
1103 
1104         xfs_qm_unmount(mp);
1105 
1106         /*
1107          * Unreserve any blocks we have so that when we unmount we don't account
1108          * the reserved free space as used. This is really only necessary for
1109          * lazy superblock counting because it trusts the incore superblock
1110          * counters to be absolutely correct on clean unmount.
1111          *
1112          * We don't bother correcting this elsewhere for lazy superblock
1113          * counting because on mount of an unclean filesystem we reconstruct the
1114          * correct counter value and this is irrelevant.
1115          *
1116          * For non-lazy counter filesystems, this doesn't matter at all because
1117          * we only every apply deltas to the superblock and hence the incore
1118          * value does not matter....
1119          */
1120         resblks = 0;
1121         error = xfs_reserve_blocks(mp, &resblks, NULL);
1122         if (error)
1123                 xfs_warn(mp, "Unable to free reserved block pool. "
1124                                 "Freespace may not be correct on next mount.");
1125 
1126         error = xfs_log_sbcount(mp);
1127         if (error)
1128                 xfs_warn(mp, "Unable to update superblock counters. "
1129                                 "Freespace may not be correct on next mount.");
1130 
1131 
1132         xfs_log_unmount(mp);
1133         xfs_da_unmount(mp);
1134         xfs_uuid_unmount(mp);
1135 
1136 #if defined(DEBUG)
1137         xfs_errortag_clearall(mp);
1138 #endif
1139         xfs_free_perag(mp);
1140 
1141         xfs_errortag_del(mp);
1142         xfs_error_sysfs_del(mp);
1143         xfs_sysfs_del(&mp->m_stats.xs_kobj);
1144         xfs_sysfs_del(&mp->m_kobj);
1145 }
1146 
1147 /*
1148  * Determine whether modifications can proceed. The caller specifies the minimum
1149  * freeze level for which modifications should not be allowed. This allows
1150  * certain operations to proceed while the freeze sequence is in progress, if
1151  * necessary.
1152  */
1153 bool
1154 xfs_fs_writable(
1155         struct xfs_mount        *mp,
1156         int                     level)
1157 {
1158         ASSERT(level > SB_UNFROZEN);
1159         if ((mp->m_super->s_writers.frozen >= level) ||
1160             XFS_FORCED_SHUTDOWN(mp) || (mp->m_flags & XFS_MOUNT_RDONLY))
1161                 return false;
1162 
1163         return true;
1164 }
1165 
1166 /*
1167  * xfs_log_sbcount
1168  *
1169  * Sync the superblock counters to disk.
1170  *
1171  * Note this code can be called during the process of freezing, so we use the
1172  * transaction allocator that does not block when the transaction subsystem is
1173  * in its frozen state.
1174  */
1175 int
1176 xfs_log_sbcount(xfs_mount_t *mp)
1177 {
1178         /* allow this to proceed during the freeze sequence... */
1179         if (!xfs_fs_writable(mp, SB_FREEZE_COMPLETE))
1180                 return 0;
1181 
1182         /*
1183          * we don't need to do this if we are updating the superblock
1184          * counters on every modification.
1185          */
1186         if (!xfs_sb_version_haslazysbcount(&mp->m_sb))
1187                 return 0;
1188 
1189         return xfs_sync_sb(mp, true);
1190 }
1191 
1192 /*
1193  * Deltas for the block count can vary from 1 to very large, but lock contention
1194  * only occurs on frequent small block count updates such as in the delayed
1195  * allocation path for buffered writes (page a time updates). Hence we set
1196  * a large batch count (1024) to minimise global counter updates except when
1197  * we get near to ENOSPC and we have to be very accurate with our updates.
1198  */
1199 #define XFS_FDBLOCKS_BATCH      1024
1200 int
1201 xfs_mod_fdblocks(
1202         struct xfs_mount        *mp,
1203         int64_t                 delta,
1204         bool                    rsvd)
1205 {
1206         int64_t                 lcounter;
1207         long long               res_used;
1208         s32                     batch;
1209 
1210         if (delta > 0) {
1211                 /*
1212                  * If the reserve pool is depleted, put blocks back into it
1213                  * first. Most of the time the pool is full.
1214                  */
1215                 if (likely(mp->m_resblks == mp->m_resblks_avail)) {
1216                         percpu_counter_add(&mp->m_fdblocks, delta);
1217                         return 0;
1218                 }
1219 
1220                 spin_lock(&mp->m_sb_lock);
1221                 res_used = (long long)(mp->m_resblks - mp->m_resblks_avail);
1222 
1223                 if (res_used > delta) {
1224                         mp->m_resblks_avail += delta;
1225                 } else {
1226                         delta -= res_used;
1227                         mp->m_resblks_avail = mp->m_resblks;
1228                         percpu_counter_add(&mp->m_fdblocks, delta);
1229                 }
1230                 spin_unlock(&mp->m_sb_lock);
1231                 return 0;
1232         }
1233 
1234         /*
1235          * Taking blocks away, need to be more accurate the closer we
1236          * are to zero.
1237          *
1238          * If the counter has a value of less than 2 * max batch size,
1239          * then make everything serialise as we are real close to
1240          * ENOSPC.
1241          */
1242         if (__percpu_counter_compare(&mp->m_fdblocks, 2 * XFS_FDBLOCKS_BATCH,
1243                                      XFS_FDBLOCKS_BATCH) < 0)
1244                 batch = 1;
1245         else
1246                 batch = XFS_FDBLOCKS_BATCH;
1247 
1248         percpu_counter_add_batch(&mp->m_fdblocks, delta, batch);
1249         if (__percpu_counter_compare(&mp->m_fdblocks, mp->m_alloc_set_aside,
1250                                      XFS_FDBLOCKS_BATCH) >= 0) {
1251                 /* we had space! */
1252                 return 0;
1253         }
1254 
1255         /*
1256          * lock up the sb for dipping into reserves before releasing the space
1257          * that took us to ENOSPC.
1258          */
1259         spin_lock(&mp->m_sb_lock);
1260         percpu_counter_add(&mp->m_fdblocks, -delta);
1261         if (!rsvd)
1262                 goto fdblocks_enospc;
1263 
1264         lcounter = (long long)mp->m_resblks_avail + delta;
1265         if (lcounter >= 0) {
1266                 mp->m_resblks_avail = lcounter;
1267                 spin_unlock(&mp->m_sb_lock);
1268                 return 0;
1269         }
1270         xfs_warn_once(mp,
1271 "Reserve blocks depleted! Consider increasing reserve pool size.");
1272 
1273 fdblocks_enospc:
1274         spin_unlock(&mp->m_sb_lock);
1275         return -ENOSPC;
1276 }
1277 
1278 int
1279 xfs_mod_frextents(
1280         struct xfs_mount        *mp,
1281         int64_t                 delta)
1282 {
1283         int64_t                 lcounter;
1284         int                     ret = 0;
1285 
1286         spin_lock(&mp->m_sb_lock);
1287         lcounter = mp->m_sb.sb_frextents + delta;
1288         if (lcounter < 0)
1289                 ret = -ENOSPC;
1290         else
1291                 mp->m_sb.sb_frextents = lcounter;
1292         spin_unlock(&mp->m_sb_lock);
1293         return ret;
1294 }
1295 
1296 /*
1297  * xfs_getsb() is called to obtain the buffer for the superblock.
1298  * The buffer is returned locked and read in from disk.
1299  * The buffer should be released with a call to xfs_brelse().
1300  */
1301 struct xfs_buf *
1302 xfs_getsb(
1303         struct xfs_mount        *mp)
1304 {
1305         struct xfs_buf          *bp = mp->m_sb_bp;
1306 
1307         xfs_buf_lock(bp);
1308         xfs_buf_hold(bp);
1309         ASSERT(bp->b_flags & XBF_DONE);
1310         return bp;
1311 }
1312 
1313 /*
1314  * Used to free the superblock along various error paths.
1315  */
1316 void
1317 xfs_freesb(
1318         struct xfs_mount        *mp)
1319 {
1320         struct xfs_buf          *bp = mp->m_sb_bp;
1321 
1322         xfs_buf_lock(bp);
1323         mp->m_sb_bp = NULL;
1324         xfs_buf_relse(bp);
1325 }
1326 
1327 /*
1328  * If the underlying (data/log/rt) device is readonly, there are some
1329  * operations that cannot proceed.
1330  */
1331 int
1332 xfs_dev_is_read_only(
1333         struct xfs_mount        *mp,
1334         char                    *message)
1335 {
1336         if (xfs_readonly_buftarg(mp->m_ddev_targp) ||
1337             xfs_readonly_buftarg(mp->m_logdev_targp) ||
1338             (mp->m_rtdev_targp && xfs_readonly_buftarg(mp->m_rtdev_targp))) {
1339                 xfs_notice(mp, "%s required on read-only device.", message);
1340                 xfs_notice(mp, "write access unavailable, cannot proceed.");
1341                 return -EROFS;
1342         }
1343         return 0;
1344 }
1345 
1346 /* Force the summary counters to be recalculated at next mount. */
1347 void
1348 xfs_force_summary_recalc(
1349         struct xfs_mount        *mp)
1350 {
1351         if (!xfs_sb_version_haslazysbcount(&mp->m_sb))
1352                 return;
1353 
1354         xfs_fs_mark_sick(mp, XFS_SICK_FS_COUNTERS);
1355 }
1356 
1357 /*
1358  * Update the in-core delayed block counter.
1359  *
1360  * We prefer to update the counter without having to take a spinlock for every
1361  * counter update (i.e. batching).  Each change to delayed allocation
1362  * reservations can change can easily exceed the default percpu counter
1363  * batching, so we use a larger batch factor here.
1364  *
1365  * Note that we don't currently have any callers requiring fast summation
1366  * (e.g. percpu_counter_read) so we can use a big batch value here.
1367  */
1368 #define XFS_DELALLOC_BATCH      (4096)
1369 void
1370 xfs_mod_delalloc(
1371         struct xfs_mount        *mp,
1372         int64_t                 delta)
1373 {
1374         percpu_counter_add_batch(&mp->m_delalloc_blks, delta,
1375                         XFS_DELALLOC_BATCH);
1376 }
1377 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp