blob: e9727d0a541a109329c2c9072b24c7c0d3b6ed23 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Nathan Scott7b718762005-11-02 14:58:39 +11002 * Copyright (c) 2000-2005 Silicon Graphics, Inc.
3 * All Rights Reserved.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 *
Nathan Scott7b718762005-11-02 14:58:39 +11005 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 * published by the Free Software Foundation.
8 *
Nathan Scott7b718762005-11-02 14:58:39 +11009 * This program is distributed in the hope that it would be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
Linus Torvalds1da177e2005-04-16 15:20:36 -070013 *
Nathan Scott7b718762005-11-02 14:58:39 +110014 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write the Free Software Foundation,
16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Linus Torvalds1da177e2005-04-16 15:20:36 -070017 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include "xfs.h"
Nathan Scotta844f452005-11-02 14:38:42 +110019#include "xfs_fs.h"
Dave Chinner70a98832013-10-23 10:36:05 +110020#include "xfs_shared.h"
Dave Chinner239880e2013-10-23 10:50:10 +110021#include "xfs_format.h"
22#include "xfs_log_format.h"
23#include "xfs_trans_resv.h"
Nathan Scotta844f452005-11-02 14:38:42 +110024#include "xfs_bit.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070025#include "xfs_sb.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#include "xfs_mount.h"
Darrick J. Wong3ab78df2016-08-03 11:15:38 +100027#include "xfs_defer.h"
Dave Chinner57062782013-10-15 09:17:51 +110028#include "xfs_da_format.h"
Dave Chinner9a2cc412014-12-04 09:43:17 +110029#include "xfs_da_btree.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070030#include "xfs_inode.h"
Dave Chinnera4fbe6a2013-10-23 10:51:50 +110031#include "xfs_dir2.h"
Nathan Scotta844f452005-11-02 14:38:42 +110032#include "xfs_ialloc.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#include "xfs_alloc.h"
34#include "xfs_rtalloc.h"
35#include "xfs_bmap.h"
Dave Chinnera4fbe6a2013-10-23 10:51:50 +110036#include "xfs_trans.h"
37#include "xfs_trans_priv.h"
38#include "xfs_log.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070039#include "xfs_error.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070040#include "xfs_quota.h"
41#include "xfs_fsops.h"
Christoph Hellwig0b1b2132009-12-14 23:14:59 +000042#include "xfs_trace.h"
Dave Chinner6d8b79c2012-10-08 21:56:09 +110043#include "xfs_icache.h"
Brian Fostera31b1d32014-07-15 08:07:01 +100044#include "xfs_sysfs.h"
Darrick J. Wong035e00a2016-08-03 11:36:07 +100045#include "xfs_rmap_btree.h"
Darrick J. Wong1946b912016-10-03 09:11:18 -070046#include "xfs_refcount_btree.h"
Darrick J. Wong174edb02016-10-03 09:11:39 -070047#include "xfs_reflink.h"
Christoph Hellwigebf55872017-02-07 14:06:57 -080048#include "xfs_extent_busy.h"
Christoph Hellwig0b1b2132009-12-14 23:14:59 +000049
Linus Torvalds1da177e2005-04-16 15:20:36 -070050
Christoph Hellwig27174202009-03-30 10:21:31 +020051static DEFINE_MUTEX(xfs_uuid_table_mutex);
52static int xfs_uuid_table_size;
53static uuid_t *xfs_uuid_table;
54
Darrick J. Wongaf3b6382015-11-03 13:06:34 +110055void
56xfs_uuid_table_free(void)
57{
58 if (xfs_uuid_table_size == 0)
59 return;
60 kmem_free(xfs_uuid_table);
61 xfs_uuid_table = NULL;
62 xfs_uuid_table_size = 0;
63}
64
Christoph Hellwig27174202009-03-30 10:21:31 +020065/*
66 * See if the UUID is unique among mounted XFS filesystems.
67 * Mount fails if UUID is nil or a FS with the same UUID is already mounted.
68 */
69STATIC int
70xfs_uuid_mount(
71 struct xfs_mount *mp)
72{
73 uuid_t *uuid = &mp->m_sb.sb_uuid;
74 int hole, i;
75
Amir Goldstein8f720d92017-04-28 08:10:53 -070076 /* Publish UUID in struct super_block */
Christoph Hellwig85787092017-05-10 15:06:33 +020077 uuid_copy(&mp->m_super->s_uuid, uuid);
Amir Goldstein8f720d92017-04-28 08:10:53 -070078
Christoph Hellwig27174202009-03-30 10:21:31 +020079 if (mp->m_flags & XFS_MOUNT_NOUUID)
80 return 0;
81
Amir Goldsteind905fda2017-05-04 16:26:23 +030082 if (uuid_is_null(uuid)) {
83 xfs_warn(mp, "Filesystem has null UUID - can't mount");
Dave Chinner24513372014-06-25 14:58:08 +100084 return -EINVAL;
Christoph Hellwig27174202009-03-30 10:21:31 +020085 }
86
87 mutex_lock(&xfs_uuid_table_mutex);
88 for (i = 0, hole = -1; i < xfs_uuid_table_size; i++) {
Amir Goldsteind905fda2017-05-04 16:26:23 +030089 if (uuid_is_null(&xfs_uuid_table[i])) {
Christoph Hellwig27174202009-03-30 10:21:31 +020090 hole = i;
91 continue;
92 }
93 if (uuid_equal(uuid, &xfs_uuid_table[i]))
94 goto out_duplicate;
95 }
96
97 if (hole < 0) {
98 xfs_uuid_table = kmem_realloc(xfs_uuid_table,
99 (xfs_uuid_table_size + 1) * sizeof(*xfs_uuid_table),
Christoph Hellwig27174202009-03-30 10:21:31 +0200100 KM_SLEEP);
101 hole = xfs_uuid_table_size++;
102 }
103 xfs_uuid_table[hole] = *uuid;
104 mutex_unlock(&xfs_uuid_table_mutex);
105
106 return 0;
107
108 out_duplicate:
109 mutex_unlock(&xfs_uuid_table_mutex);
Mitsuo Hayasaka021000e2012-01-13 05:58:39 +0000110 xfs_warn(mp, "Filesystem has duplicate UUID %pU - can't mount", uuid);
Dave Chinner24513372014-06-25 14:58:08 +1000111 return -EINVAL;
Christoph Hellwig27174202009-03-30 10:21:31 +0200112}
113
114STATIC void
115xfs_uuid_unmount(
116 struct xfs_mount *mp)
117{
118 uuid_t *uuid = &mp->m_sb.sb_uuid;
119 int i;
120
121 if (mp->m_flags & XFS_MOUNT_NOUUID)
122 return;
123
124 mutex_lock(&xfs_uuid_table_mutex);
125 for (i = 0; i < xfs_uuid_table_size; i++) {
Amir Goldsteind905fda2017-05-04 16:26:23 +0300126 if (uuid_is_null(&xfs_uuid_table[i]))
Christoph Hellwig27174202009-03-30 10:21:31 +0200127 continue;
128 if (!uuid_equal(uuid, &xfs_uuid_table[i]))
129 continue;
130 memset(&xfs_uuid_table[i], 0, sizeof(uuid_t));
131 break;
132 }
133 ASSERT(i < xfs_uuid_table_size);
134 mutex_unlock(&xfs_uuid_table_mutex);
135}
136
137
Dave Chinnere1765792010-09-22 10:47:20 +1000138STATIC void
139__xfs_free_perag(
140 struct rcu_head *head)
141{
142 struct xfs_perag *pag = container_of(head, struct xfs_perag, rcu_head);
143
144 ASSERT(atomic_read(&pag->pag_ref) == 0);
145 kmem_free(pag);
146}
147
Dave Chinner0fa800f2010-01-11 11:47:46 +0000148/*
Dave Chinnere1765792010-09-22 10:47:20 +1000149 * Free up the per-ag resources associated with the mount structure.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150 */
Christoph Hellwigc962fb72008-05-20 15:10:52 +1000151STATIC void
Christoph Hellwigff4f0382008-08-13 16:50:47 +1000152xfs_free_perag(
Christoph Hellwig745f6912007-08-30 17:20:39 +1000153 xfs_mount_t *mp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154{
Dave Chinner1c1c6eb2010-01-11 11:47:44 +0000155 xfs_agnumber_t agno;
156 struct xfs_perag *pag;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157
Dave Chinner1c1c6eb2010-01-11 11:47:44 +0000158 for (agno = 0; agno < mp->m_sb.sb_agcount; agno++) {
159 spin_lock(&mp->m_perag_lock);
160 pag = radix_tree_delete(&mp->m_perag_tree, agno);
161 spin_unlock(&mp->m_perag_lock);
Dave Chinnere1765792010-09-22 10:47:20 +1000162 ASSERT(pag);
Dave Chinnerf83282a2010-11-08 08:55:04 +0000163 ASSERT(atomic_read(&pag->pag_ref) == 0);
Lucas Stach6031e732016-12-07 17:36:36 +1100164 xfs_buf_hash_destroy(pag);
Dave Chinnere1765792010-09-22 10:47:20 +1000165 call_rcu(&pag->rcu_head, __xfs_free_perag);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167}
168
Nathan Scott4cc929e2007-05-14 18:24:02 +1000169/*
170 * Check size of device based on the (data/realtime) block count.
171 * Note: this check is used by the growfs code as well as mount.
172 */
173int
174xfs_sb_validate_fsb_count(
175 xfs_sb_t *sbp,
Darrick J. Wongc8ce5402017-06-16 11:00:05 -0700176 uint64_t nblocks)
Nathan Scott4cc929e2007-05-14 18:24:02 +1000177{
178 ASSERT(PAGE_SHIFT >= sbp->sb_blocklog);
179 ASSERT(sbp->sb_blocklog >= BBSHIFT);
180
Christoph Hellwigd5cf09b2014-07-30 09:12:05 +1000181 /* Limited by ULONG_MAX of page cache index */
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +0300182 if (nblocks >> (PAGE_SHIFT - sbp->sb_blocklog) > ULONG_MAX)
Dave Chinner24513372014-06-25 14:58:08 +1000183 return -EFBIG;
Nathan Scott4cc929e2007-05-14 18:24:02 +1000184 return 0;
185}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186
Dave Chinner1c1c6eb2010-01-11 11:47:44 +0000187int
Nathan Scottc11e2c32005-11-02 15:11:45 +1100188xfs_initialize_perag(
Nathan Scottc11e2c32005-11-02 15:11:45 +1100189 xfs_mount_t *mp,
Dave Chinner1c1c6eb2010-01-11 11:47:44 +0000190 xfs_agnumber_t agcount,
191 xfs_agnumber_t *maxagi)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192{
Carlos Maiolino2d2194f2012-09-20 10:32:38 -0300193 xfs_agnumber_t index;
Bill O'Donnellb20fe472017-02-07 12:59:33 -0800194 xfs_agnumber_t first_initialised = NULLAGNUMBER;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195 xfs_perag_t *pag;
Dave Chinner8b26c582010-01-11 11:47:48 +0000196 int error = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197
Dave Chinner1c1c6eb2010-01-11 11:47:44 +0000198 /*
199 * Walk the current per-ag tree so we don't try to initialise AGs
200 * that already exist (growfs case). Allocate and insert all the
201 * AGs we don't find ready for initialisation.
202 */
203 for (index = 0; index < agcount; index++) {
204 pag = xfs_perag_get(mp, index);
205 if (pag) {
206 xfs_perag_put(pag);
207 continue;
208 }
Christoph Hellwigfb3b5042010-05-28 19:03:10 +0000209
Dave Chinner1c1c6eb2010-01-11 11:47:44 +0000210 pag = kmem_zalloc(sizeof(*pag), KM_MAYFAIL);
211 if (!pag)
Bill O'Donnellb20fe472017-02-07 12:59:33 -0800212 goto out_unwind_new_pags;
Christoph Hellwigfb3b5042010-05-28 19:03:10 +0000213 pag->pag_agno = index;
214 pag->pag_mount = mp;
Dave Chinner1a427ab2010-12-16 17:08:41 +1100215 spin_lock_init(&pag->pag_ici_lock);
Dave Chinner69b491c2010-09-27 11:09:51 +1000216 mutex_init(&pag->pag_ici_reclaim_lock);
Christoph Hellwigfb3b5042010-05-28 19:03:10 +0000217 INIT_RADIX_TREE(&pag->pag_ici_root, GFP_ATOMIC);
Lucas Stach6031e732016-12-07 17:36:36 +1100218 if (xfs_buf_hash_init(pag))
Bill O'Donnellb20fe472017-02-07 12:59:33 -0800219 goto out_free_pag;
Christoph Hellwigebf55872017-02-07 14:06:57 -0800220 init_waitqueue_head(&pag->pagb_wait);
Christoph Hellwigfb3b5042010-05-28 19:03:10 +0000221
Dave Chinner1c1c6eb2010-01-11 11:47:44 +0000222 if (radix_tree_preload(GFP_NOFS))
Bill O'Donnellb20fe472017-02-07 12:59:33 -0800223 goto out_hash_destroy;
Christoph Hellwigfb3b5042010-05-28 19:03:10 +0000224
Dave Chinner1c1c6eb2010-01-11 11:47:44 +0000225 spin_lock(&mp->m_perag_lock);
226 if (radix_tree_insert(&mp->m_perag_tree, index, pag)) {
227 BUG();
228 spin_unlock(&mp->m_perag_lock);
Dave Chinner8b26c582010-01-11 11:47:48 +0000229 radix_tree_preload_end();
230 error = -EEXIST;
Bill O'Donnellb20fe472017-02-07 12:59:33 -0800231 goto out_hash_destroy;
Dave Chinner1c1c6eb2010-01-11 11:47:44 +0000232 }
233 spin_unlock(&mp->m_perag_lock);
234 radix_tree_preload_end();
Bill O'Donnellb20fe472017-02-07 12:59:33 -0800235 /* first new pag is fully initialized */
236 if (first_initialised == NULLAGNUMBER)
237 first_initialised = index;
Dave Chinner1c1c6eb2010-01-11 11:47:44 +0000238 }
239
Eric Sandeen12c3f052016-03-02 09:58:09 +1100240 index = xfs_set_inode_alloc(mp, agcount);
Christoph Hellwigfb3b5042010-05-28 19:03:10 +0000241
Dave Chinner1c1c6eb2010-01-11 11:47:44 +0000242 if (maxagi)
243 *maxagi = index;
Darrick J. Wong80180262016-08-03 11:31:47 +1000244
245 mp->m_ag_prealloc_blocks = xfs_prealloc_blocks(mp);
Dave Chinner1c1c6eb2010-01-11 11:47:44 +0000246 return 0;
Dave Chinner8b26c582010-01-11 11:47:48 +0000247
Bill O'Donnellb20fe472017-02-07 12:59:33 -0800248out_hash_destroy:
Lucas Stach6031e732016-12-07 17:36:36 +1100249 xfs_buf_hash_destroy(pag);
Bill O'Donnellb20fe472017-02-07 12:59:33 -0800250out_free_pag:
Dave Chinner8b26c582010-01-11 11:47:48 +0000251 kmem_free(pag);
Bill O'Donnellb20fe472017-02-07 12:59:33 -0800252out_unwind_new_pags:
253 /* unwind any prior newly initialized pags */
254 for (index = first_initialised; index < agcount; index++) {
Dave Chinner8b26c582010-01-11 11:47:48 +0000255 pag = radix_tree_delete(&mp->m_perag_tree, index);
Bill O'Donnellb20fe472017-02-07 12:59:33 -0800256 if (!pag)
257 break;
Lucas Stach6031e732016-12-07 17:36:36 +1100258 xfs_buf_hash_destroy(pag);
Dave Chinner8b26c582010-01-11 11:47:48 +0000259 kmem_free(pag);
260 }
261 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262}
263
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264/*
265 * xfs_readsb
266 *
267 * Does the initial read of the superblock.
268 */
269int
Dave Chinnerff550682013-08-12 20:49:41 +1000270xfs_readsb(
271 struct xfs_mount *mp,
272 int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273{
274 unsigned int sector_size;
Dave Chinner04a1e6c2013-04-03 16:11:31 +1100275 struct xfs_buf *bp;
276 struct xfs_sb *sbp = &mp->m_sb;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277 int error;
Dave Chinneraf34e092011-03-07 10:04:35 +1100278 int loud = !(flags & XFS_MFSI_QUIET);
Eric Sandeendaba5422014-02-19 15:39:16 +1100279 const struct xfs_buf_ops *buf_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280
281 ASSERT(mp->m_sb_bp == NULL);
282 ASSERT(mp->m_ddev_targp != NULL);
283
284 /*
Eric Sandeendaba5422014-02-19 15:39:16 +1100285 * For the initial read, we must guess at the sector
286 * size based on the block device. It's enough to
287 * get the sb_sectsize out of the superblock and
288 * then reread with the proper length.
289 * We don't verify it yet, because it may not be complete.
290 */
291 sector_size = xfs_getsize_buftarg(mp->m_ddev_targp);
292 buf_ops = NULL;
293
294 /*
Brian Fosterc891c302016-07-20 11:13:43 +1000295 * Allocate a (locked) buffer to hold the superblock. This will be kept
296 * around at all times to optimize access to the superblock. Therefore,
297 * set XBF_NO_IOACCT to make sure it doesn't hold the buftarg count
298 * elevated.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299 */
Dave Chinner26af6552010-09-22 10:47:20 +1000300reread:
Dave Chinnerba372672014-10-02 09:05:32 +1000301 error = xfs_buf_read_uncached(mp->m_ddev_targp, XFS_SB_DADDR,
Brian Fosterc891c302016-07-20 11:13:43 +1000302 BTOBB(sector_size), XBF_NO_IOACCT, &bp,
303 buf_ops);
Dave Chinnerba372672014-10-02 09:05:32 +1000304 if (error) {
Dave Chinnereab4e632012-11-12 22:54:02 +1100305 if (loud)
Dave Chinnere721f502013-04-03 16:11:32 +1100306 xfs_warn(mp, "SB validate failed with error %d.", error);
Dave Chinnerac75a1f2014-03-07 16:19:14 +1100307 /* bad CRC means corrupted metadata */
Dave Chinner24513372014-06-25 14:58:08 +1000308 if (error == -EFSBADCRC)
309 error = -EFSCORRUPTED;
Dave Chinnerba372672014-10-02 09:05:32 +1000310 return error;
Dave Chinnereab4e632012-11-12 22:54:02 +1100311 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312
313 /*
314 * Initialize the mount structure from the superblock.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315 */
Dave Chinner556b8882014-06-06 16:00:43 +1000316 xfs_sb_from_disk(sbp, XFS_BUF_TO_SBP(bp));
Dave Chinner556b8882014-06-06 16:00:43 +1000317
318 /*
319 * If we haven't validated the superblock, do so now before we try
320 * to check the sector size and reread the superblock appropriately.
321 */
322 if (sbp->sb_magicnum != XFS_SB_MAGIC) {
323 if (loud)
324 xfs_warn(mp, "Invalid superblock magic number");
Dave Chinner24513372014-06-25 14:58:08 +1000325 error = -EINVAL;
Dave Chinner556b8882014-06-06 16:00:43 +1000326 goto release_buf;
327 }
Dave Chinnerff550682013-08-12 20:49:41 +1000328
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 /*
330 * We must be able to do sector-sized and sector-aligned IO.
331 */
Dave Chinner04a1e6c2013-04-03 16:11:31 +1100332 if (sector_size > sbp->sb_sectsize) {
Dave Chinneraf34e092011-03-07 10:04:35 +1100333 if (loud)
334 xfs_warn(mp, "device supports %u byte sectors (not %u)",
Dave Chinner04a1e6c2013-04-03 16:11:31 +1100335 sector_size, sbp->sb_sectsize);
Dave Chinner24513372014-06-25 14:58:08 +1000336 error = -ENOSYS;
Dave Chinner26af6552010-09-22 10:47:20 +1000337 goto release_buf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338 }
339
Eric Sandeendaba5422014-02-19 15:39:16 +1100340 if (buf_ops == NULL) {
Dave Chinner556b8882014-06-06 16:00:43 +1000341 /*
342 * Re-read the superblock so the buffer is correctly sized,
343 * and properly verified.
344 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345 xfs_buf_relse(bp);
Dave Chinner04a1e6c2013-04-03 16:11:31 +1100346 sector_size = sbp->sb_sectsize;
Eric Sandeendaba5422014-02-19 15:39:16 +1100347 buf_ops = loud ? &xfs_sb_buf_ops : &xfs_sb_quiet_buf_ops;
Dave Chinner26af6552010-09-22 10:47:20 +1000348 goto reread;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 }
350
Dave Chinner5681ca42015-02-23 21:22:31 +1100351 xfs_reinit_percpu_counters(mp);
David Chinner8d280b92006-03-14 13:13:09 +1100352
Dave Chinner04a1e6c2013-04-03 16:11:31 +1100353 /* no need to be quiet anymore, so reset the buf ops */
354 bp->b_ops = &xfs_sb_buf_ops;
355
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 mp->m_sb_bp = bp;
Dave Chinner26af6552010-09-22 10:47:20 +1000357 xfs_buf_unlock(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 return 0;
359
Dave Chinner26af6552010-09-22 10:47:20 +1000360release_buf:
361 xfs_buf_relse(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 return error;
363}
364
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365/*
Eric Sandeen0771fb42007-10-12 11:03:40 +1000366 * Update alignment values based on mount options and sb values
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367 */
Eric Sandeen0771fb42007-10-12 11:03:40 +1000368STATIC int
Christoph Hellwig7884bc82009-01-19 02:04:07 +0100369xfs_update_alignment(xfs_mount_t *mp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 xfs_sb_t *sbp = &(mp->m_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372
Christoph Hellwig42490232008-08-13 16:49:32 +1000373 if (mp->m_dalign) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 /*
375 * If stripe unit and stripe width are not multiples
376 * of the fs blocksize turn off alignment.
377 */
378 if ((BBTOB(mp->m_dalign) & mp->m_blockmask) ||
379 (BBTOB(mp->m_swidth) & mp->m_blockmask)) {
Jie Liu39a45d82013-05-02 19:27:47 +0800380 xfs_warn(mp,
381 "alignment check failed: sunit/swidth vs. blocksize(%d)",
382 sbp->sb_blocksize);
Dave Chinner24513372014-06-25 14:58:08 +1000383 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384 } else {
385 /*
386 * Convert the stripe unit and width to FSBs.
387 */
388 mp->m_dalign = XFS_BB_TO_FSBT(mp, mp->m_dalign);
389 if (mp->m_dalign && (sbp->sb_agblocks % mp->m_dalign)) {
Dave Chinner53487782011-03-07 10:05:35 +1100390 xfs_warn(mp,
Jie Liu39a45d82013-05-02 19:27:47 +0800391 "alignment check failed: sunit/swidth vs. agsize(%d)",
392 sbp->sb_agblocks);
Dave Chinner24513372014-06-25 14:58:08 +1000393 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394 } else if (mp->m_dalign) {
395 mp->m_swidth = XFS_BB_TO_FSBT(mp, mp->m_swidth);
396 } else {
Jie Liu39a45d82013-05-02 19:27:47 +0800397 xfs_warn(mp,
398 "alignment check failed: sunit(%d) less than bsize(%d)",
399 mp->m_dalign, sbp->sb_blocksize);
Dave Chinner24513372014-06-25 14:58:08 +1000400 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401 }
402 }
403
404 /*
405 * Update superblock with new values
406 * and log changes
407 */
Eric Sandeen62118702008-03-06 13:44:28 +1100408 if (xfs_sb_version_hasdalign(sbp)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 if (sbp->sb_unit != mp->m_dalign) {
410 sbp->sb_unit = mp->m_dalign;
Dave Chinner61e63ec2015-01-22 09:10:31 +1100411 mp->m_update_sb = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412 }
413 if (sbp->sb_width != mp->m_swidth) {
414 sbp->sb_width = mp->m_swidth;
Dave Chinner61e63ec2015-01-22 09:10:31 +1100415 mp->m_update_sb = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 }
Jie Liu34d7f602013-05-02 19:27:53 +0800417 } else {
418 xfs_warn(mp,
419 "cannot change alignment: superblock does not support data alignment");
Dave Chinner24513372014-06-25 14:58:08 +1000420 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421 }
422 } else if ((mp->m_flags & XFS_MOUNT_NOALIGN) != XFS_MOUNT_NOALIGN &&
Eric Sandeen62118702008-03-06 13:44:28 +1100423 xfs_sb_version_hasdalign(&mp->m_sb)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 mp->m_dalign = sbp->sb_unit;
425 mp->m_swidth = sbp->sb_width;
426 }
427
Eric Sandeen0771fb42007-10-12 11:03:40 +1000428 return 0;
429}
430
431/*
432 * Set the maximum inode count for this filesystem
433 */
434STATIC void
435xfs_set_maxicount(xfs_mount_t *mp)
436{
437 xfs_sb_t *sbp = &(mp->m_sb);
Darrick J. Wongc8ce5402017-06-16 11:00:05 -0700438 uint64_t icount;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439
440 if (sbp->sb_imax_pct) {
Eric Sandeen0771fb42007-10-12 11:03:40 +1000441 /*
442 * Make sure the maximum inode count is a multiple
443 * of the units we allocate inodes in.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445 icount = sbp->sb_dblocks * sbp->sb_imax_pct;
446 do_div(icount, 100);
447 do_div(icount, mp->m_ialloc_blks);
448 mp->m_maxicount = (icount * mp->m_ialloc_blks) <<
449 sbp->sb_inopblog;
Eric Sandeen0771fb42007-10-12 11:03:40 +1000450 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451 mp->m_maxicount = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 }
Eric Sandeen0771fb42007-10-12 11:03:40 +1000453}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454
Eric Sandeen0771fb42007-10-12 11:03:40 +1000455/*
456 * Set the default minimum read and write sizes unless
457 * already specified in a mount option.
458 * We use smaller I/O sizes when the file system
459 * is being used for NFS service (wsync mount option).
460 */
461STATIC void
462xfs_set_rw_sizes(xfs_mount_t *mp)
463{
464 xfs_sb_t *sbp = &(mp->m_sb);
465 int readio_log, writeio_log;
466
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467 if (!(mp->m_flags & XFS_MOUNT_DFLT_IOSIZE)) {
468 if (mp->m_flags & XFS_MOUNT_WSYNC) {
469 readio_log = XFS_WSYNC_READIO_LOG;
470 writeio_log = XFS_WSYNC_WRITEIO_LOG;
471 } else {
472 readio_log = XFS_READIO_LOG_LARGE;
473 writeio_log = XFS_WRITEIO_LOG_LARGE;
474 }
475 } else {
476 readio_log = mp->m_readio_log;
477 writeio_log = mp->m_writeio_log;
478 }
479
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 if (sbp->sb_blocklog > readio_log) {
481 mp->m_readio_log = sbp->sb_blocklog;
482 } else {
483 mp->m_readio_log = readio_log;
484 }
485 mp->m_readio_blocks = 1 << (mp->m_readio_log - sbp->sb_blocklog);
486 if (sbp->sb_blocklog > writeio_log) {
487 mp->m_writeio_log = sbp->sb_blocklog;
488 } else {
489 mp->m_writeio_log = writeio_log;
490 }
491 mp->m_writeio_blocks = 1 << (mp->m_writeio_log - sbp->sb_blocklog);
Eric Sandeen0771fb42007-10-12 11:03:40 +1000492}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493
Eric Sandeen0771fb42007-10-12 11:03:40 +1000494/*
Dave Chinner055388a2011-01-04 11:35:03 +1100495 * precalculate the low space thresholds for dynamic speculative preallocation.
496 */
497void
498xfs_set_low_space_thresholds(
499 struct xfs_mount *mp)
500{
501 int i;
502
503 for (i = 0; i < XFS_LOWSP_MAX; i++) {
Darrick J. Wongc8ce5402017-06-16 11:00:05 -0700504 uint64_t space = mp->m_sb.sb_dblocks;
Dave Chinner055388a2011-01-04 11:35:03 +1100505
506 do_div(space, 100);
507 mp->m_low_space[i] = space * (i + 1);
508 }
509}
510
511
512/*
Eric Sandeen0771fb42007-10-12 11:03:40 +1000513 * Set whether we're using inode alignment.
514 */
515STATIC void
516xfs_set_inoalignment(xfs_mount_t *mp)
517{
Eric Sandeen62118702008-03-06 13:44:28 +1100518 if (xfs_sb_version_hasalign(&mp->m_sb) &&
Chandan Rajendrad5825712017-03-02 15:06:33 -0800519 mp->m_sb.sb_inoalignmt >= xfs_icluster_size_fsb(mp))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520 mp->m_inoalign_mask = mp->m_sb.sb_inoalignmt - 1;
521 else
522 mp->m_inoalign_mask = 0;
523 /*
524 * If we are using stripe alignment, check whether
525 * the stripe unit is a multiple of the inode alignment
526 */
527 if (mp->m_dalign && mp->m_inoalign_mask &&
528 !(mp->m_dalign & mp->m_inoalign_mask))
529 mp->m_sinoalign = mp->m_dalign;
530 else
531 mp->m_sinoalign = 0;
Eric Sandeen0771fb42007-10-12 11:03:40 +1000532}
533
534/*
Zhi Yong Wu0471f622013-08-07 10:10:58 +0000535 * Check that the data (and log if separate) is an ok size.
Eric Sandeen0771fb42007-10-12 11:03:40 +1000536 */
537STATIC int
Dave Chinnerba372672014-10-02 09:05:32 +1000538xfs_check_sizes(
539 struct xfs_mount *mp)
Eric Sandeen0771fb42007-10-12 11:03:40 +1000540{
Dave Chinnerba372672014-10-02 09:05:32 +1000541 struct xfs_buf *bp;
Eric Sandeen0771fb42007-10-12 11:03:40 +1000542 xfs_daddr_t d;
Dave Chinnerba372672014-10-02 09:05:32 +1000543 int error;
Eric Sandeen0771fb42007-10-12 11:03:40 +1000544
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545 d = (xfs_daddr_t)XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks);
546 if (XFS_BB_TO_FSB(mp, d) != mp->m_sb.sb_dblocks) {
Dave Chinner0b932cc2011-03-07 10:08:35 +1100547 xfs_warn(mp, "filesystem size mismatch detected");
Dave Chinner24513372014-06-25 14:58:08 +1000548 return -EFBIG;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 }
Dave Chinnerba372672014-10-02 09:05:32 +1000550 error = xfs_buf_read_uncached(mp->m_ddev_targp,
Dave Chinner1922c942010-09-22 10:47:20 +1000551 d - XFS_FSS_TO_BB(mp, 1),
Dave Chinnerba372672014-10-02 09:05:32 +1000552 XFS_FSS_TO_BB(mp, 1), 0, &bp, NULL);
553 if (error) {
Dave Chinner0b932cc2011-03-07 10:08:35 +1100554 xfs_warn(mp, "last sector read failed");
Dave Chinnerba372672014-10-02 09:05:32 +1000555 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556 }
Dave Chinner1922c942010-09-22 10:47:20 +1000557 xfs_buf_relse(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558
Dave Chinnerba372672014-10-02 09:05:32 +1000559 if (mp->m_logdev_targp == mp->m_ddev_targp)
560 return 0;
561
562 d = (xfs_daddr_t)XFS_FSB_TO_BB(mp, mp->m_sb.sb_logblocks);
563 if (XFS_BB_TO_FSB(mp, d) != mp->m_sb.sb_logblocks) {
564 xfs_warn(mp, "log size mismatch detected");
565 return -EFBIG;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566 }
Dave Chinnerba372672014-10-02 09:05:32 +1000567 error = xfs_buf_read_uncached(mp->m_logdev_targp,
568 d - XFS_FSB_TO_BB(mp, 1),
569 XFS_FSB_TO_BB(mp, 1), 0, &bp, NULL);
570 if (error) {
571 xfs_warn(mp, "log device read failed");
572 return error;
573 }
574 xfs_buf_relse(bp);
Eric Sandeen0771fb42007-10-12 11:03:40 +1000575 return 0;
576}
577
578/*
Christoph Hellwig7d095252009-06-08 15:33:32 +0200579 * Clear the quotaflags in memory and in the superblock.
580 */
581int
582xfs_mount_reset_sbqflags(
583 struct xfs_mount *mp)
584{
Christoph Hellwig7d095252009-06-08 15:33:32 +0200585 mp->m_qflags = 0;
586
Dave Chinner61e63ec2015-01-22 09:10:31 +1100587 /* It is OK to look at sb_qflags in the mount path without m_sb_lock. */
Christoph Hellwig7d095252009-06-08 15:33:32 +0200588 if (mp->m_sb.sb_qflags == 0)
589 return 0;
590 spin_lock(&mp->m_sb_lock);
591 mp->m_sb.sb_qflags = 0;
592 spin_unlock(&mp->m_sb_lock);
593
Dave Chinner61e63ec2015-01-22 09:10:31 +1100594 if (!xfs_fs_writable(mp, SB_FREEZE_WRITE))
Christoph Hellwig7d095252009-06-08 15:33:32 +0200595 return 0;
596
Dave Chinner61e63ec2015-01-22 09:10:31 +1100597 return xfs_sync_sb(mp, false);
Christoph Hellwig7d095252009-06-08 15:33:32 +0200598}
599
Darrick J. Wongc8ce5402017-06-16 11:00:05 -0700600uint64_t
Eric Sandeend5db0f92010-02-05 22:59:53 +0000601xfs_default_resblks(xfs_mount_t *mp)
602{
Darrick J. Wongc8ce5402017-06-16 11:00:05 -0700603 uint64_t resblks;
Eric Sandeend5db0f92010-02-05 22:59:53 +0000604
605 /*
Dave Chinner8babd8a2010-03-04 01:46:25 +0000606 * We default to 5% or 8192 fsbs of space reserved, whichever is
607 * smaller. This is intended to cover concurrent allocation
608 * transactions when we initially hit enospc. These each require a 4
609 * block reservation. Hence by default we cover roughly 2000 concurrent
610 * allocation reservations.
Eric Sandeend5db0f92010-02-05 22:59:53 +0000611 */
612 resblks = mp->m_sb.sb_dblocks;
613 do_div(resblks, 20);
Darrick J. Wongc8ce5402017-06-16 11:00:05 -0700614 resblks = min_t(uint64_t, resblks, 8192);
Eric Sandeend5db0f92010-02-05 22:59:53 +0000615 return resblks;
616}
617
Christoph Hellwig7d095252009-06-08 15:33:32 +0200618/*
Eric Sandeen0771fb42007-10-12 11:03:40 +1000619 * This function does the following on an initial mount of a file system:
620 * - reads the superblock from disk and init the mount struct
621 * - if we're a 32-bit kernel, do a size check on the superblock
622 * so we don't mount terabyte filesystems
623 * - init mount struct realtime fields
624 * - allocate inode hash table for fs
625 * - init directory manager
626 * - perform recovery and init the log manager
627 */
628int
629xfs_mountfs(
Brian Fosterf0b2efa2015-08-19 09:58:36 +1000630 struct xfs_mount *mp)
Eric Sandeen0771fb42007-10-12 11:03:40 +1000631{
Brian Fosterf0b2efa2015-08-19 09:58:36 +1000632 struct xfs_sb *sbp = &(mp->m_sb);
633 struct xfs_inode *rip;
Darrick J. Wongc8ce5402017-06-16 11:00:05 -0700634 uint64_t resblks;
Brian Fosterf0b2efa2015-08-19 09:58:36 +1000635 uint quotamount = 0;
636 uint quotaflags = 0;
637 int error = 0;
Eric Sandeen0771fb42007-10-12 11:03:40 +1000638
Dave Chinnerff550682013-08-12 20:49:41 +1000639 xfs_sb_mount_common(mp, sbp);
Eric Sandeen0771fb42007-10-12 11:03:40 +1000640
641 /*
Dave Chinner074e4272015-01-22 09:10:33 +1100642 * Check for a mismatched features2 values. Older kernels read & wrote
643 * into the wrong sb offset for sb_features2 on some platforms due to
644 * xfs_sb_t not being 64bit size aligned when sb_features2 was added,
645 * which made older superblock reading/writing routines swap it as a
646 * 64-bit value.
David Chinneree1c0902008-03-06 13:45:50 +1100647 *
Eric Sandeene6957ea2008-04-10 12:19:34 +1000648 * For backwards compatibility, we make both slots equal.
649 *
Dave Chinner074e4272015-01-22 09:10:33 +1100650 * If we detect a mismatched field, we OR the set bits into the existing
651 * features2 field in case it has already been modified; we don't want
652 * to lose any features. We then update the bad location with the ORed
653 * value so that older kernels will see any features2 flags. The
654 * superblock writeback code ensures the new sb_features2 is copied to
655 * sb_bad_features2 before it is logged or written to disk.
David Chinneree1c0902008-03-06 13:45:50 +1100656 */
Eric Sandeene6957ea2008-04-10 12:19:34 +1000657 if (xfs_sb_has_mismatched_features2(sbp)) {
Dave Chinner0b932cc2011-03-07 10:08:35 +1100658 xfs_warn(mp, "correcting sb_features alignment problem");
David Chinneree1c0902008-03-06 13:45:50 +1100659 sbp->sb_features2 |= sbp->sb_bad_features2;
Dave Chinner61e63ec2015-01-22 09:10:31 +1100660 mp->m_update_sb = true;
Eric Sandeene6957ea2008-04-10 12:19:34 +1000661
662 /*
663 * Re-check for ATTR2 in case it was found in bad_features2
664 * slot.
665 */
Tim Shimmin7c12f292008-04-30 18:15:28 +1000666 if (xfs_sb_version_hasattr2(&mp->m_sb) &&
667 !(mp->m_flags & XFS_MOUNT_NOATTR2))
Eric Sandeene6957ea2008-04-10 12:19:34 +1000668 mp->m_flags |= XFS_MOUNT_ATTR2;
Tim Shimmin7c12f292008-04-30 18:15:28 +1000669 }
Eric Sandeene6957ea2008-04-10 12:19:34 +1000670
Tim Shimmin7c12f292008-04-30 18:15:28 +1000671 if (xfs_sb_version_hasattr2(&mp->m_sb) &&
672 (mp->m_flags & XFS_MOUNT_NOATTR2)) {
673 xfs_sb_version_removeattr2(&mp->m_sb);
Dave Chinner61e63ec2015-01-22 09:10:31 +1100674 mp->m_update_sb = true;
Tim Shimmin7c12f292008-04-30 18:15:28 +1000675
676 /* update sb_versionnum for the clearing of the morebits */
677 if (!sbp->sb_features2)
Dave Chinner61e63ec2015-01-22 09:10:31 +1100678 mp->m_update_sb = true;
David Chinneree1c0902008-03-06 13:45:50 +1100679 }
680
Dave Chinner263997a2014-05-20 07:46:40 +1000681 /* always use v2 inodes by default now */
682 if (!(mp->m_sb.sb_versionnum & XFS_SB_VERSION_NLINKBIT)) {
683 mp->m_sb.sb_versionnum |= XFS_SB_VERSION_NLINKBIT;
Dave Chinner61e63ec2015-01-22 09:10:31 +1100684 mp->m_update_sb = true;
Dave Chinner263997a2014-05-20 07:46:40 +1000685 }
686
David Chinneree1c0902008-03-06 13:45:50 +1100687 /*
Eric Sandeen0771fb42007-10-12 11:03:40 +1000688 * Check if sb_agblocks is aligned at stripe boundary
689 * If sb_agblocks is NOT aligned turn off m_dalign since
690 * allocator alignment is within an ag, therefore ag has
691 * to be aligned at stripe boundary.
692 */
Christoph Hellwig7884bc82009-01-19 02:04:07 +0100693 error = xfs_update_alignment(mp);
Eric Sandeen0771fb42007-10-12 11:03:40 +1000694 if (error)
Christoph Hellwigf9057e32009-02-04 09:31:52 +0100695 goto out;
Eric Sandeen0771fb42007-10-12 11:03:40 +1000696
697 xfs_alloc_compute_maxlevels(mp);
698 xfs_bmap_compute_maxlevels(mp, XFS_DATA_FORK);
699 xfs_bmap_compute_maxlevels(mp, XFS_ATTR_FORK);
700 xfs_ialloc_compute_maxlevels(mp);
Darrick J. Wong035e00a2016-08-03 11:36:07 +1000701 xfs_rmapbt_compute_maxlevels(mp);
Darrick J. Wong1946b912016-10-03 09:11:18 -0700702 xfs_refcountbt_compute_maxlevels(mp);
Eric Sandeen0771fb42007-10-12 11:03:40 +1000703
704 xfs_set_maxicount(mp);
705
Carlos Maiolinoe6b3bb72016-05-18 11:11:27 +1000706 /* enable fail_at_unmount as default */
Thomas Meyer749f24f2017-10-09 11:38:54 -0700707 mp->m_fail_unmount = true;
Carlos Maiolinoe6b3bb72016-05-18 11:11:27 +1000708
Brian Fostera31b1d32014-07-15 08:07:01 +1000709 error = xfs_sysfs_init(&mp->m_kobj, &xfs_mp_ktype, NULL, mp->m_fsname);
Christoph Hellwig27174202009-03-30 10:21:31 +0200710 if (error)
711 goto out;
Eric Sandeen0771fb42007-10-12 11:03:40 +1000712
Bill O'Donnell225e4632015-10-12 18:21:19 +1100713 error = xfs_sysfs_init(&mp->m_stats.xs_kobj, &xfs_stats_ktype,
714 &mp->m_kobj, "stats");
Brian Fostera31b1d32014-07-15 08:07:01 +1000715 if (error)
716 goto out_remove_sysfs;
717
Carlos Maiolino192852b2016-05-18 10:58:51 +1000718 error = xfs_error_sysfs_init(mp);
Bill O'Donnell225e4632015-10-12 18:21:19 +1100719 if (error)
720 goto out_del_stats;
721
Darrick J. Wong31965ef2017-06-20 17:54:46 -0700722 error = xfs_errortag_init(mp);
723 if (error)
724 goto out_remove_error_sysfs;
Carlos Maiolino192852b2016-05-18 10:58:51 +1000725
726 error = xfs_uuid_mount(mp);
727 if (error)
Darrick J. Wong31965ef2017-06-20 17:54:46 -0700728 goto out_remove_errortag;
Carlos Maiolino192852b2016-05-18 10:58:51 +1000729
Eric Sandeen0771fb42007-10-12 11:03:40 +1000730 /*
731 * Set the minimum read and write sizes
732 */
733 xfs_set_rw_sizes(mp);
734
Dave Chinner055388a2011-01-04 11:35:03 +1100735 /* set the low space thresholds for dynamic preallocation */
736 xfs_set_low_space_thresholds(mp);
737
Eric Sandeen0771fb42007-10-12 11:03:40 +1000738 /*
739 * Set the inode cluster size.
740 * This may still be overridden by the file system
741 * block size if it is larger than the chosen cluster size.
Dave Chinner8f805872013-11-01 15:27:20 +1100742 *
743 * For v5 filesystems, scale the cluster size with the inode size to
744 * keep a constant ratio of inode per cluster buffer, but only if mkfs
745 * has set the inode alignment value appropriately for larger cluster
746 * sizes.
Eric Sandeen0771fb42007-10-12 11:03:40 +1000747 */
748 mp->m_inode_cluster_size = XFS_INODE_BIG_CLUSTER_SIZE;
Dave Chinner8f805872013-11-01 15:27:20 +1100749 if (xfs_sb_version_hascrc(&mp->m_sb)) {
750 int new_size = mp->m_inode_cluster_size;
751
752 new_size *= mp->m_sb.sb_inodesize / XFS_DINODE_MIN_SIZE;
753 if (mp->m_sb.sb_inoalignmt >= XFS_B_TO_FSBT(mp, new_size))
754 mp->m_inode_cluster_size = new_size;
Dave Chinner8f805872013-11-01 15:27:20 +1100755 }
Eric Sandeen0771fb42007-10-12 11:03:40 +1000756
757 /*
Brian Fostere5376fc2015-05-29 08:57:27 +1000758 * If enabled, sparse inode chunk alignment is expected to match the
759 * cluster size. Full inode chunk alignment must match the chunk size,
760 * but that is checked on sb read verification...
761 */
762 if (xfs_sb_version_hassparseinodes(&mp->m_sb) &&
763 mp->m_sb.sb_spino_align !=
764 XFS_B_TO_FSBT(mp, mp->m_inode_cluster_size)) {
765 xfs_warn(mp,
766 "Sparse inode block alignment (%u) must match cluster size (%llu).",
767 mp->m_sb.sb_spino_align,
768 XFS_B_TO_FSBT(mp, mp->m_inode_cluster_size));
769 error = -EINVAL;
770 goto out_remove_uuid;
771 }
772
773 /*
Eric Sandeen0771fb42007-10-12 11:03:40 +1000774 * Set inode alignment fields
775 */
776 xfs_set_inoalignment(mp);
777
778 /*
Zhi Yong Wuc2bfbc92013-08-12 03:15:03 +0000779 * Check that the data (and log if separate) is an ok size.
Eric Sandeen0771fb42007-10-12 11:03:40 +1000780 */
Christoph Hellwig42490232008-08-13 16:49:32 +1000781 error = xfs_check_sizes(mp);
Eric Sandeen0771fb42007-10-12 11:03:40 +1000782 if (error)
Christoph Hellwigf9057e32009-02-04 09:31:52 +0100783 goto out_remove_uuid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784
785 /*
786 * Initialize realtime fields in the mount structure
787 */
Eric Sandeen0771fb42007-10-12 11:03:40 +1000788 error = xfs_rtmount_init(mp);
789 if (error) {
Dave Chinner0b932cc2011-03-07 10:08:35 +1100790 xfs_warn(mp, "RT mount failed");
Christoph Hellwigf9057e32009-02-04 09:31:52 +0100791 goto out_remove_uuid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792 }
793
794 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795 * Copies the low order bits of the timestamp and the randomly
796 * set "sequence" number out of a UUID.
797 */
Christoph Hellwigcb0ba6c2017-05-05 09:39:10 +0200798 mp->m_fixedfsid[0] =
799 (get_unaligned_be16(&sbp->sb_uuid.b[8]) << 16) |
800 get_unaligned_be16(&sbp->sb_uuid.b[4]);
801 mp->m_fixedfsid[1] = get_unaligned_be32(&sbp->sb_uuid.b[0]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803 mp->m_dmevmask = 0; /* not persistent; set after each mount */
804
Dave Chinner0650b552014-06-06 15:01:58 +1000805 error = xfs_da_mount(mp);
806 if (error) {
807 xfs_warn(mp, "Failed dir/attr init: %d", error);
808 goto out_remove_uuid;
809 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810
811 /*
812 * Initialize the precomputed transaction reservations values.
813 */
814 xfs_trans_init(mp);
815
816 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817 * Allocate and initialize the per-ag data.
818 */
Dave Chinner1c1c6eb2010-01-11 11:47:44 +0000819 spin_lock_init(&mp->m_perag_lock);
Dave Chinner9b98b6f2010-05-27 01:58:13 +0000820 INIT_RADIX_TREE(&mp->m_perag_tree, GFP_ATOMIC);
Dave Chinner1c1c6eb2010-01-11 11:47:44 +0000821 error = xfs_initialize_perag(mp, sbp->sb_agcount, &mp->m_maxagi);
822 if (error) {
Dave Chinner0b932cc2011-03-07 10:08:35 +1100823 xfs_warn(mp, "Failed per-ag init: %d", error);
Dave Chinner0650b552014-06-06 15:01:58 +1000824 goto out_free_dir;
Dave Chinner1c1c6eb2010-01-11 11:47:44 +0000825 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700826
Christoph Hellwigf9057e32009-02-04 09:31:52 +0100827 if (!sbp->sb_logblocks) {
Dave Chinner0b932cc2011-03-07 10:08:35 +1100828 xfs_warn(mp, "no log defined");
Christoph Hellwigf9057e32009-02-04 09:31:52 +0100829 XFS_ERROR_REPORT("xfs_mountfs", XFS_ERRLEVEL_LOW, mp);
Dave Chinner24513372014-06-25 14:58:08 +1000830 error = -EFSCORRUPTED;
Christoph Hellwigf9057e32009-02-04 09:31:52 +0100831 goto out_free_perag;
832 }
833
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834 /*
Brian Fosterf0b2efa2015-08-19 09:58:36 +1000835 * 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.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838 */
Christoph Hellwigf9057e32009-02-04 09:31:52 +0100839 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) {
Dave Chinner0b932cc2011-03-07 10:08:35 +1100843 xfs_warn(mp, "log mount failed");
Dave Chinnerd4f35122012-04-23 15:59:06 +1000844 goto out_fail_wait;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845 }
846
847 /*
David Chinner92821e22007-05-24 15:26:31 +1000848 * Now the log is mounted, we know if it was an unclean shutdown or
849 * not. If it was, with the first phase of recovery has completed, we
850 * have consistent AG blocks on disk. We have not recovered EFIs yet,
851 * but they are recovered transactionally in the second recovery phase
852 * later.
853 *
854 * Hence we can safely re-initialise incore superblock counters from
855 * the per-ag data. These may not be correct if the filesystem was not
856 * cleanly unmounted, so we need to wait for recovery to finish before
857 * doing this.
858 *
859 * If the filesystem was cleanly unmounted, then we can trust the
860 * values in the superblock to be correct and we don't need to do
861 * anything here.
862 *
863 * If we are currently making the filesystem, the initialisation will
864 * fail as the perag data is in an undefined state.
865 */
David Chinner92821e22007-05-24 15:26:31 +1000866 if (xfs_sb_version_haslazysbcount(&mp->m_sb) &&
867 !XFS_LAST_UNMOUNT_WAS_CLEAN(mp) &&
868 !mp->m_sb.sb_inprogress) {
869 error = xfs_initialize_perag_data(mp, sbp->sb_agcount);
Christoph Hellwigf9057e32009-02-04 09:31:52 +0100870 if (error)
kbuild test robot6eee8972014-08-04 13:49:40 +1000871 goto out_log_dealloc;
David Chinner92821e22007-05-24 15:26:31 +1000872 }
Christoph Hellwigf9057e32009-02-04 09:31:52 +0100873
David Chinner92821e22007-05-24 15:26:31 +1000874 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875 * Get and sanity-check the root inode.
876 * Save the pointer to it in the mount structure.
877 */
Dave Chinner7b6259e2010-06-24 11:35:17 +1000878 error = xfs_iget(mp, NULL, sbp->sb_rootino, 0, XFS_ILOCK_EXCL, &rip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879 if (error) {
Dave Chinner0b932cc2011-03-07 10:08:35 +1100880 xfs_warn(mp, "failed to read root inode");
Christoph Hellwigf9057e32009-02-04 09:31:52 +0100881 goto out_log_dealloc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882 }
883
884 ASSERT(rip != NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885
Dave Chinnerc19b3b052016-02-09 16:54:58 +1100886 if (unlikely(!S_ISDIR(VFS_I(rip)->i_mode))) {
Dave Chinner0b932cc2011-03-07 10:08:35 +1100887 xfs_warn(mp, "corrupted root inode %llu: not a directory",
Nathan Scottb6574522006-06-09 15:29:40 +1000888 (unsigned long long)rip->i_ino);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889 xfs_iunlock(rip, XFS_ILOCK_EXCL);
890 XFS_ERROR_REPORT("xfs_mountfs_int(2)", XFS_ERRLEVEL_LOW,
891 mp);
Dave Chinner24513372014-06-25 14:58:08 +1000892 error = -EFSCORRUPTED;
Christoph Hellwigf9057e32009-02-04 09:31:52 +0100893 goto out_rele_rip;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700894 }
895 mp->m_rootip = rip; /* save it */
896
897 xfs_iunlock(rip, XFS_ILOCK_EXCL);
898
899 /*
900 * Initialize realtime inode pointers in the mount structure
901 */
Eric Sandeen0771fb42007-10-12 11:03:40 +1000902 error = xfs_rtmount_inodes(mp);
903 if (error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904 /*
905 * Free up the root inode.
906 */
Dave Chinner0b932cc2011-03-07 10:08:35 +1100907 xfs_warn(mp, "failed to read RT inodes");
Christoph Hellwigf9057e32009-02-04 09:31:52 +0100908 goto out_rele_rip;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700909 }
910
911 /*
Christoph Hellwig7884bc82009-01-19 02:04:07 +0100912 * If this is a read-only mount defer the superblock updates until
913 * the next remount into writeable mode. Otherwise we would never
914 * perform the update e.g. for the root filesystem.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915 */
Dave Chinner61e63ec2015-01-22 09:10:31 +1100916 if (mp->m_update_sb && !(mp->m_flags & XFS_MOUNT_RDONLY)) {
917 error = xfs_sync_sb(mp, false);
David Chinnere5720ee2008-04-10 12:21:18 +1000918 if (error) {
Dave Chinner0b932cc2011-03-07 10:08:35 +1100919 xfs_warn(mp, "failed to write sb changes");
Christoph Hellwigb93b6e42009-02-04 09:33:58 +0100920 goto out_rtunmount;
David Chinnere5720ee2008-04-10 12:21:18 +1000921 }
922 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923
924 /*
925 * Initialise the XFS quota management subsystem for this mount
926 */
Christoph Hellwig7d095252009-06-08 15:33:32 +0200927 if (XFS_IS_QUOTA_RUNNING(mp)) {
928 error = xfs_qm_newmount(mp, &quotamount, &quotaflags);
929 if (error)
930 goto out_rtunmount;
931 } else {
932 ASSERT(!XFS_IS_QUOTA_ON(mp));
933
934 /*
935 * If a file system had quotas running earlier, but decided to
936 * mount without -o uquota/pquota/gquota options, revoke the
937 * quotachecked license.
938 */
939 if (mp->m_sb.sb_qflags & XFS_ALL_QUOTA_ACCT) {
Dave Chinner0b932cc2011-03-07 10:08:35 +1100940 xfs_notice(mp, "resetting quota flags");
Christoph Hellwig7d095252009-06-08 15:33:32 +0200941 error = xfs_mount_reset_sbqflags(mp);
942 if (error)
Brian Fostera70a4fa2014-07-15 07:41:25 +1000943 goto out_rtunmount;
Christoph Hellwig7d095252009-06-08 15:33:32 +0200944 }
945 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946
947 /*
Brian Fosterf0b2efa2015-08-19 09:58:36 +1000948 * Finish recovering the file system. This part needed to be delayed
949 * until after the root and real-time bitmap inodes were consistently
950 * read in.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700951 */
Christoph Hellwig42490232008-08-13 16:49:32 +1000952 error = xfs_log_mount_finish(mp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700953 if (error) {
Dave Chinner0b932cc2011-03-07 10:08:35 +1100954 xfs_warn(mp, "log mount finish failed");
Christoph Hellwigb93b6e42009-02-04 09:33:58 +0100955 goto out_rtunmount;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700956 }
957
958 /*
Dave Chinnerddeb14f2016-09-26 08:21:44 +1000959 * Now the log is fully replayed, we can transition to full read-only
960 * mode for read-only mounts. This will sync all the metadata and clean
961 * the log so that the recovery we just performed does not have to be
962 * replayed again on the next mount.
963 *
964 * We use the same quiesce mechanism as the rw->ro remount, as they are
965 * semantically identical operations.
966 */
967 if ((mp->m_flags & (XFS_MOUNT_RDONLY|XFS_MOUNT_NORECOVERY)) ==
968 XFS_MOUNT_RDONLY) {
969 xfs_quiesce_attr(mp);
970 }
971
972 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700973 * Complete the quota initialisation, post-log-replay component.
974 */
Christoph Hellwig7d095252009-06-08 15:33:32 +0200975 if (quotamount) {
976 ASSERT(mp->m_qflags == 0);
977 mp->m_qflags = quotaflags;
978
979 xfs_qm_mount_quotas(mp);
980 }
981
David Chinner84e1e992007-06-18 16:50:27 +1000982 /*
983 * Now we are mounted, reserve a small amount of unused space for
984 * privileged transactions. This is needed so that transaction
985 * space required for critical operations can dip into this pool
986 * when at ENOSPC. This is needed for operations like create with
987 * attr, unwritten extent conversion at ENOSPC, etc. Data allocations
988 * are not allowed to use this reserved space.
Dave Chinner8babd8a2010-03-04 01:46:25 +0000989 *
990 * This may drive us straight to ENOSPC on mount, but that implies
991 * we were already there on the last unmount. Warn if this occurs.
David Chinner84e1e992007-06-18 16:50:27 +1000992 */
Eric Sandeend5db0f92010-02-05 22:59:53 +0000993 if (!(mp->m_flags & XFS_MOUNT_RDONLY)) {
994 resblks = xfs_default_resblks(mp);
995 error = xfs_reserve_blocks(mp, &resblks, NULL);
996 if (error)
Dave Chinner0b932cc2011-03-07 10:08:35 +1100997 xfs_warn(mp,
998 "Unable to allocate reserve blocks. Continuing without reserve pool.");
Darrick J. Wong174edb02016-10-03 09:11:39 -0700999
1000 /* Recover any CoW blocks that never got remapped. */
1001 error = xfs_reflink_recover_cow(mp);
1002 if (error) {
1003 xfs_err(mp,
1004 "Error %d recovering leftover CoW allocations.", error);
1005 xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
1006 goto out_quota;
1007 }
Darrick J. Wong84d69612016-10-03 09:11:44 -07001008
1009 /* Reserve AG blocks for future btree expansion. */
1010 error = xfs_fs_reserve_ag_blocks(mp);
1011 if (error && error != -ENOSPC)
1012 goto out_agresv;
Eric Sandeend5db0f92010-02-05 22:59:53 +00001013 }
David Chinner84e1e992007-06-18 16:50:27 +10001014
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015 return 0;
1016
Darrick J. Wong84d69612016-10-03 09:11:44 -07001017 out_agresv:
1018 xfs_fs_unreserve_ag_blocks(mp);
Darrick J. Wong174edb02016-10-03 09:11:39 -07001019 out_quota:
1020 xfs_qm_unmount_quotas(mp);
Christoph Hellwigb93b6e42009-02-04 09:33:58 +01001021 out_rtunmount:
1022 xfs_rtunmount_inodes(mp);
Christoph Hellwigf9057e32009-02-04 09:31:52 +01001023 out_rele_rip:
Christoph Hellwig43355092008-03-27 18:01:08 +11001024 IRELE(rip);
Brian Foster0ae120f2015-08-19 10:00:28 +10001025 cancel_delayed_work_sync(&mp->m_reclaim_work);
1026 xfs_reclaim_inodes(mp, SYNC_WAIT);
Darrick J. Wong77aff8c2017-08-10 14:20:29 -07001027 /* Clean out dquots that might be in memory after quotacheck. */
1028 xfs_qm_unmount(mp);
Christoph Hellwigf9057e32009-02-04 09:31:52 +01001029 out_log_dealloc:
Carlos Maiolinoe6b3bb72016-05-18 11:11:27 +10001030 mp->m_flags |= XFS_MOUNT_UNMOUNTING;
Brian Fosterf0b2efa2015-08-19 09:58:36 +10001031 xfs_log_mount_cancel(mp);
Dave Chinnerd4f35122012-04-23 15:59:06 +10001032 out_fail_wait:
1033 if (mp->m_logdev_targp && mp->m_logdev_targp != mp->m_ddev_targp)
1034 xfs_wait_buftarg(mp->m_logdev_targp);
1035 xfs_wait_buftarg(mp->m_ddev_targp);
Christoph Hellwigf9057e32009-02-04 09:31:52 +01001036 out_free_perag:
Christoph Hellwigff4f0382008-08-13 16:50:47 +10001037 xfs_free_perag(mp);
Dave Chinner0650b552014-06-06 15:01:58 +10001038 out_free_dir:
1039 xfs_da_unmount(mp);
Christoph Hellwigf9057e32009-02-04 09:31:52 +01001040 out_remove_uuid:
Christoph Hellwig27174202009-03-30 10:21:31 +02001041 xfs_uuid_unmount(mp);
Darrick J. Wong31965ef2017-06-20 17:54:46 -07001042 out_remove_errortag:
1043 xfs_errortag_del(mp);
Carlos Maiolino192852b2016-05-18 10:58:51 +10001044 out_remove_error_sysfs:
1045 xfs_error_sysfs_del(mp);
Bill O'Donnell225e4632015-10-12 18:21:19 +11001046 out_del_stats:
1047 xfs_sysfs_del(&mp->m_stats.xs_kobj);
Brian Fostera31b1d32014-07-15 08:07:01 +10001048 out_remove_sysfs:
1049 xfs_sysfs_del(&mp->m_kobj);
Christoph Hellwigf9057e32009-02-04 09:31:52 +01001050 out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001051 return error;
1052}
1053
1054/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001055 * This flushes out the inodes,dquots and the superblock, unmounts the
1056 * log and makes sure that incore structures are freed.
1057 */
Christoph Hellwig41b5c2e2008-08-13 16:49:57 +10001058void
1059xfs_unmountfs(
1060 struct xfs_mount *mp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001061{
Darrick J. Wongc8ce5402017-06-16 11:00:05 -07001062 uint64_t resblks;
Christoph Hellwig41b5c2e2008-08-13 16:49:57 +10001063 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001064
Brian Foster579b62f2012-11-06 09:50:47 -05001065 cancel_delayed_work_sync(&mp->m_eofblocks_work);
Darrick J. Wong83104d42016-10-03 09:11:46 -07001066 cancel_delayed_work_sync(&mp->m_cowblocks_work);
Brian Foster579b62f2012-11-06 09:50:47 -05001067
Darrick J. Wong84d69612016-10-03 09:11:44 -07001068 xfs_fs_unreserve_ag_blocks(mp);
Christoph Hellwig7d095252009-06-08 15:33:32 +02001069 xfs_qm_unmount_quotas(mp);
Christoph Hellwigb93b6e42009-02-04 09:33:58 +01001070 xfs_rtunmount_inodes(mp);
Christoph Hellwig77508ec2008-08-13 16:49:04 +10001071 IRELE(mp->m_rootip);
1072
David Chinner641c56f2007-06-18 16:50:17 +10001073 /*
1074 * We can potentially deadlock here if we have an inode cluster
Malcolm Parsons9da096f2009-03-29 09:55:42 +02001075 * that has been freed has its buffer still pinned in memory because
David Chinner641c56f2007-06-18 16:50:17 +10001076 * the transaction is still sitting in a iclog. The stale inodes
1077 * on that buffer will have their flush locks held until the
1078 * transaction hits the disk and the callbacks run. the inode
1079 * flush takes the flush lock unconditionally and with nothing to
1080 * push out the iclog we will never get that unlocked. hence we
1081 * need to force the log first.
1082 */
Christoph Hellwiga14a3482010-01-19 09:56:46 +00001083 xfs_log_force(mp, XFS_LOG_SYNC);
Dave Chinnerc8543632010-02-06 12:39:36 +11001084
1085 /*
Christoph Hellwigebf55872017-02-07 14:06:57 -08001086 * Wait for all busy extents to be freed, including completion of
1087 * any discard operation.
1088 */
1089 xfs_extent_busy_wait_all(mp);
Christoph Hellwig4560e782017-02-07 14:07:58 -08001090 flush_workqueue(xfs_discard_wq);
Christoph Hellwigebf55872017-02-07 14:06:57 -08001091
1092 /*
Carlos Maiolinoe6b3bb72016-05-18 11:11:27 +10001093 * We now need to tell the world we are unmounting. This will allow
1094 * us to detect that the filesystem is going away and we should error
1095 * out anything that we have been retrying in the background. This will
1096 * prevent neverending retries in AIL pushing from hanging the unmount.
1097 */
1098 mp->m_flags |= XFS_MOUNT_UNMOUNTING;
1099
1100 /*
Christoph Hellwig211e4d42012-04-23 15:58:34 +10001101 * Flush all pending changes from the AIL.
Dave Chinnerc8543632010-02-06 12:39:36 +11001102 */
Christoph Hellwig211e4d42012-04-23 15:58:34 +10001103 xfs_ail_push_all_sync(mp->m_ail);
1104
1105 /*
1106 * And reclaim all inodes. At this point there should be no dirty
Dave Chinner7e185302012-10-08 21:56:00 +11001107 * inodes and none should be pinned or locked, but use synchronous
1108 * reclaim just to be sure. We can stop background inode reclaim
1109 * here as well if it is still running.
Christoph Hellwig211e4d42012-04-23 15:58:34 +10001110 */
Dave Chinner7e185302012-10-08 21:56:00 +11001111 cancel_delayed_work_sync(&mp->m_reclaim_work);
Dave Chinnerc8543632010-02-06 12:39:36 +11001112 xfs_reclaim_inodes(mp, SYNC_WAIT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001113
Christoph Hellwig7d095252009-06-08 15:33:32 +02001114 xfs_qm_unmount(mp);
Lachlan McIlroya357a122008-10-30 16:53:25 +11001115
Linus Torvalds1da177e2005-04-16 15:20:36 -07001116 /*
David Chinner84e1e992007-06-18 16:50:27 +10001117 * Unreserve any blocks we have so that when we unmount we don't account
1118 * the reserved free space as used. This is really only necessary for
1119 * lazy superblock counting because it trusts the incore superblock
Malcolm Parsons9da096f2009-03-29 09:55:42 +02001120 * counters to be absolutely correct on clean unmount.
David Chinner84e1e992007-06-18 16:50:27 +10001121 *
1122 * We don't bother correcting this elsewhere for lazy superblock
1123 * counting because on mount of an unclean filesystem we reconstruct the
1124 * correct counter value and this is irrelevant.
1125 *
1126 * For non-lazy counter filesystems, this doesn't matter at all because
1127 * we only every apply deltas to the superblock and hence the incore
1128 * value does not matter....
1129 */
1130 resblks = 0;
David Chinner714082b2008-04-10 12:20:03 +10001131 error = xfs_reserve_blocks(mp, &resblks, NULL);
1132 if (error)
Dave Chinner0b932cc2011-03-07 10:08:35 +11001133 xfs_warn(mp, "Unable to free reserved block pool. "
David Chinner714082b2008-04-10 12:20:03 +10001134 "Freespace may not be correct on next mount.");
1135
Chandra Seetharamanadab0f62011-06-29 22:10:14 +00001136 error = xfs_log_sbcount(mp);
David Chinnere5720ee2008-04-10 12:21:18 +10001137 if (error)
Dave Chinner0b932cc2011-03-07 10:08:35 +11001138 xfs_warn(mp, "Unable to update superblock counters. "
David Chinnere5720ee2008-04-10 12:21:18 +10001139 "Freespace may not be correct on next mount.");
Christoph Hellwig87c7bec2011-09-14 14:08:26 +00001140
Bill O'Donnell225e4632015-10-12 18:21:19 +11001141
Christoph Hellwig21b699c2009-03-16 08:19:29 +01001142 xfs_log_unmount(mp);
Dave Chinner0650b552014-06-06 15:01:58 +10001143 xfs_da_unmount(mp);
Christoph Hellwig27174202009-03-30 10:21:31 +02001144 xfs_uuid_unmount(mp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001145
Christoph Hellwig1550d0b2008-08-13 16:17:37 +10001146#if defined(DEBUG)
Darrick J. Wong31965ef2017-06-20 17:54:46 -07001147 xfs_errortag_clearall(mp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148#endif
Christoph Hellwigff4f0382008-08-13 16:50:47 +10001149 xfs_free_perag(mp);
Brian Fostera31b1d32014-07-15 08:07:01 +10001150
Darrick J. Wong31965ef2017-06-20 17:54:46 -07001151 xfs_errortag_del(mp);
Carlos Maiolino192852b2016-05-18 10:58:51 +10001152 xfs_error_sysfs_del(mp);
Bill O'Donnell225e4632015-10-12 18:21:19 +11001153 xfs_sysfs_del(&mp->m_stats.xs_kobj);
Brian Fostera31b1d32014-07-15 08:07:01 +10001154 xfs_sysfs_del(&mp->m_kobj);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001155}
1156
Brian Foster91ee5752014-11-28 14:02:59 +11001157/*
1158 * Determine whether modifications can proceed. The caller specifies the minimum
1159 * freeze level for which modifications should not be allowed. This allows
1160 * certain operations to proceed while the freeze sequence is in progress, if
1161 * necessary.
1162 */
1163bool
1164xfs_fs_writable(
1165 struct xfs_mount *mp,
1166 int level)
David Chinner92821e22007-05-24 15:26:31 +10001167{
Brian Foster91ee5752014-11-28 14:02:59 +11001168 ASSERT(level > SB_UNFROZEN);
1169 if ((mp->m_super->s_writers.frozen >= level) ||
1170 XFS_FORCED_SHUTDOWN(mp) || (mp->m_flags & XFS_MOUNT_RDONLY))
1171 return false;
1172
1173 return true;
David Chinner92821e22007-05-24 15:26:31 +10001174}
1175
1176/*
Alex Elderb2ce3972011-07-11 09:51:44 -05001177 * xfs_log_sbcount
1178 *
Chandra Seetharamanadab0f62011-06-29 22:10:14 +00001179 * Sync the superblock counters to disk.
Alex Elderb2ce3972011-07-11 09:51:44 -05001180 *
Brian Foster91ee5752014-11-28 14:02:59 +11001181 * Note this code can be called during the process of freezing, so we use the
1182 * transaction allocator that does not block when the transaction subsystem is
1183 * in its frozen state.
David Chinner92821e22007-05-24 15:26:31 +10001184 */
1185int
Chandra Seetharamanadab0f62011-06-29 22:10:14 +00001186xfs_log_sbcount(xfs_mount_t *mp)
David Chinner92821e22007-05-24 15:26:31 +10001187{
Brian Foster91ee5752014-11-28 14:02:59 +11001188 /* allow this to proceed during the freeze sequence... */
1189 if (!xfs_fs_writable(mp, SB_FREEZE_COMPLETE))
David Chinner92821e22007-05-24 15:26:31 +10001190 return 0;
1191
David Chinner92821e22007-05-24 15:26:31 +10001192 /*
1193 * we don't need to do this if we are updating the superblock
1194 * counters on every modification.
1195 */
1196 if (!xfs_sb_version_haslazysbcount(&mp->m_sb))
1197 return 0;
1198
Dave Chinner61e63ec2015-01-22 09:10:31 +11001199 return xfs_sync_sb(mp, true);
David Chinner92821e22007-05-24 15:26:31 +10001200}
1201
Dave Chinner8c1903d2015-05-29 07:39:34 +10001202/*
1203 * Deltas for the inode count are +/-64, hence we use a large batch size
1204 * of 128 so we don't need to take the counter lock on every update.
1205 */
1206#define XFS_ICOUNT_BATCH 128
Dave Chinner501ab322015-02-23 21:19:28 +11001207int
1208xfs_mod_icount(
1209 struct xfs_mount *mp,
1210 int64_t delta)
1211{
Nikolay Borisov104b4e52017-06-20 21:01:20 +03001212 percpu_counter_add_batch(&mp->m_icount, delta, XFS_ICOUNT_BATCH);
Dave Chinner8c1903d2015-05-29 07:39:34 +10001213 if (__percpu_counter_compare(&mp->m_icount, 0, XFS_ICOUNT_BATCH) < 0) {
Dave Chinner501ab322015-02-23 21:19:28 +11001214 ASSERT(0);
1215 percpu_counter_add(&mp->m_icount, -delta);
1216 return -EINVAL;
1217 }
1218 return 0;
1219}
1220
Dave Chinnere88b64e2015-02-23 21:19:53 +11001221int
1222xfs_mod_ifree(
1223 struct xfs_mount *mp,
1224 int64_t delta)
1225{
1226 percpu_counter_add(&mp->m_ifree, delta);
1227 if (percpu_counter_compare(&mp->m_ifree, 0) < 0) {
1228 ASSERT(0);
1229 percpu_counter_add(&mp->m_ifree, -delta);
1230 return -EINVAL;
1231 }
1232 return 0;
1233}
Dave Chinner0d485ad2015-02-23 21:22:03 +11001234
Dave Chinner8c1903d2015-05-29 07:39:34 +10001235/*
1236 * Deltas for the block count can vary from 1 to very large, but lock contention
1237 * only occurs on frequent small block count updates such as in the delayed
1238 * allocation path for buffered writes (page a time updates). Hence we set
1239 * a large batch count (1024) to minimise global counter updates except when
1240 * we get near to ENOSPC and we have to be very accurate with our updates.
1241 */
1242#define XFS_FDBLOCKS_BATCH 1024
Dave Chinner0d485ad2015-02-23 21:22:03 +11001243int
1244xfs_mod_fdblocks(
1245 struct xfs_mount *mp,
1246 int64_t delta,
1247 bool rsvd)
1248{
1249 int64_t lcounter;
1250 long long res_used;
1251 s32 batch;
1252
1253 if (delta > 0) {
1254 /*
1255 * If the reserve pool is depleted, put blocks back into it
1256 * first. Most of the time the pool is full.
1257 */
1258 if (likely(mp->m_resblks == mp->m_resblks_avail)) {
1259 percpu_counter_add(&mp->m_fdblocks, delta);
1260 return 0;
1261 }
1262
1263 spin_lock(&mp->m_sb_lock);
1264 res_used = (long long)(mp->m_resblks - mp->m_resblks_avail);
1265
1266 if (res_used > delta) {
1267 mp->m_resblks_avail += delta;
1268 } else {
1269 delta -= res_used;
1270 mp->m_resblks_avail = mp->m_resblks;
1271 percpu_counter_add(&mp->m_fdblocks, delta);
1272 }
1273 spin_unlock(&mp->m_sb_lock);
1274 return 0;
1275 }
1276
1277 /*
1278 * Taking blocks away, need to be more accurate the closer we
1279 * are to zero.
1280 *
Dave Chinner0d485ad2015-02-23 21:22:03 +11001281 * If the counter has a value of less than 2 * max batch size,
1282 * then make everything serialise as we are real close to
1283 * ENOSPC.
1284 */
Dave Chinner8c1903d2015-05-29 07:39:34 +10001285 if (__percpu_counter_compare(&mp->m_fdblocks, 2 * XFS_FDBLOCKS_BATCH,
1286 XFS_FDBLOCKS_BATCH) < 0)
Dave Chinner0d485ad2015-02-23 21:22:03 +11001287 batch = 1;
1288 else
Dave Chinner8c1903d2015-05-29 07:39:34 +10001289 batch = XFS_FDBLOCKS_BATCH;
Dave Chinner0d485ad2015-02-23 21:22:03 +11001290
Nikolay Borisov104b4e52017-06-20 21:01:20 +03001291 percpu_counter_add_batch(&mp->m_fdblocks, delta, batch);
Darrick J. Wong52548852016-08-03 11:38:24 +10001292 if (__percpu_counter_compare(&mp->m_fdblocks, mp->m_alloc_set_aside,
Dave Chinner8c1903d2015-05-29 07:39:34 +10001293 XFS_FDBLOCKS_BATCH) >= 0) {
Dave Chinner0d485ad2015-02-23 21:22:03 +11001294 /* we had space! */
1295 return 0;
1296 }
1297
1298 /*
1299 * lock up the sb for dipping into reserves before releasing the space
1300 * that took us to ENOSPC.
1301 */
1302 spin_lock(&mp->m_sb_lock);
1303 percpu_counter_add(&mp->m_fdblocks, -delta);
1304 if (!rsvd)
1305 goto fdblocks_enospc;
1306
1307 lcounter = (long long)mp->m_resblks_avail + delta;
1308 if (lcounter >= 0) {
1309 mp->m_resblks_avail = lcounter;
1310 spin_unlock(&mp->m_sb_lock);
1311 return 0;
1312 }
1313 printk_once(KERN_WARNING
1314 "Filesystem \"%s\": reserve blocks depleted! "
1315 "Consider increasing reserve pool size.",
1316 mp->m_fsname);
1317fdblocks_enospc:
1318 spin_unlock(&mp->m_sb_lock);
1319 return -ENOSPC;
1320}
1321
Dave Chinnerbab98bb2015-02-23 21:22:54 +11001322int
1323xfs_mod_frextents(
1324 struct xfs_mount *mp,
1325 int64_t delta)
1326{
1327 int64_t lcounter;
1328 int ret = 0;
1329
1330 spin_lock(&mp->m_sb_lock);
1331 lcounter = mp->m_sb.sb_frextents + delta;
1332 if (lcounter < 0)
1333 ret = -ENOSPC;
1334 else
1335 mp->m_sb.sb_frextents = lcounter;
1336 spin_unlock(&mp->m_sb_lock);
1337 return ret;
1338}
1339
Linus Torvalds1da177e2005-04-16 15:20:36 -07001340/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341 * xfs_getsb() is called to obtain the buffer for the superblock.
1342 * The buffer is returned locked and read in from disk.
1343 * The buffer should be released with a call to xfs_brelse().
1344 *
1345 * If the flags parameter is BUF_TRYLOCK, then we'll only return
1346 * the superblock buffer if it can be locked without sleeping.
1347 * If it can't then we'll return NULL.
1348 */
Christoph Hellwig0c842ad2011-07-08 14:36:19 +02001349struct xfs_buf *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001350xfs_getsb(
Christoph Hellwig0c842ad2011-07-08 14:36:19 +02001351 struct xfs_mount *mp,
1352 int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001353{
Christoph Hellwig0c842ad2011-07-08 14:36:19 +02001354 struct xfs_buf *bp = mp->m_sb_bp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001355
Christoph Hellwig0c842ad2011-07-08 14:36:19 +02001356 if (!xfs_buf_trylock(bp)) {
1357 if (flags & XBF_TRYLOCK)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001358 return NULL;
Christoph Hellwig0c842ad2011-07-08 14:36:19 +02001359 xfs_buf_lock(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001360 }
Christoph Hellwig0c842ad2011-07-08 14:36:19 +02001361
Chandra Seetharaman72790aa2011-07-22 23:40:04 +00001362 xfs_buf_hold(bp);
Dave Chinnerb0388bf2016-02-10 15:01:11 +11001363 ASSERT(bp->b_flags & XBF_DONE);
Jesper Juhl014c2542006-01-15 02:37:08 +01001364 return bp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001365}
1366
1367/*
1368 * Used to free the superblock along various error paths.
1369 */
1370void
1371xfs_freesb(
Dave Chinner26af6552010-09-22 10:47:20 +10001372 struct xfs_mount *mp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001373{
Dave Chinner26af6552010-09-22 10:47:20 +10001374 struct xfs_buf *bp = mp->m_sb_bp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001375
Dave Chinner26af6552010-09-22 10:47:20 +10001376 xfs_buf_lock(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001377 mp->m_sb_bp = NULL;
Dave Chinner26af6552010-09-22 10:47:20 +10001378 xfs_buf_relse(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001379}
1380
1381/*
Christoph Hellwigdda35b82010-02-15 09:44:46 +00001382 * If the underlying (data/log/rt) device is readonly, there are some
1383 * operations that cannot proceed.
1384 */
1385int
1386xfs_dev_is_read_only(
1387 struct xfs_mount *mp,
1388 char *message)
1389{
1390 if (xfs_readonly_buftarg(mp->m_ddev_targp) ||
1391 xfs_readonly_buftarg(mp->m_logdev_targp) ||
1392 (mp->m_rtdev_targp && xfs_readonly_buftarg(mp->m_rtdev_targp))) {
Dave Chinner0b932cc2011-03-07 10:08:35 +11001393 xfs_notice(mp, "%s required on read-only device.", message);
1394 xfs_notice(mp, "write access unavailable, cannot proceed.");
Dave Chinner24513372014-06-25 14:58:08 +10001395 return -EROFS;
Christoph Hellwigdda35b82010-02-15 09:44:46 +00001396 }
1397 return 0;
1398}