blob: bf92e0c037c7378cadf1848a4324968170e1ae29 [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 Chinner70a9883c2013-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"
Dave Chinner57062782013-10-15 09:17:51 +110027#include "xfs_da_format.h"
Dave Chinner9a2cc412014-12-04 09:43:17 +110028#include "xfs_da_btree.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070029#include "xfs_inode.h"
Dave Chinnera4fbe6a2013-10-23 10:51:50 +110030#include "xfs_dir2.h"
Nathan Scotta844f452005-11-02 14:38:42 +110031#include "xfs_ialloc.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#include "xfs_alloc.h"
33#include "xfs_rtalloc.h"
34#include "xfs_bmap.h"
Dave Chinnera4fbe6a2013-10-23 10:51:50 +110035#include "xfs_trans.h"
36#include "xfs_trans_priv.h"
37#include "xfs_log.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070038#include "xfs_error.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070039#include "xfs_quota.h"
40#include "xfs_fsops.h"
Christoph Hellwig0b1b2132009-12-14 23:14:59 +000041#include "xfs_trace.h"
Dave Chinner6d8b79c2012-10-08 21:56:09 +110042#include "xfs_icache.h"
Brian Fostera31b1d32014-07-15 08:07:01 +100043#include "xfs_sysfs.h"
Christoph Hellwig0b1b2132009-12-14 23:14:59 +000044
Linus Torvalds1da177e2005-04-16 15:20:36 -070045
Christoph Hellwig27174202009-03-30 10:21:31 +020046static DEFINE_MUTEX(xfs_uuid_table_mutex);
47static int xfs_uuid_table_size;
48static uuid_t *xfs_uuid_table;
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 */
54STATIC int
55xfs_uuid_mount(
56 struct xfs_mount *mp)
57{
58 uuid_t *uuid = &mp->m_sb.sb_uuid;
59 int hole, i;
60
61 if (mp->m_flags & XFS_MOUNT_NOUUID)
62 return 0;
63
64 if (uuid_is_nil(uuid)) {
Dave Chinner0b932cc2011-03-07 10:08:35 +110065 xfs_warn(mp, "Filesystem has nil UUID - can't mount");
Dave Chinner24513372014-06-25 14:58:08 +100066 return -EINVAL;
Christoph Hellwig27174202009-03-30 10:21:31 +020067 }
68
69 mutex_lock(&xfs_uuid_table_mutex);
70 for (i = 0, hole = -1; i < xfs_uuid_table_size; i++) {
71 if (uuid_is_nil(&xfs_uuid_table[i])) {
72 hole = i;
73 continue;
74 }
75 if (uuid_equal(uuid, &xfs_uuid_table[i]))
76 goto out_duplicate;
77 }
78
79 if (hole < 0) {
80 xfs_uuid_table = kmem_realloc(xfs_uuid_table,
81 (xfs_uuid_table_size + 1) * sizeof(*xfs_uuid_table),
82 xfs_uuid_table_size * sizeof(*xfs_uuid_table),
83 KM_SLEEP);
84 hole = xfs_uuid_table_size++;
85 }
86 xfs_uuid_table[hole] = *uuid;
87 mutex_unlock(&xfs_uuid_table_mutex);
88
89 return 0;
90
91 out_duplicate:
92 mutex_unlock(&xfs_uuid_table_mutex);
Mitsuo Hayasaka021000e2012-01-13 05:58:39 +000093 xfs_warn(mp, "Filesystem has duplicate UUID %pU - can't mount", uuid);
Dave Chinner24513372014-06-25 14:58:08 +100094 return -EINVAL;
Christoph Hellwig27174202009-03-30 10:21:31 +020095}
96
97STATIC void
98xfs_uuid_unmount(
99 struct xfs_mount *mp)
100{
101 uuid_t *uuid = &mp->m_sb.sb_uuid;
102 int i;
103
104 if (mp->m_flags & XFS_MOUNT_NOUUID)
105 return;
106
107 mutex_lock(&xfs_uuid_table_mutex);
108 for (i = 0; i < xfs_uuid_table_size; i++) {
109 if (uuid_is_nil(&xfs_uuid_table[i]))
110 continue;
111 if (!uuid_equal(uuid, &xfs_uuid_table[i]))
112 continue;
113 memset(&xfs_uuid_table[i], 0, sizeof(uuid_t));
114 break;
115 }
116 ASSERT(i < xfs_uuid_table_size);
117 mutex_unlock(&xfs_uuid_table_mutex);
118}
119
120
Dave Chinnere1765792010-09-22 10:47:20 +1000121STATIC void
122__xfs_free_perag(
123 struct rcu_head *head)
124{
125 struct xfs_perag *pag = container_of(head, struct xfs_perag, rcu_head);
126
127 ASSERT(atomic_read(&pag->pag_ref) == 0);
128 kmem_free(pag);
129}
130
Dave Chinner0fa800f2010-01-11 11:47:46 +0000131/*
Dave Chinnere1765792010-09-22 10:47:20 +1000132 * Free up the per-ag resources associated with the mount structure.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133 */
Christoph Hellwigc962fb72008-05-20 15:10:52 +1000134STATIC void
Christoph Hellwigff4f0382008-08-13 16:50:47 +1000135xfs_free_perag(
Christoph Hellwig745f6912007-08-30 17:20:39 +1000136 xfs_mount_t *mp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137{
Dave Chinner1c1c6eb2010-01-11 11:47:44 +0000138 xfs_agnumber_t agno;
139 struct xfs_perag *pag;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140
Dave Chinner1c1c6eb2010-01-11 11:47:44 +0000141 for (agno = 0; agno < mp->m_sb.sb_agcount; agno++) {
142 spin_lock(&mp->m_perag_lock);
143 pag = radix_tree_delete(&mp->m_perag_tree, agno);
144 spin_unlock(&mp->m_perag_lock);
Dave Chinnere1765792010-09-22 10:47:20 +1000145 ASSERT(pag);
Dave Chinnerf83282a2010-11-08 08:55:04 +0000146 ASSERT(atomic_read(&pag->pag_ref) == 0);
Dave Chinnere1765792010-09-22 10:47:20 +1000147 call_rcu(&pag->rcu_head, __xfs_free_perag);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149}
150
Nathan Scott4cc929e2007-05-14 18:24:02 +1000151/*
152 * Check size of device based on the (data/realtime) block count.
153 * Note: this check is used by the growfs code as well as mount.
154 */
155int
156xfs_sb_validate_fsb_count(
157 xfs_sb_t *sbp,
158 __uint64_t nblocks)
159{
160 ASSERT(PAGE_SHIFT >= sbp->sb_blocklog);
161 ASSERT(sbp->sb_blocklog >= BBSHIFT);
162
Christoph Hellwigd5cf09b2014-07-30 09:12:05 +1000163 /* Limited by ULONG_MAX of page cache index */
Nathan Scott4cc929e2007-05-14 18:24:02 +1000164 if (nblocks >> (PAGE_CACHE_SHIFT - sbp->sb_blocklog) > ULONG_MAX)
Dave Chinner24513372014-06-25 14:58:08 +1000165 return -EFBIG;
Nathan Scott4cc929e2007-05-14 18:24:02 +1000166 return 0;
167}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168
Dave Chinner1c1c6eb2010-01-11 11:47:44 +0000169int
Nathan Scottc11e2c32005-11-02 15:11:45 +1100170xfs_initialize_perag(
Nathan Scottc11e2c32005-11-02 15:11:45 +1100171 xfs_mount_t *mp,
Dave Chinner1c1c6eb2010-01-11 11:47:44 +0000172 xfs_agnumber_t agcount,
173 xfs_agnumber_t *maxagi)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174{
Carlos Maiolino2d2194f2012-09-20 10:32:38 -0300175 xfs_agnumber_t index;
Dave Chinner8b26c582010-01-11 11:47:48 +0000176 xfs_agnumber_t first_initialised = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177 xfs_perag_t *pag;
178 xfs_agino_t agino;
179 xfs_ino_t ino;
180 xfs_sb_t *sbp = &mp->m_sb;
Dave Chinner8b26c582010-01-11 11:47:48 +0000181 int error = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182
Dave Chinner1c1c6eb2010-01-11 11:47:44 +0000183 /*
184 * Walk the current per-ag tree so we don't try to initialise AGs
185 * that already exist (growfs case). Allocate and insert all the
186 * AGs we don't find ready for initialisation.
187 */
188 for (index = 0; index < agcount; index++) {
189 pag = xfs_perag_get(mp, index);
190 if (pag) {
191 xfs_perag_put(pag);
192 continue;
193 }
Dave Chinner8b26c582010-01-11 11:47:48 +0000194 if (!first_initialised)
195 first_initialised = index;
Christoph Hellwigfb3b5042010-05-28 19:03:10 +0000196
Dave Chinner1c1c6eb2010-01-11 11:47:44 +0000197 pag = kmem_zalloc(sizeof(*pag), KM_MAYFAIL);
198 if (!pag)
Dave Chinner8b26c582010-01-11 11:47:48 +0000199 goto out_unwind;
Christoph Hellwigfb3b5042010-05-28 19:03:10 +0000200 pag->pag_agno = index;
201 pag->pag_mount = mp;
Dave Chinner1a427ab2010-12-16 17:08:41 +1100202 spin_lock_init(&pag->pag_ici_lock);
Dave Chinner69b491c2010-09-27 11:09:51 +1000203 mutex_init(&pag->pag_ici_reclaim_lock);
Christoph Hellwigfb3b5042010-05-28 19:03:10 +0000204 INIT_RADIX_TREE(&pag->pag_ici_root, GFP_ATOMIC);
Dave Chinner74f75a02010-09-24 19:59:04 +1000205 spin_lock_init(&pag->pag_buf_lock);
206 pag->pag_buf_tree = RB_ROOT;
Christoph Hellwigfb3b5042010-05-28 19:03:10 +0000207
Dave Chinner1c1c6eb2010-01-11 11:47:44 +0000208 if (radix_tree_preload(GFP_NOFS))
Dave Chinner8b26c582010-01-11 11:47:48 +0000209 goto out_unwind;
Christoph Hellwigfb3b5042010-05-28 19:03:10 +0000210
Dave Chinner1c1c6eb2010-01-11 11:47:44 +0000211 spin_lock(&mp->m_perag_lock);
212 if (radix_tree_insert(&mp->m_perag_tree, index, pag)) {
213 BUG();
214 spin_unlock(&mp->m_perag_lock);
Dave Chinner8b26c582010-01-11 11:47:48 +0000215 radix_tree_preload_end();
216 error = -EEXIST;
217 goto out_unwind;
Dave Chinner1c1c6eb2010-01-11 11:47:44 +0000218 }
219 spin_unlock(&mp->m_perag_lock);
220 radix_tree_preload_end();
221 }
222
Christoph Hellwigfb3b5042010-05-28 19:03:10 +0000223 /*
224 * If we mount with the inode64 option, or no inode overflows
225 * the legacy 32-bit address space clear the inode32 option.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226 */
Christoph Hellwigfb3b5042010-05-28 19:03:10 +0000227 agino = XFS_OFFBNO_TO_AGINO(mp, sbp->sb_agblocks - 1, 0);
228 ino = XFS_AGINO_TO_INO(mp, agcount - 1, agino);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229
Christoph Hellwigfb3b5042010-05-28 19:03:10 +0000230 if ((mp->m_flags & XFS_MOUNT_SMALL_INUMS) && ino > XFS_MAXINUMBER_32)
231 mp->m_flags |= XFS_MOUNT_32BITINODES;
232 else
233 mp->m_flags &= ~XFS_MOUNT_32BITINODES;
234
Carlos Maiolino2d2194f2012-09-20 10:32:38 -0300235 if (mp->m_flags & XFS_MOUNT_32BITINODES)
Eric Sandeen9de67c32014-07-24 20:51:54 +1000236 index = xfs_set_inode32(mp, agcount);
Carlos Maiolino2d2194f2012-09-20 10:32:38 -0300237 else
Eric Sandeen9de67c32014-07-24 20:51:54 +1000238 index = xfs_set_inode64(mp, agcount);
Christoph Hellwigfb3b5042010-05-28 19:03:10 +0000239
Dave Chinner1c1c6eb2010-01-11 11:47:44 +0000240 if (maxagi)
241 *maxagi = index;
242 return 0;
Dave Chinner8b26c582010-01-11 11:47:48 +0000243
244out_unwind:
245 kmem_free(pag);
246 for (; index > first_initialised; index--) {
247 pag = radix_tree_delete(&mp->m_perag_tree, index);
248 kmem_free(pag);
249 }
250 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251}
252
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253/*
254 * xfs_readsb
255 *
256 * Does the initial read of the superblock.
257 */
258int
Dave Chinnerff550682013-08-12 20:49:41 +1000259xfs_readsb(
260 struct xfs_mount *mp,
261 int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262{
263 unsigned int sector_size;
Dave Chinner04a1e6c2013-04-03 16:11:31 +1100264 struct xfs_buf *bp;
265 struct xfs_sb *sbp = &mp->m_sb;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266 int error;
Dave Chinneraf34e092011-03-07 10:04:35 +1100267 int loud = !(flags & XFS_MFSI_QUIET);
Eric Sandeendaba5422014-02-19 15:39:16 +1100268 const struct xfs_buf_ops *buf_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269
270 ASSERT(mp->m_sb_bp == NULL);
271 ASSERT(mp->m_ddev_targp != NULL);
272
273 /*
Eric Sandeendaba5422014-02-19 15:39:16 +1100274 * For the initial read, we must guess at the sector
275 * size based on the block device. It's enough to
276 * get the sb_sectsize out of the superblock and
277 * then reread with the proper length.
278 * We don't verify it yet, because it may not be complete.
279 */
280 sector_size = xfs_getsize_buftarg(mp->m_ddev_targp);
281 buf_ops = NULL;
282
283 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 * Allocate a (locked) buffer to hold the superblock.
285 * This will be kept around at all times to optimize
286 * access to the superblock.
287 */
Dave Chinner26af6552010-09-22 10:47:20 +1000288reread:
Dave Chinnerba372672014-10-02 09:05:32 +1000289 error = xfs_buf_read_uncached(mp->m_ddev_targp, XFS_SB_DADDR,
290 BTOBB(sector_size), 0, &bp, buf_ops);
291 if (error) {
Dave Chinnereab4e632012-11-12 22:54:02 +1100292 if (loud)
Dave Chinnere721f502013-04-03 16:11:32 +1100293 xfs_warn(mp, "SB validate failed with error %d.", error);
Dave Chinnerac75a1f2014-03-07 16:19:14 +1100294 /* bad CRC means corrupted metadata */
Dave Chinner24513372014-06-25 14:58:08 +1000295 if (error == -EFSBADCRC)
296 error = -EFSCORRUPTED;
Dave Chinnerba372672014-10-02 09:05:32 +1000297 return error;
Dave Chinnereab4e632012-11-12 22:54:02 +1100298 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299
300 /*
301 * Initialize the mount structure from the superblock.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 */
Dave Chinner556b8882014-06-06 16:00:43 +1000303 xfs_sb_from_disk(sbp, XFS_BUF_TO_SBP(bp));
Dave Chinner556b8882014-06-06 16:00:43 +1000304
305 /*
306 * If we haven't validated the superblock, do so now before we try
307 * to check the sector size and reread the superblock appropriately.
308 */
309 if (sbp->sb_magicnum != XFS_SB_MAGIC) {
310 if (loud)
311 xfs_warn(mp, "Invalid superblock magic number");
Dave Chinner24513372014-06-25 14:58:08 +1000312 error = -EINVAL;
Dave Chinner556b8882014-06-06 16:00:43 +1000313 goto release_buf;
314 }
Dave Chinnerff550682013-08-12 20:49:41 +1000315
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316 /*
317 * We must be able to do sector-sized and sector-aligned IO.
318 */
Dave Chinner04a1e6c2013-04-03 16:11:31 +1100319 if (sector_size > sbp->sb_sectsize) {
Dave Chinneraf34e092011-03-07 10:04:35 +1100320 if (loud)
321 xfs_warn(mp, "device supports %u byte sectors (not %u)",
Dave Chinner04a1e6c2013-04-03 16:11:31 +1100322 sector_size, sbp->sb_sectsize);
Dave Chinner24513372014-06-25 14:58:08 +1000323 error = -ENOSYS;
Dave Chinner26af6552010-09-22 10:47:20 +1000324 goto release_buf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325 }
326
Eric Sandeendaba5422014-02-19 15:39:16 +1100327 if (buf_ops == NULL) {
Dave Chinner556b8882014-06-06 16:00:43 +1000328 /*
329 * Re-read the superblock so the buffer is correctly sized,
330 * and properly verified.
331 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332 xfs_buf_relse(bp);
Dave Chinner04a1e6c2013-04-03 16:11:31 +1100333 sector_size = sbp->sb_sectsize;
Eric Sandeendaba5422014-02-19 15:39:16 +1100334 buf_ops = loud ? &xfs_sb_buf_ops : &xfs_sb_quiet_buf_ops;
Dave Chinner26af6552010-09-22 10:47:20 +1000335 goto reread;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336 }
337
Dave Chinner5681ca42015-02-23 21:22:31 +1100338 xfs_reinit_percpu_counters(mp);
David Chinner8d280b92006-03-14 13:13:09 +1100339
Dave Chinner04a1e6c2013-04-03 16:11:31 +1100340 /* no need to be quiet anymore, so reset the buf ops */
341 bp->b_ops = &xfs_sb_buf_ops;
342
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343 mp->m_sb_bp = bp;
Dave Chinner26af6552010-09-22 10:47:20 +1000344 xfs_buf_unlock(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345 return 0;
346
Dave Chinner26af6552010-09-22 10:47:20 +1000347release_buf:
348 xfs_buf_relse(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 return error;
350}
351
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352/*
Eric Sandeen0771fb42007-10-12 11:03:40 +1000353 * Update alignment values based on mount options and sb values
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 */
Eric Sandeen0771fb42007-10-12 11:03:40 +1000355STATIC int
Christoph Hellwig7884bc82009-01-19 02:04:07 +0100356xfs_update_alignment(xfs_mount_t *mp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 xfs_sb_t *sbp = &(mp->m_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359
Christoph Hellwig42490232008-08-13 16:49:32 +1000360 if (mp->m_dalign) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361 /*
362 * If stripe unit and stripe width are not multiples
363 * of the fs blocksize turn off alignment.
364 */
365 if ((BBTOB(mp->m_dalign) & mp->m_blockmask) ||
366 (BBTOB(mp->m_swidth) & mp->m_blockmask)) {
Jie Liu39a45d82013-05-02 19:27:47 +0800367 xfs_warn(mp,
368 "alignment check failed: sunit/swidth vs. blocksize(%d)",
369 sbp->sb_blocksize);
Dave Chinner24513372014-06-25 14:58:08 +1000370 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 } else {
372 /*
373 * Convert the stripe unit and width to FSBs.
374 */
375 mp->m_dalign = XFS_BB_TO_FSBT(mp, mp->m_dalign);
376 if (mp->m_dalign && (sbp->sb_agblocks % mp->m_dalign)) {
Dave Chinner53487782011-03-07 10:05:35 +1100377 xfs_warn(mp,
Jie Liu39a45d82013-05-02 19:27:47 +0800378 "alignment check failed: sunit/swidth vs. agsize(%d)",
379 sbp->sb_agblocks);
Dave Chinner24513372014-06-25 14:58:08 +1000380 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381 } else if (mp->m_dalign) {
382 mp->m_swidth = XFS_BB_TO_FSBT(mp, mp->m_swidth);
383 } else {
Jie Liu39a45d82013-05-02 19:27:47 +0800384 xfs_warn(mp,
385 "alignment check failed: sunit(%d) less than bsize(%d)",
386 mp->m_dalign, sbp->sb_blocksize);
Dave Chinner24513372014-06-25 14:58:08 +1000387 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 }
389 }
390
391 /*
392 * Update superblock with new values
393 * and log changes
394 */
Eric Sandeen62118702008-03-06 13:44:28 +1100395 if (xfs_sb_version_hasdalign(sbp)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396 if (sbp->sb_unit != mp->m_dalign) {
397 sbp->sb_unit = mp->m_dalign;
Dave Chinner61e63ec2015-01-22 09:10:31 +1100398 mp->m_update_sb = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 }
400 if (sbp->sb_width != mp->m_swidth) {
401 sbp->sb_width = mp->m_swidth;
Dave Chinner61e63ec2015-01-22 09:10:31 +1100402 mp->m_update_sb = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403 }
Jie Liu34d7f602013-05-02 19:27:53 +0800404 } else {
405 xfs_warn(mp,
406 "cannot change alignment: superblock does not support data alignment");
Dave Chinner24513372014-06-25 14:58:08 +1000407 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408 }
409 } else if ((mp->m_flags & XFS_MOUNT_NOALIGN) != XFS_MOUNT_NOALIGN &&
Eric Sandeen62118702008-03-06 13:44:28 +1100410 xfs_sb_version_hasdalign(&mp->m_sb)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411 mp->m_dalign = sbp->sb_unit;
412 mp->m_swidth = sbp->sb_width;
413 }
414
Eric Sandeen0771fb42007-10-12 11:03:40 +1000415 return 0;
416}
417
418/*
419 * Set the maximum inode count for this filesystem
420 */
421STATIC void
422xfs_set_maxicount(xfs_mount_t *mp)
423{
424 xfs_sb_t *sbp = &(mp->m_sb);
425 __uint64_t icount;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426
427 if (sbp->sb_imax_pct) {
Eric Sandeen0771fb42007-10-12 11:03:40 +1000428 /*
429 * Make sure the maximum inode count is a multiple
430 * of the units we allocate inodes in.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 icount = sbp->sb_dblocks * sbp->sb_imax_pct;
433 do_div(icount, 100);
434 do_div(icount, mp->m_ialloc_blks);
435 mp->m_maxicount = (icount * mp->m_ialloc_blks) <<
436 sbp->sb_inopblog;
Eric Sandeen0771fb42007-10-12 11:03:40 +1000437 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438 mp->m_maxicount = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439 }
Eric Sandeen0771fb42007-10-12 11:03:40 +1000440}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441
Eric Sandeen0771fb42007-10-12 11:03:40 +1000442/*
443 * Set the default minimum read and write sizes unless
444 * already specified in a mount option.
445 * We use smaller I/O sizes when the file system
446 * is being used for NFS service (wsync mount option).
447 */
448STATIC void
449xfs_set_rw_sizes(xfs_mount_t *mp)
450{
451 xfs_sb_t *sbp = &(mp->m_sb);
452 int readio_log, writeio_log;
453
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454 if (!(mp->m_flags & XFS_MOUNT_DFLT_IOSIZE)) {
455 if (mp->m_flags & XFS_MOUNT_WSYNC) {
456 readio_log = XFS_WSYNC_READIO_LOG;
457 writeio_log = XFS_WSYNC_WRITEIO_LOG;
458 } else {
459 readio_log = XFS_READIO_LOG_LARGE;
460 writeio_log = XFS_WRITEIO_LOG_LARGE;
461 }
462 } else {
463 readio_log = mp->m_readio_log;
464 writeio_log = mp->m_writeio_log;
465 }
466
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467 if (sbp->sb_blocklog > readio_log) {
468 mp->m_readio_log = sbp->sb_blocklog;
469 } else {
470 mp->m_readio_log = readio_log;
471 }
472 mp->m_readio_blocks = 1 << (mp->m_readio_log - sbp->sb_blocklog);
473 if (sbp->sb_blocklog > writeio_log) {
474 mp->m_writeio_log = sbp->sb_blocklog;
475 } else {
476 mp->m_writeio_log = writeio_log;
477 }
478 mp->m_writeio_blocks = 1 << (mp->m_writeio_log - sbp->sb_blocklog);
Eric Sandeen0771fb42007-10-12 11:03:40 +1000479}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480
Eric Sandeen0771fb42007-10-12 11:03:40 +1000481/*
Dave Chinner055388a2011-01-04 11:35:03 +1100482 * precalculate the low space thresholds for dynamic speculative preallocation.
483 */
484void
485xfs_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/*
Eric Sandeen0771fb42007-10-12 11:03:40 +1000500 * Set whether we're using inode alignment.
501 */
502STATIC void
503xfs_set_inoalignment(xfs_mount_t *mp)
504{
Eric Sandeen62118702008-03-06 13:44:28 +1100505 if (xfs_sb_version_hasalign(&mp->m_sb) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506 mp->m_sb.sb_inoalignmt >=
507 XFS_B_TO_FSBT(mp, mp->m_inode_cluster_size))
508 mp->m_inoalign_mask = mp->m_sb.sb_inoalignmt - 1;
509 else
510 mp->m_inoalign_mask = 0;
511 /*
512 * If we are using stripe alignment, check whether
513 * the stripe unit is a multiple of the inode alignment
514 */
515 if (mp->m_dalign && mp->m_inoalign_mask &&
516 !(mp->m_dalign & mp->m_inoalign_mask))
517 mp->m_sinoalign = mp->m_dalign;
518 else
519 mp->m_sinoalign = 0;
Eric Sandeen0771fb42007-10-12 11:03:40 +1000520}
521
522/*
Zhi Yong Wu0471f622013-08-07 10:10:58 +0000523 * Check that the data (and log if separate) is an ok size.
Eric Sandeen0771fb42007-10-12 11:03:40 +1000524 */
525STATIC int
Dave Chinnerba372672014-10-02 09:05:32 +1000526xfs_check_sizes(
527 struct xfs_mount *mp)
Eric Sandeen0771fb42007-10-12 11:03:40 +1000528{
Dave Chinnerba372672014-10-02 09:05:32 +1000529 struct xfs_buf *bp;
Eric Sandeen0771fb42007-10-12 11:03:40 +1000530 xfs_daddr_t d;
Dave Chinnerba372672014-10-02 09:05:32 +1000531 int error;
Eric Sandeen0771fb42007-10-12 11:03:40 +1000532
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533 d = (xfs_daddr_t)XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks);
534 if (XFS_BB_TO_FSB(mp, d) != mp->m_sb.sb_dblocks) {
Dave Chinner0b932cc2011-03-07 10:08:35 +1100535 xfs_warn(mp, "filesystem size mismatch detected");
Dave Chinner24513372014-06-25 14:58:08 +1000536 return -EFBIG;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537 }
Dave Chinnerba372672014-10-02 09:05:32 +1000538 error = xfs_buf_read_uncached(mp->m_ddev_targp,
Dave Chinner1922c942010-09-22 10:47:20 +1000539 d - XFS_FSS_TO_BB(mp, 1),
Dave Chinnerba372672014-10-02 09:05:32 +1000540 XFS_FSS_TO_BB(mp, 1), 0, &bp, NULL);
541 if (error) {
Dave Chinner0b932cc2011-03-07 10:08:35 +1100542 xfs_warn(mp, "last sector read failed");
Dave Chinnerba372672014-10-02 09:05:32 +1000543 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544 }
Dave Chinner1922c942010-09-22 10:47:20 +1000545 xfs_buf_relse(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546
Dave Chinnerba372672014-10-02 09:05:32 +1000547 if (mp->m_logdev_targp == mp->m_ddev_targp)
548 return 0;
549
550 d = (xfs_daddr_t)XFS_FSB_TO_BB(mp, mp->m_sb.sb_logblocks);
551 if (XFS_BB_TO_FSB(mp, d) != mp->m_sb.sb_logblocks) {
552 xfs_warn(mp, "log size mismatch detected");
553 return -EFBIG;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554 }
Dave Chinnerba372672014-10-02 09:05:32 +1000555 error = xfs_buf_read_uncached(mp->m_logdev_targp,
556 d - XFS_FSB_TO_BB(mp, 1),
557 XFS_FSB_TO_BB(mp, 1), 0, &bp, NULL);
558 if (error) {
559 xfs_warn(mp, "log device read failed");
560 return error;
561 }
562 xfs_buf_relse(bp);
Eric Sandeen0771fb42007-10-12 11:03:40 +1000563 return 0;
564}
565
566/*
Christoph Hellwig7d095252009-06-08 15:33:32 +0200567 * Clear the quotaflags in memory and in the superblock.
568 */
569int
570xfs_mount_reset_sbqflags(
571 struct xfs_mount *mp)
572{
Christoph Hellwig7d095252009-06-08 15:33:32 +0200573 mp->m_qflags = 0;
574
Dave Chinner61e63ec2015-01-22 09:10:31 +1100575 /* It is OK to look at sb_qflags in the mount path without m_sb_lock. */
Christoph Hellwig7d095252009-06-08 15:33:32 +0200576 if (mp->m_sb.sb_qflags == 0)
577 return 0;
578 spin_lock(&mp->m_sb_lock);
579 mp->m_sb.sb_qflags = 0;
580 spin_unlock(&mp->m_sb_lock);
581
Dave Chinner61e63ec2015-01-22 09:10:31 +1100582 if (!xfs_fs_writable(mp, SB_FREEZE_WRITE))
Christoph Hellwig7d095252009-06-08 15:33:32 +0200583 return 0;
584
Dave Chinner61e63ec2015-01-22 09:10:31 +1100585 return xfs_sync_sb(mp, false);
Christoph Hellwig7d095252009-06-08 15:33:32 +0200586}
587
Eric Sandeend5db0f92010-02-05 22:59:53 +0000588__uint64_t
589xfs_default_resblks(xfs_mount_t *mp)
590{
591 __uint64_t resblks;
592
593 /*
Dave Chinner8babd8a2010-03-04 01:46:25 +0000594 * We default to 5% or 8192 fsbs of space reserved, whichever is
595 * smaller. This is intended to cover concurrent allocation
596 * transactions when we initially hit enospc. These each require a 4
597 * block reservation. Hence by default we cover roughly 2000 concurrent
598 * allocation reservations.
Eric Sandeend5db0f92010-02-05 22:59:53 +0000599 */
600 resblks = mp->m_sb.sb_dblocks;
601 do_div(resblks, 20);
Dave Chinner8babd8a2010-03-04 01:46:25 +0000602 resblks = min_t(__uint64_t, resblks, 8192);
Eric Sandeend5db0f92010-02-05 22:59:53 +0000603 return resblks;
604}
605
Christoph Hellwig7d095252009-06-08 15:33:32 +0200606/*
Eric Sandeen0771fb42007-10-12 11:03:40 +1000607 * This function does the following on an initial mount of a file system:
608 * - reads the superblock from disk and init the mount struct
609 * - if we're a 32-bit kernel, do a size check on the superblock
610 * so we don't mount terabyte filesystems
611 * - init mount struct realtime fields
612 * - allocate inode hash table for fs
613 * - init directory manager
614 * - perform recovery and init the log manager
615 */
616int
617xfs_mountfs(
Brian Fosterf0b2efa2015-08-19 09:58:36 +1000618 struct xfs_mount *mp)
Eric Sandeen0771fb42007-10-12 11:03:40 +1000619{
Brian Fosterf0b2efa2015-08-19 09:58:36 +1000620 struct xfs_sb *sbp = &(mp->m_sb);
621 struct xfs_inode *rip;
622 __uint64_t resblks;
623 uint quotamount = 0;
624 uint quotaflags = 0;
625 int error = 0;
Eric Sandeen0771fb42007-10-12 11:03:40 +1000626
Dave Chinnerff550682013-08-12 20:49:41 +1000627 xfs_sb_mount_common(mp, sbp);
Eric Sandeen0771fb42007-10-12 11:03:40 +1000628
629 /*
Dave Chinner074e4272015-01-22 09:10:33 +1100630 * Check for a mismatched features2 values. Older kernels read & wrote
631 * into the wrong sb offset for sb_features2 on some platforms due to
632 * xfs_sb_t not being 64bit size aligned when sb_features2 was added,
633 * which made older superblock reading/writing routines swap it as a
634 * 64-bit value.
David Chinneree1c0902008-03-06 13:45:50 +1100635 *
Eric Sandeene6957ea2008-04-10 12:19:34 +1000636 * For backwards compatibility, we make both slots equal.
637 *
Dave Chinner074e4272015-01-22 09:10:33 +1100638 * If we detect a mismatched field, we OR the set bits into the existing
639 * features2 field in case it has already been modified; we don't want
640 * to lose any features. We then update the bad location with the ORed
641 * value so that older kernels will see any features2 flags. The
642 * superblock writeback code ensures the new sb_features2 is copied to
643 * sb_bad_features2 before it is logged or written to disk.
David Chinneree1c0902008-03-06 13:45:50 +1100644 */
Eric Sandeene6957ea2008-04-10 12:19:34 +1000645 if (xfs_sb_has_mismatched_features2(sbp)) {
Dave Chinner0b932cc2011-03-07 10:08:35 +1100646 xfs_warn(mp, "correcting sb_features alignment problem");
David Chinneree1c0902008-03-06 13:45:50 +1100647 sbp->sb_features2 |= sbp->sb_bad_features2;
Dave Chinner61e63ec2015-01-22 09:10:31 +1100648 mp->m_update_sb = true;
Eric Sandeene6957ea2008-04-10 12:19:34 +1000649
650 /*
651 * Re-check for ATTR2 in case it was found in bad_features2
652 * slot.
653 */
Tim Shimmin7c12f292008-04-30 18:15:28 +1000654 if (xfs_sb_version_hasattr2(&mp->m_sb) &&
655 !(mp->m_flags & XFS_MOUNT_NOATTR2))
Eric Sandeene6957ea2008-04-10 12:19:34 +1000656 mp->m_flags |= XFS_MOUNT_ATTR2;
Tim Shimmin7c12f292008-04-30 18:15:28 +1000657 }
Eric Sandeene6957ea2008-04-10 12:19:34 +1000658
Tim Shimmin7c12f292008-04-30 18:15:28 +1000659 if (xfs_sb_version_hasattr2(&mp->m_sb) &&
660 (mp->m_flags & XFS_MOUNT_NOATTR2)) {
661 xfs_sb_version_removeattr2(&mp->m_sb);
Dave Chinner61e63ec2015-01-22 09:10:31 +1100662 mp->m_update_sb = true;
Tim Shimmin7c12f292008-04-30 18:15:28 +1000663
664 /* update sb_versionnum for the clearing of the morebits */
665 if (!sbp->sb_features2)
Dave Chinner61e63ec2015-01-22 09:10:31 +1100666 mp->m_update_sb = true;
David Chinneree1c0902008-03-06 13:45:50 +1100667 }
668
Dave Chinner263997a2014-05-20 07:46:40 +1000669 /* always use v2 inodes by default now */
670 if (!(mp->m_sb.sb_versionnum & XFS_SB_VERSION_NLINKBIT)) {
671 mp->m_sb.sb_versionnum |= XFS_SB_VERSION_NLINKBIT;
Dave Chinner61e63ec2015-01-22 09:10:31 +1100672 mp->m_update_sb = true;
Dave Chinner263997a2014-05-20 07:46:40 +1000673 }
674
David Chinneree1c0902008-03-06 13:45:50 +1100675 /*
Eric Sandeen0771fb42007-10-12 11:03:40 +1000676 * Check if sb_agblocks is aligned at stripe boundary
677 * If sb_agblocks is NOT aligned turn off m_dalign since
678 * allocator alignment is within an ag, therefore ag has
679 * to be aligned at stripe boundary.
680 */
Christoph Hellwig7884bc82009-01-19 02:04:07 +0100681 error = xfs_update_alignment(mp);
Eric Sandeen0771fb42007-10-12 11:03:40 +1000682 if (error)
Christoph Hellwigf9057e32009-02-04 09:31:52 +0100683 goto out;
Eric Sandeen0771fb42007-10-12 11:03:40 +1000684
685 xfs_alloc_compute_maxlevels(mp);
686 xfs_bmap_compute_maxlevels(mp, XFS_DATA_FORK);
687 xfs_bmap_compute_maxlevels(mp, XFS_ATTR_FORK);
688 xfs_ialloc_compute_maxlevels(mp);
689
690 xfs_set_maxicount(mp);
691
Brian Fostera31b1d32014-07-15 08:07:01 +1000692 error = xfs_sysfs_init(&mp->m_kobj, &xfs_mp_ktype, NULL, mp->m_fsname);
Christoph Hellwig27174202009-03-30 10:21:31 +0200693 if (error)
694 goto out;
Eric Sandeen0771fb42007-10-12 11:03:40 +1000695
Brian Fostera31b1d32014-07-15 08:07:01 +1000696 error = xfs_uuid_mount(mp);
697 if (error)
698 goto out_remove_sysfs;
699
Eric Sandeen0771fb42007-10-12 11:03:40 +1000700 /*
701 * Set the minimum read and write sizes
702 */
703 xfs_set_rw_sizes(mp);
704
Dave Chinner055388a2011-01-04 11:35:03 +1100705 /* set the low space thresholds for dynamic preallocation */
706 xfs_set_low_space_thresholds(mp);
707
Eric Sandeen0771fb42007-10-12 11:03:40 +1000708 /*
709 * Set the inode cluster size.
710 * This may still be overridden by the file system
711 * block size if it is larger than the chosen cluster size.
Dave Chinner8f805872013-11-01 15:27:20 +1100712 *
713 * For v5 filesystems, scale the cluster size with the inode size to
714 * keep a constant ratio of inode per cluster buffer, but only if mkfs
715 * has set the inode alignment value appropriately for larger cluster
716 * sizes.
Eric Sandeen0771fb42007-10-12 11:03:40 +1000717 */
718 mp->m_inode_cluster_size = XFS_INODE_BIG_CLUSTER_SIZE;
Dave Chinner8f805872013-11-01 15:27:20 +1100719 if (xfs_sb_version_hascrc(&mp->m_sb)) {
720 int new_size = mp->m_inode_cluster_size;
721
722 new_size *= mp->m_sb.sb_inodesize / XFS_DINODE_MIN_SIZE;
723 if (mp->m_sb.sb_inoalignmt >= XFS_B_TO_FSBT(mp, new_size))
724 mp->m_inode_cluster_size = new_size;
Dave Chinner8f805872013-11-01 15:27:20 +1100725 }
Eric Sandeen0771fb42007-10-12 11:03:40 +1000726
727 /*
Brian Fostere5376fc2015-05-29 08:57:27 +1000728 * If enabled, sparse inode chunk alignment is expected to match the
729 * cluster size. Full inode chunk alignment must match the chunk size,
730 * but that is checked on sb read verification...
731 */
732 if (xfs_sb_version_hassparseinodes(&mp->m_sb) &&
733 mp->m_sb.sb_spino_align !=
734 XFS_B_TO_FSBT(mp, mp->m_inode_cluster_size)) {
735 xfs_warn(mp,
736 "Sparse inode block alignment (%u) must match cluster size (%llu).",
737 mp->m_sb.sb_spino_align,
738 XFS_B_TO_FSBT(mp, mp->m_inode_cluster_size));
739 error = -EINVAL;
740 goto out_remove_uuid;
741 }
742
743 /*
Eric Sandeen0771fb42007-10-12 11:03:40 +1000744 * Set inode alignment fields
745 */
746 xfs_set_inoalignment(mp);
747
748 /*
Zhi Yong Wuc2bfbc92013-08-12 03:15:03 +0000749 * Check that the data (and log if separate) is an ok size.
Eric Sandeen0771fb42007-10-12 11:03:40 +1000750 */
Christoph Hellwig42490232008-08-13 16:49:32 +1000751 error = xfs_check_sizes(mp);
Eric Sandeen0771fb42007-10-12 11:03:40 +1000752 if (error)
Christoph Hellwigf9057e32009-02-04 09:31:52 +0100753 goto out_remove_uuid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754
755 /*
756 * Initialize realtime fields in the mount structure
757 */
Eric Sandeen0771fb42007-10-12 11:03:40 +1000758 error = xfs_rtmount_init(mp);
759 if (error) {
Dave Chinner0b932cc2011-03-07 10:08:35 +1100760 xfs_warn(mp, "RT mount failed");
Christoph Hellwigf9057e32009-02-04 09:31:52 +0100761 goto out_remove_uuid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762 }
763
764 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765 * Copies the low order bits of the timestamp and the randomly
766 * set "sequence" number out of a UUID.
767 */
768 uuid_getnodeuniq(&sbp->sb_uuid, mp->m_fixedfsid);
769
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 mp->m_dmevmask = 0; /* not persistent; set after each mount */
771
Dave Chinner0650b552014-06-06 15:01:58 +1000772 error = xfs_da_mount(mp);
773 if (error) {
774 xfs_warn(mp, "Failed dir/attr init: %d", error);
775 goto out_remove_uuid;
776 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777
778 /*
779 * Initialize the precomputed transaction reservations values.
780 */
781 xfs_trans_init(mp);
782
783 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784 * Allocate and initialize the per-ag data.
785 */
Dave Chinner1c1c6eb2010-01-11 11:47:44 +0000786 spin_lock_init(&mp->m_perag_lock);
Dave Chinner9b98b6f2010-05-27 01:58:13 +0000787 INIT_RADIX_TREE(&mp->m_perag_tree, GFP_ATOMIC);
Dave Chinner1c1c6eb2010-01-11 11:47:44 +0000788 error = xfs_initialize_perag(mp, sbp->sb_agcount, &mp->m_maxagi);
789 if (error) {
Dave Chinner0b932cc2011-03-07 10:08:35 +1100790 xfs_warn(mp, "Failed per-ag init: %d", error);
Dave Chinner0650b552014-06-06 15:01:58 +1000791 goto out_free_dir;
Dave Chinner1c1c6eb2010-01-11 11:47:44 +0000792 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793
Christoph Hellwigf9057e32009-02-04 09:31:52 +0100794 if (!sbp->sb_logblocks) {
Dave Chinner0b932cc2011-03-07 10:08:35 +1100795 xfs_warn(mp, "no log defined");
Christoph Hellwigf9057e32009-02-04 09:31:52 +0100796 XFS_ERROR_REPORT("xfs_mountfs", XFS_ERRLEVEL_LOW, mp);
Dave Chinner24513372014-06-25 14:58:08 +1000797 error = -EFSCORRUPTED;
Christoph Hellwigf9057e32009-02-04 09:31:52 +0100798 goto out_free_perag;
799 }
800
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801 /*
Brian Fosterf0b2efa2015-08-19 09:58:36 +1000802 * Log's mount-time initialization. The first part of recovery can place
803 * some items on the AIL, to be handled when recovery is finished or
804 * cancelled.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805 */
Christoph Hellwigf9057e32009-02-04 09:31:52 +0100806 error = xfs_log_mount(mp, mp->m_logdev_targp,
807 XFS_FSB_TO_DADDR(mp, sbp->sb_logstart),
808 XFS_FSB_TO_BB(mp, sbp->sb_logblocks));
809 if (error) {
Dave Chinner0b932cc2011-03-07 10:08:35 +1100810 xfs_warn(mp, "log mount failed");
Dave Chinnerd4f35122012-04-23 15:59:06 +1000811 goto out_fail_wait;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812 }
813
814 /*
David Chinner92821e22007-05-24 15:26:31 +1000815 * Now the log is mounted, we know if it was an unclean shutdown or
816 * not. If it was, with the first phase of recovery has completed, we
817 * have consistent AG blocks on disk. We have not recovered EFIs yet,
818 * but they are recovered transactionally in the second recovery phase
819 * later.
820 *
821 * Hence we can safely re-initialise incore superblock counters from
822 * the per-ag data. These may not be correct if the filesystem was not
823 * cleanly unmounted, so we need to wait for recovery to finish before
824 * doing this.
825 *
826 * If the filesystem was cleanly unmounted, then we can trust the
827 * values in the superblock to be correct and we don't need to do
828 * anything here.
829 *
830 * If we are currently making the filesystem, the initialisation will
831 * fail as the perag data is in an undefined state.
832 */
David Chinner92821e22007-05-24 15:26:31 +1000833 if (xfs_sb_version_haslazysbcount(&mp->m_sb) &&
834 !XFS_LAST_UNMOUNT_WAS_CLEAN(mp) &&
835 !mp->m_sb.sb_inprogress) {
836 error = xfs_initialize_perag_data(mp, sbp->sb_agcount);
Christoph Hellwigf9057e32009-02-04 09:31:52 +0100837 if (error)
kbuild test robot6eee8972014-08-04 13:49:40 +1000838 goto out_log_dealloc;
David Chinner92821e22007-05-24 15:26:31 +1000839 }
Christoph Hellwigf9057e32009-02-04 09:31:52 +0100840
David Chinner92821e22007-05-24 15:26:31 +1000841 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842 * Get and sanity-check the root inode.
843 * Save the pointer to it in the mount structure.
844 */
Dave Chinner7b6259e2010-06-24 11:35:17 +1000845 error = xfs_iget(mp, NULL, sbp->sb_rootino, 0, XFS_ILOCK_EXCL, &rip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846 if (error) {
Dave Chinner0b932cc2011-03-07 10:08:35 +1100847 xfs_warn(mp, "failed to read root inode");
Christoph Hellwigf9057e32009-02-04 09:31:52 +0100848 goto out_log_dealloc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700849 }
850
851 ASSERT(rip != NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852
Al Viroabbede12011-07-26 02:31:30 -0400853 if (unlikely(!S_ISDIR(rip->i_d.di_mode))) {
Dave Chinner0b932cc2011-03-07 10:08:35 +1100854 xfs_warn(mp, "corrupted root inode %llu: not a directory",
Nathan Scottb6574522006-06-09 15:29:40 +1000855 (unsigned long long)rip->i_ino);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856 xfs_iunlock(rip, XFS_ILOCK_EXCL);
857 XFS_ERROR_REPORT("xfs_mountfs_int(2)", XFS_ERRLEVEL_LOW,
858 mp);
Dave Chinner24513372014-06-25 14:58:08 +1000859 error = -EFSCORRUPTED;
Christoph Hellwigf9057e32009-02-04 09:31:52 +0100860 goto out_rele_rip;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861 }
862 mp->m_rootip = rip; /* save it */
863
864 xfs_iunlock(rip, XFS_ILOCK_EXCL);
865
866 /*
867 * Initialize realtime inode pointers in the mount structure
868 */
Eric Sandeen0771fb42007-10-12 11:03:40 +1000869 error = xfs_rtmount_inodes(mp);
870 if (error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871 /*
872 * Free up the root inode.
873 */
Dave Chinner0b932cc2011-03-07 10:08:35 +1100874 xfs_warn(mp, "failed to read RT inodes");
Christoph Hellwigf9057e32009-02-04 09:31:52 +0100875 goto out_rele_rip;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876 }
877
878 /*
Christoph Hellwig7884bc82009-01-19 02:04:07 +0100879 * If this is a read-only mount defer the superblock updates until
880 * the next remount into writeable mode. Otherwise we would never
881 * perform the update e.g. for the root filesystem.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882 */
Dave Chinner61e63ec2015-01-22 09:10:31 +1100883 if (mp->m_update_sb && !(mp->m_flags & XFS_MOUNT_RDONLY)) {
884 error = xfs_sync_sb(mp, false);
David Chinnere5720ee2008-04-10 12:21:18 +1000885 if (error) {
Dave Chinner0b932cc2011-03-07 10:08:35 +1100886 xfs_warn(mp, "failed to write sb changes");
Christoph Hellwigb93b6e42009-02-04 09:33:58 +0100887 goto out_rtunmount;
David Chinnere5720ee2008-04-10 12:21:18 +1000888 }
889 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700890
891 /*
892 * Initialise the XFS quota management subsystem for this mount
893 */
Christoph Hellwig7d095252009-06-08 15:33:32 +0200894 if (XFS_IS_QUOTA_RUNNING(mp)) {
895 error = xfs_qm_newmount(mp, &quotamount, &quotaflags);
896 if (error)
897 goto out_rtunmount;
898 } else {
899 ASSERT(!XFS_IS_QUOTA_ON(mp));
900
901 /*
902 * If a file system had quotas running earlier, but decided to
903 * mount without -o uquota/pquota/gquota options, revoke the
904 * quotachecked license.
905 */
906 if (mp->m_sb.sb_qflags & XFS_ALL_QUOTA_ACCT) {
Dave Chinner0b932cc2011-03-07 10:08:35 +1100907 xfs_notice(mp, "resetting quota flags");
Christoph Hellwig7d095252009-06-08 15:33:32 +0200908 error = xfs_mount_reset_sbqflags(mp);
909 if (error)
Brian Fostera70a4fa2014-07-15 07:41:25 +1000910 goto out_rtunmount;
Christoph Hellwig7d095252009-06-08 15:33:32 +0200911 }
912 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913
914 /*
Brian Fosterf0b2efa2015-08-19 09:58:36 +1000915 * Finish recovering the file system. This part needed to be delayed
916 * until after the root and real-time bitmap inodes were consistently
917 * read in.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918 */
Christoph Hellwig42490232008-08-13 16:49:32 +1000919 error = xfs_log_mount_finish(mp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920 if (error) {
Dave Chinner0b932cc2011-03-07 10:08:35 +1100921 xfs_warn(mp, "log mount finish failed");
Christoph Hellwigb93b6e42009-02-04 09:33:58 +0100922 goto out_rtunmount;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923 }
924
925 /*
926 * Complete the quota initialisation, post-log-replay component.
927 */
Christoph Hellwig7d095252009-06-08 15:33:32 +0200928 if (quotamount) {
929 ASSERT(mp->m_qflags == 0);
930 mp->m_qflags = quotaflags;
931
932 xfs_qm_mount_quotas(mp);
933 }
934
David Chinner84e1e992007-06-18 16:50:27 +1000935 /*
936 * Now we are mounted, reserve a small amount of unused space for
937 * privileged transactions. This is needed so that transaction
938 * space required for critical operations can dip into this pool
939 * when at ENOSPC. This is needed for operations like create with
940 * attr, unwritten extent conversion at ENOSPC, etc. Data allocations
941 * are not allowed to use this reserved space.
Dave Chinner8babd8a2010-03-04 01:46:25 +0000942 *
943 * This may drive us straight to ENOSPC on mount, but that implies
944 * we were already there on the last unmount. Warn if this occurs.
David Chinner84e1e992007-06-18 16:50:27 +1000945 */
Eric Sandeend5db0f92010-02-05 22:59:53 +0000946 if (!(mp->m_flags & XFS_MOUNT_RDONLY)) {
947 resblks = xfs_default_resblks(mp);
948 error = xfs_reserve_blocks(mp, &resblks, NULL);
949 if (error)
Dave Chinner0b932cc2011-03-07 10:08:35 +1100950 xfs_warn(mp,
951 "Unable to allocate reserve blocks. Continuing without reserve pool.");
Eric Sandeend5db0f92010-02-05 22:59:53 +0000952 }
David Chinner84e1e992007-06-18 16:50:27 +1000953
Linus Torvalds1da177e2005-04-16 15:20:36 -0700954 return 0;
955
Christoph Hellwigb93b6e42009-02-04 09:33:58 +0100956 out_rtunmount:
957 xfs_rtunmount_inodes(mp);
Christoph Hellwigf9057e32009-02-04 09:31:52 +0100958 out_rele_rip:
Christoph Hellwig43355092008-03-27 18:01:08 +1100959 IRELE(rip);
Brian Foster0ae120f2015-08-19 10:00:28 +1000960 cancel_delayed_work_sync(&mp->m_reclaim_work);
961 xfs_reclaim_inodes(mp, SYNC_WAIT);
Christoph Hellwigf9057e32009-02-04 09:31:52 +0100962 out_log_dealloc:
Brian Fosterf0b2efa2015-08-19 09:58:36 +1000963 xfs_log_mount_cancel(mp);
Dave Chinnerd4f35122012-04-23 15:59:06 +1000964 out_fail_wait:
965 if (mp->m_logdev_targp && mp->m_logdev_targp != mp->m_ddev_targp)
966 xfs_wait_buftarg(mp->m_logdev_targp);
967 xfs_wait_buftarg(mp->m_ddev_targp);
Christoph Hellwigf9057e32009-02-04 09:31:52 +0100968 out_free_perag:
Christoph Hellwigff4f0382008-08-13 16:50:47 +1000969 xfs_free_perag(mp);
Dave Chinner0650b552014-06-06 15:01:58 +1000970 out_free_dir:
971 xfs_da_unmount(mp);
Christoph Hellwigf9057e32009-02-04 09:31:52 +0100972 out_remove_uuid:
Christoph Hellwig27174202009-03-30 10:21:31 +0200973 xfs_uuid_unmount(mp);
Brian Fostera31b1d32014-07-15 08:07:01 +1000974 out_remove_sysfs:
975 xfs_sysfs_del(&mp->m_kobj);
Christoph Hellwigf9057e32009-02-04 09:31:52 +0100976 out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700977 return error;
978}
979
980/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981 * This flushes out the inodes,dquots and the superblock, unmounts the
982 * log and makes sure that incore structures are freed.
983 */
Christoph Hellwig41b5c2e2008-08-13 16:49:57 +1000984void
985xfs_unmountfs(
986 struct xfs_mount *mp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700987{
Christoph Hellwig41b5c2e2008-08-13 16:49:57 +1000988 __uint64_t resblks;
989 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990
Brian Foster579b62f2012-11-06 09:50:47 -0500991 cancel_delayed_work_sync(&mp->m_eofblocks_work);
992
Christoph Hellwig7d095252009-06-08 15:33:32 +0200993 xfs_qm_unmount_quotas(mp);
Christoph Hellwigb93b6e42009-02-04 09:33:58 +0100994 xfs_rtunmount_inodes(mp);
Christoph Hellwig77508ec2008-08-13 16:49:04 +1000995 IRELE(mp->m_rootip);
996
David Chinner641c56f2007-06-18 16:50:17 +1000997 /*
998 * We can potentially deadlock here if we have an inode cluster
Malcolm Parsons9da096f2009-03-29 09:55:42 +0200999 * that has been freed has its buffer still pinned in memory because
David Chinner641c56f2007-06-18 16:50:17 +10001000 * the transaction is still sitting in a iclog. The stale inodes
1001 * on that buffer will have their flush locks held until the
1002 * transaction hits the disk and the callbacks run. the inode
1003 * flush takes the flush lock unconditionally and with nothing to
1004 * push out the iclog we will never get that unlocked. hence we
1005 * need to force the log first.
1006 */
Christoph Hellwiga14a3482010-01-19 09:56:46 +00001007 xfs_log_force(mp, XFS_LOG_SYNC);
Dave Chinnerc8543632010-02-06 12:39:36 +11001008
1009 /*
Christoph Hellwig211e4d42012-04-23 15:58:34 +10001010 * Flush all pending changes from the AIL.
Dave Chinnerc8543632010-02-06 12:39:36 +11001011 */
Christoph Hellwig211e4d42012-04-23 15:58:34 +10001012 xfs_ail_push_all_sync(mp->m_ail);
1013
1014 /*
1015 * And reclaim all inodes. At this point there should be no dirty
Dave Chinner7e185302012-10-08 21:56:00 +11001016 * inodes and none should be pinned or locked, but use synchronous
1017 * reclaim just to be sure. We can stop background inode reclaim
1018 * here as well if it is still running.
Christoph Hellwig211e4d42012-04-23 15:58:34 +10001019 */
Dave Chinner7e185302012-10-08 21:56:00 +11001020 cancel_delayed_work_sync(&mp->m_reclaim_work);
Dave Chinnerc8543632010-02-06 12:39:36 +11001021 xfs_reclaim_inodes(mp, SYNC_WAIT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022
Christoph Hellwig7d095252009-06-08 15:33:32 +02001023 xfs_qm_unmount(mp);
Lachlan McIlroya357a122008-10-30 16:53:25 +11001024
Linus Torvalds1da177e2005-04-16 15:20:36 -07001025 /*
David Chinner84e1e992007-06-18 16:50:27 +10001026 * Unreserve any blocks we have so that when we unmount we don't account
1027 * the reserved free space as used. This is really only necessary for
1028 * lazy superblock counting because it trusts the incore superblock
Malcolm Parsons9da096f2009-03-29 09:55:42 +02001029 * counters to be absolutely correct on clean unmount.
David Chinner84e1e992007-06-18 16:50:27 +10001030 *
1031 * We don't bother correcting this elsewhere for lazy superblock
1032 * counting because on mount of an unclean filesystem we reconstruct the
1033 * correct counter value and this is irrelevant.
1034 *
1035 * For non-lazy counter filesystems, this doesn't matter at all because
1036 * we only every apply deltas to the superblock and hence the incore
1037 * value does not matter....
1038 */
1039 resblks = 0;
David Chinner714082b2008-04-10 12:20:03 +10001040 error = xfs_reserve_blocks(mp, &resblks, NULL);
1041 if (error)
Dave Chinner0b932cc2011-03-07 10:08:35 +11001042 xfs_warn(mp, "Unable to free reserved block pool. "
David Chinner714082b2008-04-10 12:20:03 +10001043 "Freespace may not be correct on next mount.");
1044
Chandra Seetharamanadab0f62011-06-29 22:10:14 +00001045 error = xfs_log_sbcount(mp);
David Chinnere5720ee2008-04-10 12:21:18 +10001046 if (error)
Dave Chinner0b932cc2011-03-07 10:08:35 +11001047 xfs_warn(mp, "Unable to update superblock counters. "
David Chinnere5720ee2008-04-10 12:21:18 +10001048 "Freespace may not be correct on next mount.");
Christoph Hellwig87c7bec2011-09-14 14:08:26 +00001049
Christoph Hellwig21b699c2009-03-16 08:19:29 +01001050 xfs_log_unmount(mp);
Dave Chinner0650b552014-06-06 15:01:58 +10001051 xfs_da_unmount(mp);
Christoph Hellwig27174202009-03-30 10:21:31 +02001052 xfs_uuid_unmount(mp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053
Christoph Hellwig1550d0b2008-08-13 16:17:37 +10001054#if defined(DEBUG)
Christoph Hellwig0ce4cfd2007-08-30 17:20:53 +10001055 xfs_errortag_clearall(mp, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001056#endif
Christoph Hellwigff4f0382008-08-13 16:50:47 +10001057 xfs_free_perag(mp);
Brian Fostera31b1d32014-07-15 08:07:01 +10001058
1059 xfs_sysfs_del(&mp->m_kobj);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001060}
1061
Brian Foster91ee5752014-11-28 14:02:59 +11001062/*
1063 * Determine whether modifications can proceed. The caller specifies the minimum
1064 * freeze level for which modifications should not be allowed. This allows
1065 * certain operations to proceed while the freeze sequence is in progress, if
1066 * necessary.
1067 */
1068bool
1069xfs_fs_writable(
1070 struct xfs_mount *mp,
1071 int level)
David Chinner92821e22007-05-24 15:26:31 +10001072{
Brian Foster91ee5752014-11-28 14:02:59 +11001073 ASSERT(level > SB_UNFROZEN);
1074 if ((mp->m_super->s_writers.frozen >= level) ||
1075 XFS_FORCED_SHUTDOWN(mp) || (mp->m_flags & XFS_MOUNT_RDONLY))
1076 return false;
1077
1078 return true;
David Chinner92821e22007-05-24 15:26:31 +10001079}
1080
1081/*
Alex Elderb2ce3972011-07-11 09:51:44 -05001082 * xfs_log_sbcount
1083 *
Chandra Seetharamanadab0f62011-06-29 22:10:14 +00001084 * Sync the superblock counters to disk.
Alex Elderb2ce3972011-07-11 09:51:44 -05001085 *
Brian Foster91ee5752014-11-28 14:02:59 +11001086 * Note this code can be called during the process of freezing, so we use the
1087 * transaction allocator that does not block when the transaction subsystem is
1088 * in its frozen state.
David Chinner92821e22007-05-24 15:26:31 +10001089 */
1090int
Chandra Seetharamanadab0f62011-06-29 22:10:14 +00001091xfs_log_sbcount(xfs_mount_t *mp)
David Chinner92821e22007-05-24 15:26:31 +10001092{
Brian Foster91ee5752014-11-28 14:02:59 +11001093 /* allow this to proceed during the freeze sequence... */
1094 if (!xfs_fs_writable(mp, SB_FREEZE_COMPLETE))
David Chinner92821e22007-05-24 15:26:31 +10001095 return 0;
1096
David Chinner92821e22007-05-24 15:26:31 +10001097 /*
1098 * we don't need to do this if we are updating the superblock
1099 * counters on every modification.
1100 */
1101 if (!xfs_sb_version_haslazysbcount(&mp->m_sb))
1102 return 0;
1103
Dave Chinner61e63ec2015-01-22 09:10:31 +11001104 return xfs_sync_sb(mp, true);
David Chinner92821e22007-05-24 15:26:31 +10001105}
1106
Dave Chinner8c1903d2015-05-29 07:39:34 +10001107/*
1108 * Deltas for the inode count are +/-64, hence we use a large batch size
1109 * of 128 so we don't need to take the counter lock on every update.
1110 */
1111#define XFS_ICOUNT_BATCH 128
Dave Chinner501ab322015-02-23 21:19:28 +11001112int
1113xfs_mod_icount(
1114 struct xfs_mount *mp,
1115 int64_t delta)
1116{
Dave Chinner8c1903d2015-05-29 07:39:34 +10001117 __percpu_counter_add(&mp->m_icount, delta, XFS_ICOUNT_BATCH);
1118 if (__percpu_counter_compare(&mp->m_icount, 0, XFS_ICOUNT_BATCH) < 0) {
Dave Chinner501ab322015-02-23 21:19:28 +11001119 ASSERT(0);
1120 percpu_counter_add(&mp->m_icount, -delta);
1121 return -EINVAL;
1122 }
1123 return 0;
1124}
1125
Dave Chinnere88b64e2015-02-23 21:19:53 +11001126int
1127xfs_mod_ifree(
1128 struct xfs_mount *mp,
1129 int64_t delta)
1130{
1131 percpu_counter_add(&mp->m_ifree, delta);
1132 if (percpu_counter_compare(&mp->m_ifree, 0) < 0) {
1133 ASSERT(0);
1134 percpu_counter_add(&mp->m_ifree, -delta);
1135 return -EINVAL;
1136 }
1137 return 0;
1138}
Dave Chinner0d485ad2015-02-23 21:22:03 +11001139
Dave Chinner8c1903d2015-05-29 07:39:34 +10001140/*
1141 * Deltas for the block count can vary from 1 to very large, but lock contention
1142 * only occurs on frequent small block count updates such as in the delayed
1143 * allocation path for buffered writes (page a time updates). Hence we set
1144 * a large batch count (1024) to minimise global counter updates except when
1145 * we get near to ENOSPC and we have to be very accurate with our updates.
1146 */
1147#define XFS_FDBLOCKS_BATCH 1024
Dave Chinner0d485ad2015-02-23 21:22:03 +11001148int
1149xfs_mod_fdblocks(
1150 struct xfs_mount *mp,
1151 int64_t delta,
1152 bool rsvd)
1153{
1154 int64_t lcounter;
1155 long long res_used;
1156 s32 batch;
1157
1158 if (delta > 0) {
1159 /*
1160 * If the reserve pool is depleted, put blocks back into it
1161 * first. Most of the time the pool is full.
1162 */
1163 if (likely(mp->m_resblks == mp->m_resblks_avail)) {
1164 percpu_counter_add(&mp->m_fdblocks, delta);
1165 return 0;
1166 }
1167
1168 spin_lock(&mp->m_sb_lock);
1169 res_used = (long long)(mp->m_resblks - mp->m_resblks_avail);
1170
1171 if (res_used > delta) {
1172 mp->m_resblks_avail += delta;
1173 } else {
1174 delta -= res_used;
1175 mp->m_resblks_avail = mp->m_resblks;
1176 percpu_counter_add(&mp->m_fdblocks, delta);
1177 }
1178 spin_unlock(&mp->m_sb_lock);
1179 return 0;
1180 }
1181
1182 /*
1183 * Taking blocks away, need to be more accurate the closer we
1184 * are to zero.
1185 *
Dave Chinner0d485ad2015-02-23 21:22:03 +11001186 * If the counter has a value of less than 2 * max batch size,
1187 * then make everything serialise as we are real close to
1188 * ENOSPC.
1189 */
Dave Chinner8c1903d2015-05-29 07:39:34 +10001190 if (__percpu_counter_compare(&mp->m_fdblocks, 2 * XFS_FDBLOCKS_BATCH,
1191 XFS_FDBLOCKS_BATCH) < 0)
Dave Chinner0d485ad2015-02-23 21:22:03 +11001192 batch = 1;
1193 else
Dave Chinner8c1903d2015-05-29 07:39:34 +10001194 batch = XFS_FDBLOCKS_BATCH;
Dave Chinner0d485ad2015-02-23 21:22:03 +11001195
1196 __percpu_counter_add(&mp->m_fdblocks, delta, batch);
Dave Chinner8c1903d2015-05-29 07:39:34 +10001197 if (__percpu_counter_compare(&mp->m_fdblocks, XFS_ALLOC_SET_ASIDE(mp),
1198 XFS_FDBLOCKS_BATCH) >= 0) {
Dave Chinner0d485ad2015-02-23 21:22:03 +11001199 /* we had space! */
1200 return 0;
1201 }
1202
1203 /*
1204 * lock up the sb for dipping into reserves before releasing the space
1205 * that took us to ENOSPC.
1206 */
1207 spin_lock(&mp->m_sb_lock);
1208 percpu_counter_add(&mp->m_fdblocks, -delta);
1209 if (!rsvd)
1210 goto fdblocks_enospc;
1211
1212 lcounter = (long long)mp->m_resblks_avail + delta;
1213 if (lcounter >= 0) {
1214 mp->m_resblks_avail = lcounter;
1215 spin_unlock(&mp->m_sb_lock);
1216 return 0;
1217 }
1218 printk_once(KERN_WARNING
1219 "Filesystem \"%s\": reserve blocks depleted! "
1220 "Consider increasing reserve pool size.",
1221 mp->m_fsname);
1222fdblocks_enospc:
1223 spin_unlock(&mp->m_sb_lock);
1224 return -ENOSPC;
1225}
1226
Dave Chinnerbab98bb2015-02-23 21:22:54 +11001227int
1228xfs_mod_frextents(
1229 struct xfs_mount *mp,
1230 int64_t delta)
1231{
1232 int64_t lcounter;
1233 int ret = 0;
1234
1235 spin_lock(&mp->m_sb_lock);
1236 lcounter = mp->m_sb.sb_frextents + delta;
1237 if (lcounter < 0)
1238 ret = -ENOSPC;
1239 else
1240 mp->m_sb.sb_frextents = lcounter;
1241 spin_unlock(&mp->m_sb_lock);
1242 return ret;
1243}
1244
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001246 * xfs_getsb() is called to obtain the buffer for the superblock.
1247 * The buffer is returned locked and read in from disk.
1248 * The buffer should be released with a call to xfs_brelse().
1249 *
1250 * If the flags parameter is BUF_TRYLOCK, then we'll only return
1251 * the superblock buffer if it can be locked without sleeping.
1252 * If it can't then we'll return NULL.
1253 */
Christoph Hellwig0c842ad2011-07-08 14:36:19 +02001254struct xfs_buf *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001255xfs_getsb(
Christoph Hellwig0c842ad2011-07-08 14:36:19 +02001256 struct xfs_mount *mp,
1257 int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001258{
Christoph Hellwig0c842ad2011-07-08 14:36:19 +02001259 struct xfs_buf *bp = mp->m_sb_bp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001260
Christoph Hellwig0c842ad2011-07-08 14:36:19 +02001261 if (!xfs_buf_trylock(bp)) {
1262 if (flags & XBF_TRYLOCK)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001263 return NULL;
Christoph Hellwig0c842ad2011-07-08 14:36:19 +02001264 xfs_buf_lock(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001265 }
Christoph Hellwig0c842ad2011-07-08 14:36:19 +02001266
Chandra Seetharaman72790aa2011-07-22 23:40:04 +00001267 xfs_buf_hold(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268 ASSERT(XFS_BUF_ISDONE(bp));
Jesper Juhl014c2542006-01-15 02:37:08 +01001269 return bp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001270}
1271
1272/*
1273 * Used to free the superblock along various error paths.
1274 */
1275void
1276xfs_freesb(
Dave Chinner26af6552010-09-22 10:47:20 +10001277 struct xfs_mount *mp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001278{
Dave Chinner26af6552010-09-22 10:47:20 +10001279 struct xfs_buf *bp = mp->m_sb_bp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001280
Dave Chinner26af6552010-09-22 10:47:20 +10001281 xfs_buf_lock(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001282 mp->m_sb_bp = NULL;
Dave Chinner26af6552010-09-22 10:47:20 +10001283 xfs_buf_relse(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284}
1285
1286/*
Christoph Hellwigdda35b82010-02-15 09:44:46 +00001287 * If the underlying (data/log/rt) device is readonly, there are some
1288 * operations that cannot proceed.
1289 */
1290int
1291xfs_dev_is_read_only(
1292 struct xfs_mount *mp,
1293 char *message)
1294{
1295 if (xfs_readonly_buftarg(mp->m_ddev_targp) ||
1296 xfs_readonly_buftarg(mp->m_logdev_targp) ||
1297 (mp->m_rtdev_targp && xfs_readonly_buftarg(mp->m_rtdev_targp))) {
Dave Chinner0b932cc2011-03-07 10:08:35 +11001298 xfs_notice(mp, "%s required on read-only device.", message);
1299 xfs_notice(mp, "write access unavailable, cannot proceed.");
Dave Chinner24513372014-06-25 14:58:08 +10001300 return -EROFS;
Christoph Hellwigdda35b82010-02-15 09:44:46 +00001301 }
1302 return 0;
1303}