blob: acbb4837abc5696c770df6be9a3c281fc040d406 [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"
Nathan Scotta844f452005-11-02 14:38:42 +110025#include "xfs_inum.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#include "xfs_sb.h"
27#include "xfs_ag.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include "xfs_mount.h"
Dave Chinner57062782013-10-15 09:17:51 +110029#include "xfs_da_format.h"
Dave Chinner9a2cc412014-12-04 09:43:17 +110030#include "xfs_da_btree.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070031#include "xfs_inode.h"
Dave Chinnera4fbe6a2013-10-23 10:51:50 +110032#include "xfs_dir2.h"
Nathan Scotta844f452005-11-02 14:38:42 +110033#include "xfs_ialloc.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070034#include "xfs_alloc.h"
35#include "xfs_rtalloc.h"
36#include "xfs_bmap.h"
Dave Chinnera4fbe6a2013-10-23 10:51:50 +110037#include "xfs_trans.h"
38#include "xfs_trans_priv.h"
39#include "xfs_log.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070040#include "xfs_error.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070041#include "xfs_quota.h"
42#include "xfs_fsops.h"
Christoph Hellwig0b1b2132009-12-14 23:14:59 +000043#include "xfs_trace.h"
Dave Chinner6d8b79c2012-10-08 21:56:09 +110044#include "xfs_icache.h"
Dave Chinner8f805872013-11-01 15:27:20 +110045#include "xfs_dinode.h"
Brian Fostera31b1d32014-07-15 08:07:01 +100046#include "xfs_sysfs.h"
Christoph Hellwig0b1b2132009-12-14 23:14:59 +000047
Linus Torvalds1da177e2005-04-16 15:20:36 -070048
David Chinner8d280b92006-03-14 13:13:09 +110049#ifdef HAVE_PERCPU_SB
David Chinner20f4ebf2007-02-10 18:36:10 +110050STATIC void xfs_icsb_balance_counter(xfs_mount_t *, xfs_sb_field_t,
Christoph Hellwig45af6c62008-04-22 17:34:44 +100051 int);
52STATIC void xfs_icsb_balance_counter_locked(xfs_mount_t *, xfs_sb_field_t,
53 int);
David Chinner36fbe6e2008-04-10 12:19:56 +100054STATIC void xfs_icsb_disable_counter(xfs_mount_t *, xfs_sb_field_t);
David Chinner8d280b92006-03-14 13:13:09 +110055#else
56
Christoph Hellwig45af6c62008-04-22 17:34:44 +100057#define xfs_icsb_balance_counter(mp, a, b) do { } while (0)
58#define xfs_icsb_balance_counter_locked(mp, a, b) do { } while (0)
David Chinner8d280b92006-03-14 13:13:09 +110059#endif
60
Christoph Hellwig27174202009-03-30 10:21:31 +020061static DEFINE_MUTEX(xfs_uuid_table_mutex);
62static int xfs_uuid_table_size;
63static uuid_t *xfs_uuid_table;
64
65/*
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
76 if (mp->m_flags & XFS_MOUNT_NOUUID)
77 return 0;
78
79 if (uuid_is_nil(uuid)) {
Dave Chinner0b932cc2011-03-07 10:08:35 +110080 xfs_warn(mp, "Filesystem has nil UUID - can't mount");
Dave Chinner24513372014-06-25 14:58:08 +100081 return -EINVAL;
Christoph Hellwig27174202009-03-30 10:21:31 +020082 }
83
84 mutex_lock(&xfs_uuid_table_mutex);
85 for (i = 0, hole = -1; i < xfs_uuid_table_size; i++) {
86 if (uuid_is_nil(&xfs_uuid_table[i])) {
87 hole = i;
88 continue;
89 }
90 if (uuid_equal(uuid, &xfs_uuid_table[i]))
91 goto out_duplicate;
92 }
93
94 if (hole < 0) {
95 xfs_uuid_table = kmem_realloc(xfs_uuid_table,
96 (xfs_uuid_table_size + 1) * sizeof(*xfs_uuid_table),
97 xfs_uuid_table_size * sizeof(*xfs_uuid_table),
98 KM_SLEEP);
99 hole = xfs_uuid_table_size++;
100 }
101 xfs_uuid_table[hole] = *uuid;
102 mutex_unlock(&xfs_uuid_table_mutex);
103
104 return 0;
105
106 out_duplicate:
107 mutex_unlock(&xfs_uuid_table_mutex);
Mitsuo Hayasaka021000e2012-01-13 05:58:39 +0000108 xfs_warn(mp, "Filesystem has duplicate UUID %pU - can't mount", uuid);
Dave Chinner24513372014-06-25 14:58:08 +1000109 return -EINVAL;
Christoph Hellwig27174202009-03-30 10:21:31 +0200110}
111
112STATIC void
113xfs_uuid_unmount(
114 struct xfs_mount *mp)
115{
116 uuid_t *uuid = &mp->m_sb.sb_uuid;
117 int i;
118
119 if (mp->m_flags & XFS_MOUNT_NOUUID)
120 return;
121
122 mutex_lock(&xfs_uuid_table_mutex);
123 for (i = 0; i < xfs_uuid_table_size; i++) {
124 if (uuid_is_nil(&xfs_uuid_table[i]))
125 continue;
126 if (!uuid_equal(uuid, &xfs_uuid_table[i]))
127 continue;
128 memset(&xfs_uuid_table[i], 0, sizeof(uuid_t));
129 break;
130 }
131 ASSERT(i < xfs_uuid_table_size);
132 mutex_unlock(&xfs_uuid_table_mutex);
133}
134
135
Dave Chinnere1765792010-09-22 10:47:20 +1000136STATIC void
137__xfs_free_perag(
138 struct rcu_head *head)
139{
140 struct xfs_perag *pag = container_of(head, struct xfs_perag, rcu_head);
141
142 ASSERT(atomic_read(&pag->pag_ref) == 0);
143 kmem_free(pag);
144}
145
Dave Chinner0fa800f2010-01-11 11:47:46 +0000146/*
Dave Chinnere1765792010-09-22 10:47:20 +1000147 * Free up the per-ag resources associated with the mount structure.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148 */
Christoph Hellwigc962fb72008-05-20 15:10:52 +1000149STATIC void
Christoph Hellwigff4f0382008-08-13 16:50:47 +1000150xfs_free_perag(
Christoph Hellwig745f6912007-08-30 17:20:39 +1000151 xfs_mount_t *mp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152{
Dave Chinner1c1c6eb2010-01-11 11:47:44 +0000153 xfs_agnumber_t agno;
154 struct xfs_perag *pag;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155
Dave Chinner1c1c6eb2010-01-11 11:47:44 +0000156 for (agno = 0; agno < mp->m_sb.sb_agcount; agno++) {
157 spin_lock(&mp->m_perag_lock);
158 pag = radix_tree_delete(&mp->m_perag_tree, agno);
159 spin_unlock(&mp->m_perag_lock);
Dave Chinnere1765792010-09-22 10:47:20 +1000160 ASSERT(pag);
Dave Chinnerf83282a2010-11-08 08:55:04 +0000161 ASSERT(atomic_read(&pag->pag_ref) == 0);
Dave Chinnere1765792010-09-22 10:47:20 +1000162 call_rcu(&pag->rcu_head, __xfs_free_perag);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164}
165
Nathan Scott4cc929e2007-05-14 18:24:02 +1000166/*
167 * Check size of device based on the (data/realtime) block count.
168 * Note: this check is used by the growfs code as well as mount.
169 */
170int
171xfs_sb_validate_fsb_count(
172 xfs_sb_t *sbp,
173 __uint64_t nblocks)
174{
175 ASSERT(PAGE_SHIFT >= sbp->sb_blocklog);
176 ASSERT(sbp->sb_blocklog >= BBSHIFT);
177
Christoph Hellwigd5cf09b2014-07-30 09:12:05 +1000178 /* Limited by ULONG_MAX of page cache index */
Nathan Scott4cc929e2007-05-14 18:24:02 +1000179 if (nblocks >> (PAGE_CACHE_SHIFT - sbp->sb_blocklog) > ULONG_MAX)
Dave Chinner24513372014-06-25 14:58:08 +1000180 return -EFBIG;
Nathan Scott4cc929e2007-05-14 18:24:02 +1000181 return 0;
182}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183
Dave Chinner1c1c6eb2010-01-11 11:47:44 +0000184int
Nathan Scottc11e2c32005-11-02 15:11:45 +1100185xfs_initialize_perag(
Nathan Scottc11e2c32005-11-02 15:11:45 +1100186 xfs_mount_t *mp,
Dave Chinner1c1c6eb2010-01-11 11:47:44 +0000187 xfs_agnumber_t agcount,
188 xfs_agnumber_t *maxagi)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189{
Carlos Maiolino2d2194f2012-09-20 10:32:38 -0300190 xfs_agnumber_t index;
Dave Chinner8b26c582010-01-11 11:47:48 +0000191 xfs_agnumber_t first_initialised = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 xfs_perag_t *pag;
193 xfs_agino_t agino;
194 xfs_ino_t ino;
195 xfs_sb_t *sbp = &mp->m_sb;
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 }
Dave Chinner8b26c582010-01-11 11:47:48 +0000209 if (!first_initialised)
210 first_initialised = index;
Christoph Hellwigfb3b5042010-05-28 19:03:10 +0000211
Dave Chinner1c1c6eb2010-01-11 11:47:44 +0000212 pag = kmem_zalloc(sizeof(*pag), KM_MAYFAIL);
213 if (!pag)
Dave Chinner8b26c582010-01-11 11:47:48 +0000214 goto out_unwind;
Christoph Hellwigfb3b5042010-05-28 19:03:10 +0000215 pag->pag_agno = index;
216 pag->pag_mount = mp;
Dave Chinner1a427ab2010-12-16 17:08:41 +1100217 spin_lock_init(&pag->pag_ici_lock);
Dave Chinner69b491c2010-09-27 11:09:51 +1000218 mutex_init(&pag->pag_ici_reclaim_lock);
Christoph Hellwigfb3b5042010-05-28 19:03:10 +0000219 INIT_RADIX_TREE(&pag->pag_ici_root, GFP_ATOMIC);
Dave Chinner74f75a02010-09-24 19:59:04 +1000220 spin_lock_init(&pag->pag_buf_lock);
221 pag->pag_buf_tree = RB_ROOT;
Christoph Hellwigfb3b5042010-05-28 19:03:10 +0000222
Dave Chinner1c1c6eb2010-01-11 11:47:44 +0000223 if (radix_tree_preload(GFP_NOFS))
Dave Chinner8b26c582010-01-11 11:47:48 +0000224 goto out_unwind;
Christoph Hellwigfb3b5042010-05-28 19:03:10 +0000225
Dave Chinner1c1c6eb2010-01-11 11:47:44 +0000226 spin_lock(&mp->m_perag_lock);
227 if (radix_tree_insert(&mp->m_perag_tree, index, pag)) {
228 BUG();
229 spin_unlock(&mp->m_perag_lock);
Dave Chinner8b26c582010-01-11 11:47:48 +0000230 radix_tree_preload_end();
231 error = -EEXIST;
232 goto out_unwind;
Dave Chinner1c1c6eb2010-01-11 11:47:44 +0000233 }
234 spin_unlock(&mp->m_perag_lock);
235 radix_tree_preload_end();
236 }
237
Christoph Hellwigfb3b5042010-05-28 19:03:10 +0000238 /*
239 * If we mount with the inode64 option, or no inode overflows
240 * the legacy 32-bit address space clear the inode32 option.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241 */
Christoph Hellwigfb3b5042010-05-28 19:03:10 +0000242 agino = XFS_OFFBNO_TO_AGINO(mp, sbp->sb_agblocks - 1, 0);
243 ino = XFS_AGINO_TO_INO(mp, agcount - 1, agino);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244
Christoph Hellwigfb3b5042010-05-28 19:03:10 +0000245 if ((mp->m_flags & XFS_MOUNT_SMALL_INUMS) && ino > XFS_MAXINUMBER_32)
246 mp->m_flags |= XFS_MOUNT_32BITINODES;
247 else
248 mp->m_flags &= ~XFS_MOUNT_32BITINODES;
249
Carlos Maiolino2d2194f2012-09-20 10:32:38 -0300250 if (mp->m_flags & XFS_MOUNT_32BITINODES)
Eric Sandeen9de67c32014-07-24 20:51:54 +1000251 index = xfs_set_inode32(mp, agcount);
Carlos Maiolino2d2194f2012-09-20 10:32:38 -0300252 else
Eric Sandeen9de67c32014-07-24 20:51:54 +1000253 index = xfs_set_inode64(mp, agcount);
Christoph Hellwigfb3b5042010-05-28 19:03:10 +0000254
Dave Chinner1c1c6eb2010-01-11 11:47:44 +0000255 if (maxagi)
256 *maxagi = index;
257 return 0;
Dave Chinner8b26c582010-01-11 11:47:48 +0000258
259out_unwind:
260 kmem_free(pag);
261 for (; index > first_initialised; index--) {
262 pag = radix_tree_delete(&mp->m_perag_tree, index);
263 kmem_free(pag);
264 }
265 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266}
267
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268/*
269 * xfs_readsb
270 *
271 * Does the initial read of the superblock.
272 */
273int
Dave Chinnerff550682013-08-12 20:49:41 +1000274xfs_readsb(
275 struct xfs_mount *mp,
276 int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277{
278 unsigned int sector_size;
Dave Chinner04a1e6c2013-04-03 16:11:31 +1100279 struct xfs_buf *bp;
280 struct xfs_sb *sbp = &mp->m_sb;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281 int error;
Dave Chinneraf34e092011-03-07 10:04:35 +1100282 int loud = !(flags & XFS_MFSI_QUIET);
Eric Sandeendaba5422014-02-19 15:39:16 +1100283 const struct xfs_buf_ops *buf_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284
285 ASSERT(mp->m_sb_bp == NULL);
286 ASSERT(mp->m_ddev_targp != NULL);
287
288 /*
Eric Sandeendaba5422014-02-19 15:39:16 +1100289 * For the initial read, we must guess at the sector
290 * size based on the block device. It's enough to
291 * get the sb_sectsize out of the superblock and
292 * then reread with the proper length.
293 * We don't verify it yet, because it may not be complete.
294 */
295 sector_size = xfs_getsize_buftarg(mp->m_ddev_targp);
296 buf_ops = NULL;
297
298 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299 * Allocate a (locked) buffer to hold the superblock.
300 * This will be kept around at all times to optimize
301 * access to the superblock.
302 */
Dave Chinner26af6552010-09-22 10:47:20 +1000303reread:
Dave Chinnerba3726742014-10-02 09:05:32 +1000304 error = xfs_buf_read_uncached(mp->m_ddev_targp, XFS_SB_DADDR,
305 BTOBB(sector_size), 0, &bp, buf_ops);
306 if (error) {
Dave Chinnereab4e632012-11-12 22:54:02 +1100307 if (loud)
Dave Chinnere721f502013-04-03 16:11:32 +1100308 xfs_warn(mp, "SB validate failed with error %d.", error);
Dave Chinnerac75a1f2014-03-07 16:19:14 +1100309 /* bad CRC means corrupted metadata */
Dave Chinner24513372014-06-25 14:58:08 +1000310 if (error == -EFSBADCRC)
311 error = -EFSCORRUPTED;
Dave Chinnerba3726742014-10-02 09:05:32 +1000312 return error;
Dave Chinnereab4e632012-11-12 22:54:02 +1100313 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314
315 /*
316 * Initialize the mount structure from the superblock.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317 */
Dave Chinner556b8882014-06-06 16:00:43 +1000318 xfs_sb_from_disk(sbp, XFS_BUF_TO_SBP(bp));
Dave Chinner556b8882014-06-06 16:00:43 +1000319
320 /*
321 * If we haven't validated the superblock, do so now before we try
322 * to check the sector size and reread the superblock appropriately.
323 */
324 if (sbp->sb_magicnum != XFS_SB_MAGIC) {
325 if (loud)
326 xfs_warn(mp, "Invalid superblock magic number");
Dave Chinner24513372014-06-25 14:58:08 +1000327 error = -EINVAL;
Dave Chinner556b8882014-06-06 16:00:43 +1000328 goto release_buf;
329 }
Dave Chinnerff550682013-08-12 20:49:41 +1000330
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331 /*
332 * We must be able to do sector-sized and sector-aligned IO.
333 */
Dave Chinner04a1e6c2013-04-03 16:11:31 +1100334 if (sector_size > sbp->sb_sectsize) {
Dave Chinneraf34e092011-03-07 10:04:35 +1100335 if (loud)
336 xfs_warn(mp, "device supports %u byte sectors (not %u)",
Dave Chinner04a1e6c2013-04-03 16:11:31 +1100337 sector_size, sbp->sb_sectsize);
Dave Chinner24513372014-06-25 14:58:08 +1000338 error = -ENOSYS;
Dave Chinner26af6552010-09-22 10:47:20 +1000339 goto release_buf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 }
341
Eric Sandeendaba5422014-02-19 15:39:16 +1100342 if (buf_ops == NULL) {
Dave Chinner556b8882014-06-06 16:00:43 +1000343 /*
344 * Re-read the superblock so the buffer is correctly sized,
345 * and properly verified.
346 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 xfs_buf_relse(bp);
Dave Chinner04a1e6c2013-04-03 16:11:31 +1100348 sector_size = sbp->sb_sectsize;
Eric Sandeendaba5422014-02-19 15:39:16 +1100349 buf_ops = loud ? &xfs_sb_buf_ops : &xfs_sb_quiet_buf_ops;
Dave Chinner26af6552010-09-22 10:47:20 +1000350 goto reread;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351 }
352
Lachlan McIlroy5478eea2007-02-10 18:36:29 +1100353 /* Initialize per-cpu counters */
354 xfs_icsb_reinit_counters(mp);
David Chinner8d280b92006-03-14 13:13:09 +1100355
Dave Chinner04a1e6c2013-04-03 16:11:31 +1100356 /* no need to be quiet anymore, so reset the buf ops */
357 bp->b_ops = &xfs_sb_buf_ops;
358
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359 mp->m_sb_bp = bp;
Dave Chinner26af6552010-09-22 10:47:20 +1000360 xfs_buf_unlock(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361 return 0;
362
Dave Chinner26af6552010-09-22 10:47:20 +1000363release_buf:
364 xfs_buf_relse(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365 return error;
366}
367
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368/*
Eric Sandeen0771fb42007-10-12 11:03:40 +1000369 * Update alignment values based on mount options and sb values
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 */
Eric Sandeen0771fb42007-10-12 11:03:40 +1000371STATIC int
Christoph Hellwig7884bc82009-01-19 02:04:07 +0100372xfs_update_alignment(xfs_mount_t *mp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 xfs_sb_t *sbp = &(mp->m_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375
Christoph Hellwig42490232008-08-13 16:49:32 +1000376 if (mp->m_dalign) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377 /*
378 * If stripe unit and stripe width are not multiples
379 * of the fs blocksize turn off alignment.
380 */
381 if ((BBTOB(mp->m_dalign) & mp->m_blockmask) ||
382 (BBTOB(mp->m_swidth) & mp->m_blockmask)) {
Jie Liu39a45d82013-05-02 19:27:47 +0800383 xfs_warn(mp,
384 "alignment check failed: sunit/swidth vs. blocksize(%d)",
385 sbp->sb_blocksize);
Dave Chinner24513372014-06-25 14:58:08 +1000386 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 } else {
388 /*
389 * Convert the stripe unit and width to FSBs.
390 */
391 mp->m_dalign = XFS_BB_TO_FSBT(mp, mp->m_dalign);
392 if (mp->m_dalign && (sbp->sb_agblocks % mp->m_dalign)) {
Dave Chinner53487782011-03-07 10:05:35 +1100393 xfs_warn(mp,
Jie Liu39a45d82013-05-02 19:27:47 +0800394 "alignment check failed: sunit/swidth vs. agsize(%d)",
395 sbp->sb_agblocks);
Dave Chinner24513372014-06-25 14:58:08 +1000396 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 } else if (mp->m_dalign) {
398 mp->m_swidth = XFS_BB_TO_FSBT(mp, mp->m_swidth);
399 } else {
Jie Liu39a45d82013-05-02 19:27:47 +0800400 xfs_warn(mp,
401 "alignment check failed: sunit(%d) less than bsize(%d)",
402 mp->m_dalign, sbp->sb_blocksize);
Dave Chinner24513372014-06-25 14:58:08 +1000403 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404 }
405 }
406
407 /*
408 * Update superblock with new values
409 * and log changes
410 */
Eric Sandeen62118702008-03-06 13:44:28 +1100411 if (xfs_sb_version_hasdalign(sbp)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412 if (sbp->sb_unit != mp->m_dalign) {
413 sbp->sb_unit = mp->m_dalign;
Christoph Hellwig7884bc82009-01-19 02:04:07 +0100414 mp->m_update_flags |= XFS_SB_UNIT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 }
416 if (sbp->sb_width != mp->m_swidth) {
417 sbp->sb_width = mp->m_swidth;
Christoph Hellwig7884bc82009-01-19 02:04:07 +0100418 mp->m_update_flags |= XFS_SB_WIDTH;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419 }
Jie Liu34d7f602013-05-02 19:27:53 +0800420 } else {
421 xfs_warn(mp,
422 "cannot change alignment: superblock does not support data alignment");
Dave Chinner24513372014-06-25 14:58:08 +1000423 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 }
425 } else if ((mp->m_flags & XFS_MOUNT_NOALIGN) != XFS_MOUNT_NOALIGN &&
Eric Sandeen62118702008-03-06 13:44:28 +1100426 xfs_sb_version_hasdalign(&mp->m_sb)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 mp->m_dalign = sbp->sb_unit;
428 mp->m_swidth = sbp->sb_width;
429 }
430
Eric Sandeen0771fb42007-10-12 11:03:40 +1000431 return 0;
432}
433
434/*
435 * Set the maximum inode count for this filesystem
436 */
437STATIC void
438xfs_set_maxicount(xfs_mount_t *mp)
439{
440 xfs_sb_t *sbp = &(mp->m_sb);
441 __uint64_t icount;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442
443 if (sbp->sb_imax_pct) {
Eric Sandeen0771fb42007-10-12 11:03:40 +1000444 /*
445 * Make sure the maximum inode count is a multiple
446 * of the units we allocate inodes in.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 icount = sbp->sb_dblocks * sbp->sb_imax_pct;
449 do_div(icount, 100);
450 do_div(icount, mp->m_ialloc_blks);
451 mp->m_maxicount = (icount * mp->m_ialloc_blks) <<
452 sbp->sb_inopblog;
Eric Sandeen0771fb42007-10-12 11:03:40 +1000453 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454 mp->m_maxicount = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455 }
Eric Sandeen0771fb42007-10-12 11:03:40 +1000456}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457
Eric Sandeen0771fb42007-10-12 11:03:40 +1000458/*
459 * Set the default minimum read and write sizes unless
460 * already specified in a mount option.
461 * We use smaller I/O sizes when the file system
462 * is being used for NFS service (wsync mount option).
463 */
464STATIC void
465xfs_set_rw_sizes(xfs_mount_t *mp)
466{
467 xfs_sb_t *sbp = &(mp->m_sb);
468 int readio_log, writeio_log;
469
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470 if (!(mp->m_flags & XFS_MOUNT_DFLT_IOSIZE)) {
471 if (mp->m_flags & XFS_MOUNT_WSYNC) {
472 readio_log = XFS_WSYNC_READIO_LOG;
473 writeio_log = XFS_WSYNC_WRITEIO_LOG;
474 } else {
475 readio_log = XFS_READIO_LOG_LARGE;
476 writeio_log = XFS_WRITEIO_LOG_LARGE;
477 }
478 } else {
479 readio_log = mp->m_readio_log;
480 writeio_log = mp->m_writeio_log;
481 }
482
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 if (sbp->sb_blocklog > readio_log) {
484 mp->m_readio_log = sbp->sb_blocklog;
485 } else {
486 mp->m_readio_log = readio_log;
487 }
488 mp->m_readio_blocks = 1 << (mp->m_readio_log - sbp->sb_blocklog);
489 if (sbp->sb_blocklog > writeio_log) {
490 mp->m_writeio_log = sbp->sb_blocklog;
491 } else {
492 mp->m_writeio_log = writeio_log;
493 }
494 mp->m_writeio_blocks = 1 << (mp->m_writeio_log - sbp->sb_blocklog);
Eric Sandeen0771fb42007-10-12 11:03:40 +1000495}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496
Eric Sandeen0771fb42007-10-12 11:03:40 +1000497/*
Dave Chinner055388a2011-01-04 11:35:03 +1100498 * precalculate the low space thresholds for dynamic speculative preallocation.
499 */
500void
501xfs_set_low_space_thresholds(
502 struct xfs_mount *mp)
503{
504 int i;
505
506 for (i = 0; i < XFS_LOWSP_MAX; i++) {
507 __uint64_t space = mp->m_sb.sb_dblocks;
508
509 do_div(space, 100);
510 mp->m_low_space[i] = space * (i + 1);
511 }
512}
513
514
515/*
Eric Sandeen0771fb42007-10-12 11:03:40 +1000516 * Set whether we're using inode alignment.
517 */
518STATIC void
519xfs_set_inoalignment(xfs_mount_t *mp)
520{
Eric Sandeen62118702008-03-06 13:44:28 +1100521 if (xfs_sb_version_hasalign(&mp->m_sb) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522 mp->m_sb.sb_inoalignmt >=
523 XFS_B_TO_FSBT(mp, mp->m_inode_cluster_size))
524 mp->m_inoalign_mask = mp->m_sb.sb_inoalignmt - 1;
525 else
526 mp->m_inoalign_mask = 0;
527 /*
528 * If we are using stripe alignment, check whether
529 * the stripe unit is a multiple of the inode alignment
530 */
531 if (mp->m_dalign && mp->m_inoalign_mask &&
532 !(mp->m_dalign & mp->m_inoalign_mask))
533 mp->m_sinoalign = mp->m_dalign;
534 else
535 mp->m_sinoalign = 0;
Eric Sandeen0771fb42007-10-12 11:03:40 +1000536}
537
538/*
Zhi Yong Wu0471f622013-08-07 10:10:58 +0000539 * Check that the data (and log if separate) is an ok size.
Eric Sandeen0771fb42007-10-12 11:03:40 +1000540 */
541STATIC int
Dave Chinnerba3726742014-10-02 09:05:32 +1000542xfs_check_sizes(
543 struct xfs_mount *mp)
Eric Sandeen0771fb42007-10-12 11:03:40 +1000544{
Dave Chinnerba3726742014-10-02 09:05:32 +1000545 struct xfs_buf *bp;
Eric Sandeen0771fb42007-10-12 11:03:40 +1000546 xfs_daddr_t d;
Dave Chinnerba3726742014-10-02 09:05:32 +1000547 int error;
Eric Sandeen0771fb42007-10-12 11:03:40 +1000548
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 d = (xfs_daddr_t)XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks);
550 if (XFS_BB_TO_FSB(mp, d) != mp->m_sb.sb_dblocks) {
Dave Chinner0b932cc2011-03-07 10:08:35 +1100551 xfs_warn(mp, "filesystem size mismatch detected");
Dave Chinner24513372014-06-25 14:58:08 +1000552 return -EFBIG;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553 }
Dave Chinnerba3726742014-10-02 09:05:32 +1000554 error = xfs_buf_read_uncached(mp->m_ddev_targp,
Dave Chinner1922c942010-09-22 10:47:20 +1000555 d - XFS_FSS_TO_BB(mp, 1),
Dave Chinnerba3726742014-10-02 09:05:32 +1000556 XFS_FSS_TO_BB(mp, 1), 0, &bp, NULL);
557 if (error) {
Dave Chinner0b932cc2011-03-07 10:08:35 +1100558 xfs_warn(mp, "last sector read failed");
Dave Chinnerba3726742014-10-02 09:05:32 +1000559 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560 }
Dave Chinner1922c942010-09-22 10:47:20 +1000561 xfs_buf_relse(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562
Dave Chinnerba3726742014-10-02 09:05:32 +1000563 if (mp->m_logdev_targp == mp->m_ddev_targp)
564 return 0;
565
566 d = (xfs_daddr_t)XFS_FSB_TO_BB(mp, mp->m_sb.sb_logblocks);
567 if (XFS_BB_TO_FSB(mp, d) != mp->m_sb.sb_logblocks) {
568 xfs_warn(mp, "log size mismatch detected");
569 return -EFBIG;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570 }
Dave Chinnerba3726742014-10-02 09:05:32 +1000571 error = xfs_buf_read_uncached(mp->m_logdev_targp,
572 d - XFS_FSB_TO_BB(mp, 1),
573 XFS_FSB_TO_BB(mp, 1), 0, &bp, NULL);
574 if (error) {
575 xfs_warn(mp, "log device read failed");
576 return error;
577 }
578 xfs_buf_relse(bp);
Eric Sandeen0771fb42007-10-12 11:03:40 +1000579 return 0;
580}
581
582/*
Christoph Hellwig7d095252009-06-08 15:33:32 +0200583 * Clear the quotaflags in memory and in the superblock.
584 */
585int
586xfs_mount_reset_sbqflags(
587 struct xfs_mount *mp)
588{
589 int error;
590 struct xfs_trans *tp;
591
592 mp->m_qflags = 0;
593
594 /*
595 * It is OK to look at sb_qflags here in mount path,
596 * without m_sb_lock.
597 */
598 if (mp->m_sb.sb_qflags == 0)
599 return 0;
600 spin_lock(&mp->m_sb_lock);
601 mp->m_sb.sb_qflags = 0;
602 spin_unlock(&mp->m_sb_lock);
603
604 /*
605 * If the fs is readonly, let the incore superblock run
606 * with quotas off but don't flush the update out to disk
607 */
608 if (mp->m_flags & XFS_MOUNT_RDONLY)
609 return 0;
610
Christoph Hellwig7d095252009-06-08 15:33:32 +0200611 tp = xfs_trans_alloc(mp, XFS_TRANS_QM_SBCHANGE);
Jie Liu3d3c8b52013-08-12 20:49:59 +1000612 error = xfs_trans_reserve(tp, &M_RES(mp)->tr_qm_sbchange, 0, 0);
Christoph Hellwig7d095252009-06-08 15:33:32 +0200613 if (error) {
614 xfs_trans_cancel(tp, 0);
Dave Chinner53487782011-03-07 10:05:35 +1100615 xfs_alert(mp, "%s: Superblock update failed!", __func__);
Christoph Hellwig7d095252009-06-08 15:33:32 +0200616 return error;
617 }
618
619 xfs_mod_sb(tp, XFS_SB_QFLAGS);
620 return xfs_trans_commit(tp, 0);
621}
622
Eric Sandeend5db0f92010-02-05 22:59:53 +0000623__uint64_t
624xfs_default_resblks(xfs_mount_t *mp)
625{
626 __uint64_t resblks;
627
628 /*
Dave Chinner8babd8a2010-03-04 01:46:25 +0000629 * We default to 5% or 8192 fsbs of space reserved, whichever is
630 * smaller. This is intended to cover concurrent allocation
631 * transactions when we initially hit enospc. These each require a 4
632 * block reservation. Hence by default we cover roughly 2000 concurrent
633 * allocation reservations.
Eric Sandeend5db0f92010-02-05 22:59:53 +0000634 */
635 resblks = mp->m_sb.sb_dblocks;
636 do_div(resblks, 20);
Dave Chinner8babd8a2010-03-04 01:46:25 +0000637 resblks = min_t(__uint64_t, resblks, 8192);
Eric Sandeend5db0f92010-02-05 22:59:53 +0000638 return resblks;
639}
640
Christoph Hellwig7d095252009-06-08 15:33:32 +0200641/*
Eric Sandeen0771fb42007-10-12 11:03:40 +1000642 * This function does the following on an initial mount of a file system:
643 * - reads the superblock from disk and init the mount struct
644 * - if we're a 32-bit kernel, do a size check on the superblock
645 * so we don't mount terabyte filesystems
646 * - init mount struct realtime fields
647 * - allocate inode hash table for fs
648 * - init directory manager
649 * - perform recovery and init the log manager
650 */
651int
652xfs_mountfs(
Christoph Hellwig42490232008-08-13 16:49:32 +1000653 xfs_mount_t *mp)
Eric Sandeen0771fb42007-10-12 11:03:40 +1000654{
655 xfs_sb_t *sbp = &(mp->m_sb);
656 xfs_inode_t *rip;
Eric Sandeen0771fb42007-10-12 11:03:40 +1000657 __uint64_t resblks;
Christoph Hellwig7d095252009-06-08 15:33:32 +0200658 uint quotamount = 0;
659 uint quotaflags = 0;
Eric Sandeen0771fb42007-10-12 11:03:40 +1000660 int error = 0;
661
Dave Chinnerff550682013-08-12 20:49:41 +1000662 xfs_sb_mount_common(mp, sbp);
Eric Sandeen0771fb42007-10-12 11:03:40 +1000663
664 /*
Eric Sandeene6957ea42008-04-10 12:19:34 +1000665 * Check for a mismatched features2 values. Older kernels
666 * read & wrote into the wrong sb offset for sb_features2
667 * on some platforms due to xfs_sb_t not being 64bit size aligned
668 * when sb_features2 was added, which made older superblock
669 * reading/writing routines swap it as a 64-bit value.
David Chinneree1c0902008-03-06 13:45:50 +1100670 *
Eric Sandeene6957ea42008-04-10 12:19:34 +1000671 * For backwards compatibility, we make both slots equal.
672 *
673 * If we detect a mismatched field, we OR the set bits into the
674 * existing features2 field in case it has already been modified; we
675 * don't want to lose any features. We then update the bad location
676 * with the ORed value so that older kernels will see any features2
677 * flags, and mark the two fields as needing updates once the
678 * transaction subsystem is online.
David Chinneree1c0902008-03-06 13:45:50 +1100679 */
Eric Sandeene6957ea42008-04-10 12:19:34 +1000680 if (xfs_sb_has_mismatched_features2(sbp)) {
Dave Chinner0b932cc2011-03-07 10:08:35 +1100681 xfs_warn(mp, "correcting sb_features alignment problem");
David Chinneree1c0902008-03-06 13:45:50 +1100682 sbp->sb_features2 |= sbp->sb_bad_features2;
Eric Sandeene6957ea42008-04-10 12:19:34 +1000683 sbp->sb_bad_features2 = sbp->sb_features2;
Christoph Hellwig7884bc82009-01-19 02:04:07 +0100684 mp->m_update_flags |= XFS_SB_FEATURES2 | XFS_SB_BAD_FEATURES2;
Eric Sandeene6957ea42008-04-10 12:19:34 +1000685
686 /*
687 * Re-check for ATTR2 in case it was found in bad_features2
688 * slot.
689 */
Tim Shimmin7c12f292008-04-30 18:15:28 +1000690 if (xfs_sb_version_hasattr2(&mp->m_sb) &&
691 !(mp->m_flags & XFS_MOUNT_NOATTR2))
Eric Sandeene6957ea42008-04-10 12:19:34 +1000692 mp->m_flags |= XFS_MOUNT_ATTR2;
Tim Shimmin7c12f292008-04-30 18:15:28 +1000693 }
Eric Sandeene6957ea42008-04-10 12:19:34 +1000694
Tim Shimmin7c12f292008-04-30 18:15:28 +1000695 if (xfs_sb_version_hasattr2(&mp->m_sb) &&
696 (mp->m_flags & XFS_MOUNT_NOATTR2)) {
697 xfs_sb_version_removeattr2(&mp->m_sb);
Christoph Hellwig7884bc82009-01-19 02:04:07 +0100698 mp->m_update_flags |= XFS_SB_FEATURES2;
Tim Shimmin7c12f292008-04-30 18:15:28 +1000699
700 /* update sb_versionnum for the clearing of the morebits */
701 if (!sbp->sb_features2)
Christoph Hellwig7884bc82009-01-19 02:04:07 +0100702 mp->m_update_flags |= XFS_SB_VERSIONNUM;
David Chinneree1c0902008-03-06 13:45:50 +1100703 }
704
Dave Chinner263997a2014-05-20 07:46:40 +1000705 /* always use v2 inodes by default now */
706 if (!(mp->m_sb.sb_versionnum & XFS_SB_VERSION_NLINKBIT)) {
707 mp->m_sb.sb_versionnum |= XFS_SB_VERSION_NLINKBIT;
708 mp->m_update_flags |= XFS_SB_VERSIONNUM;
709 }
710
David Chinneree1c0902008-03-06 13:45:50 +1100711 /*
Eric Sandeen0771fb42007-10-12 11:03:40 +1000712 * Check if sb_agblocks is aligned at stripe boundary
713 * If sb_agblocks is NOT aligned turn off m_dalign since
714 * allocator alignment is within an ag, therefore ag has
715 * to be aligned at stripe boundary.
716 */
Christoph Hellwig7884bc82009-01-19 02:04:07 +0100717 error = xfs_update_alignment(mp);
Eric Sandeen0771fb42007-10-12 11:03:40 +1000718 if (error)
Christoph Hellwigf9057e32009-02-04 09:31:52 +0100719 goto out;
Eric Sandeen0771fb42007-10-12 11:03:40 +1000720
721 xfs_alloc_compute_maxlevels(mp);
722 xfs_bmap_compute_maxlevels(mp, XFS_DATA_FORK);
723 xfs_bmap_compute_maxlevels(mp, XFS_ATTR_FORK);
724 xfs_ialloc_compute_maxlevels(mp);
725
726 xfs_set_maxicount(mp);
727
Brian Fostera31b1d32014-07-15 08:07:01 +1000728 error = xfs_sysfs_init(&mp->m_kobj, &xfs_mp_ktype, NULL, mp->m_fsname);
Christoph Hellwig27174202009-03-30 10:21:31 +0200729 if (error)
730 goto out;
Eric Sandeen0771fb42007-10-12 11:03:40 +1000731
Brian Fostera31b1d32014-07-15 08:07:01 +1000732 error = xfs_uuid_mount(mp);
733 if (error)
734 goto out_remove_sysfs;
735
Eric Sandeen0771fb42007-10-12 11:03:40 +1000736 /*
737 * Set the minimum read and write sizes
738 */
739 xfs_set_rw_sizes(mp);
740
Dave Chinner055388a2011-01-04 11:35:03 +1100741 /* set the low space thresholds for dynamic preallocation */
742 xfs_set_low_space_thresholds(mp);
743
Eric Sandeen0771fb42007-10-12 11:03:40 +1000744 /*
745 * Set the inode cluster size.
746 * This may still be overridden by the file system
747 * block size if it is larger than the chosen cluster size.
Dave Chinner8f805872013-11-01 15:27:20 +1100748 *
749 * For v5 filesystems, scale the cluster size with the inode size to
750 * keep a constant ratio of inode per cluster buffer, but only if mkfs
751 * has set the inode alignment value appropriately for larger cluster
752 * sizes.
Eric Sandeen0771fb42007-10-12 11:03:40 +1000753 */
754 mp->m_inode_cluster_size = XFS_INODE_BIG_CLUSTER_SIZE;
Dave Chinner8f805872013-11-01 15:27:20 +1100755 if (xfs_sb_version_hascrc(&mp->m_sb)) {
756 int new_size = mp->m_inode_cluster_size;
757
758 new_size *= mp->m_sb.sb_inodesize / XFS_DINODE_MIN_SIZE;
759 if (mp->m_sb.sb_inoalignmt >= XFS_B_TO_FSBT(mp, new_size))
760 mp->m_inode_cluster_size = new_size;
Dave Chinner8f805872013-11-01 15:27:20 +1100761 }
Eric Sandeen0771fb42007-10-12 11:03:40 +1000762
763 /*
764 * Set inode alignment fields
765 */
766 xfs_set_inoalignment(mp);
767
768 /*
Zhi Yong Wuc2bfbc92013-08-12 03:15:03 +0000769 * Check that the data (and log if separate) is an ok size.
Eric Sandeen0771fb42007-10-12 11:03:40 +1000770 */
Christoph Hellwig42490232008-08-13 16:49:32 +1000771 error = xfs_check_sizes(mp);
Eric Sandeen0771fb42007-10-12 11:03:40 +1000772 if (error)
Christoph Hellwigf9057e32009-02-04 09:31:52 +0100773 goto out_remove_uuid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774
775 /*
776 * Initialize realtime fields in the mount structure
777 */
Eric Sandeen0771fb42007-10-12 11:03:40 +1000778 error = xfs_rtmount_init(mp);
779 if (error) {
Dave Chinner0b932cc2011-03-07 10:08:35 +1100780 xfs_warn(mp, "RT mount failed");
Christoph Hellwigf9057e32009-02-04 09:31:52 +0100781 goto out_remove_uuid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782 }
783
784 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785 * Copies the low order bits of the timestamp and the randomly
786 * set "sequence" number out of a UUID.
787 */
788 uuid_getnodeuniq(&sbp->sb_uuid, mp->m_fixedfsid);
789
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790 mp->m_dmevmask = 0; /* not persistent; set after each mount */
791
Dave Chinner0650b552014-06-06 15:01:58 +1000792 error = xfs_da_mount(mp);
793 if (error) {
794 xfs_warn(mp, "Failed dir/attr init: %d", error);
795 goto out_remove_uuid;
796 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797
798 /*
799 * Initialize the precomputed transaction reservations values.
800 */
801 xfs_trans_init(mp);
802
803 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804 * Allocate and initialize the per-ag data.
805 */
Dave Chinner1c1c6eb2010-01-11 11:47:44 +0000806 spin_lock_init(&mp->m_perag_lock);
Dave Chinner9b98b6f2010-05-27 01:58:13 +0000807 INIT_RADIX_TREE(&mp->m_perag_tree, GFP_ATOMIC);
Dave Chinner1c1c6eb2010-01-11 11:47:44 +0000808 error = xfs_initialize_perag(mp, sbp->sb_agcount, &mp->m_maxagi);
809 if (error) {
Dave Chinner0b932cc2011-03-07 10:08:35 +1100810 xfs_warn(mp, "Failed per-ag init: %d", error);
Dave Chinner0650b552014-06-06 15:01:58 +1000811 goto out_free_dir;
Dave Chinner1c1c6eb2010-01-11 11:47:44 +0000812 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813
Christoph Hellwigf9057e32009-02-04 09:31:52 +0100814 if (!sbp->sb_logblocks) {
Dave Chinner0b932cc2011-03-07 10:08:35 +1100815 xfs_warn(mp, "no log defined");
Christoph Hellwigf9057e32009-02-04 09:31:52 +0100816 XFS_ERROR_REPORT("xfs_mountfs", XFS_ERRLEVEL_LOW, mp);
Dave Chinner24513372014-06-25 14:58:08 +1000817 error = -EFSCORRUPTED;
Christoph Hellwigf9057e32009-02-04 09:31:52 +0100818 goto out_free_perag;
819 }
820
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821 /*
822 * log's mount-time initialization. Perform 1st part recovery if needed
823 */
Christoph Hellwigf9057e32009-02-04 09:31:52 +0100824 error = xfs_log_mount(mp, mp->m_logdev_targp,
825 XFS_FSB_TO_DADDR(mp, sbp->sb_logstart),
826 XFS_FSB_TO_BB(mp, sbp->sb_logblocks));
827 if (error) {
Dave Chinner0b932cc2011-03-07 10:08:35 +1100828 xfs_warn(mp, "log mount failed");
Dave Chinnerd4f35122012-04-23 15:59:06 +1000829 goto out_fail_wait;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830 }
831
832 /*
David Chinner92821e22007-05-24 15:26:31 +1000833 * Now the log is mounted, we know if it was an unclean shutdown or
834 * not. If it was, with the first phase of recovery has completed, we
835 * have consistent AG blocks on disk. We have not recovered EFIs yet,
836 * but they are recovered transactionally in the second recovery phase
837 * later.
838 *
839 * Hence we can safely re-initialise incore superblock counters from
840 * the per-ag data. These may not be correct if the filesystem was not
841 * cleanly unmounted, so we need to wait for recovery to finish before
842 * doing this.
843 *
844 * If the filesystem was cleanly unmounted, then we can trust the
845 * values in the superblock to be correct and we don't need to do
846 * anything here.
847 *
848 * If we are currently making the filesystem, the initialisation will
849 * fail as the perag data is in an undefined state.
850 */
David Chinner92821e22007-05-24 15:26:31 +1000851 if (xfs_sb_version_haslazysbcount(&mp->m_sb) &&
852 !XFS_LAST_UNMOUNT_WAS_CLEAN(mp) &&
853 !mp->m_sb.sb_inprogress) {
854 error = xfs_initialize_perag_data(mp, sbp->sb_agcount);
Christoph Hellwigf9057e32009-02-04 09:31:52 +0100855 if (error)
kbuild test robot6eee8972014-08-04 13:49:40 +1000856 goto out_log_dealloc;
David Chinner92821e22007-05-24 15:26:31 +1000857 }
Christoph Hellwigf9057e32009-02-04 09:31:52 +0100858
David Chinner92821e22007-05-24 15:26:31 +1000859 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860 * Get and sanity-check the root inode.
861 * Save the pointer to it in the mount structure.
862 */
Dave Chinner7b6259e2010-06-24 11:35:17 +1000863 error = xfs_iget(mp, NULL, sbp->sb_rootino, 0, XFS_ILOCK_EXCL, &rip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864 if (error) {
Dave Chinner0b932cc2011-03-07 10:08:35 +1100865 xfs_warn(mp, "failed to read root inode");
Christoph Hellwigf9057e32009-02-04 09:31:52 +0100866 goto out_log_dealloc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867 }
868
869 ASSERT(rip != NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870
Al Viroabbede12011-07-26 02:31:30 -0400871 if (unlikely(!S_ISDIR(rip->i_d.di_mode))) {
Dave Chinner0b932cc2011-03-07 10:08:35 +1100872 xfs_warn(mp, "corrupted root inode %llu: not a directory",
Nathan Scottb6574522006-06-09 15:29:40 +1000873 (unsigned long long)rip->i_ino);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874 xfs_iunlock(rip, XFS_ILOCK_EXCL);
875 XFS_ERROR_REPORT("xfs_mountfs_int(2)", XFS_ERRLEVEL_LOW,
876 mp);
Dave Chinner24513372014-06-25 14:58:08 +1000877 error = -EFSCORRUPTED;
Christoph Hellwigf9057e32009-02-04 09:31:52 +0100878 goto out_rele_rip;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879 }
880 mp->m_rootip = rip; /* save it */
881
882 xfs_iunlock(rip, XFS_ILOCK_EXCL);
883
884 /*
885 * Initialize realtime inode pointers in the mount structure
886 */
Eric Sandeen0771fb42007-10-12 11:03:40 +1000887 error = xfs_rtmount_inodes(mp);
888 if (error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889 /*
890 * Free up the root inode.
891 */
Dave Chinner0b932cc2011-03-07 10:08:35 +1100892 xfs_warn(mp, "failed to read RT inodes");
Christoph Hellwigf9057e32009-02-04 09:31:52 +0100893 goto out_rele_rip;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700894 }
895
896 /*
Christoph Hellwig7884bc82009-01-19 02:04:07 +0100897 * If this is a read-only mount defer the superblock updates until
898 * the next remount into writeable mode. Otherwise we would never
899 * perform the update e.g. for the root filesystem.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900 */
Christoph Hellwig7884bc82009-01-19 02:04:07 +0100901 if (mp->m_update_flags && !(mp->m_flags & XFS_MOUNT_RDONLY)) {
902 error = xfs_mount_log_sb(mp, mp->m_update_flags);
David Chinnere5720ee2008-04-10 12:21:18 +1000903 if (error) {
Dave Chinner0b932cc2011-03-07 10:08:35 +1100904 xfs_warn(mp, "failed to write sb changes");
Christoph Hellwigb93b6e42009-02-04 09:33:58 +0100905 goto out_rtunmount;
David Chinnere5720ee2008-04-10 12:21:18 +1000906 }
907 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908
909 /*
910 * Initialise the XFS quota management subsystem for this mount
911 */
Christoph Hellwig7d095252009-06-08 15:33:32 +0200912 if (XFS_IS_QUOTA_RUNNING(mp)) {
913 error = xfs_qm_newmount(mp, &quotamount, &quotaflags);
914 if (error)
915 goto out_rtunmount;
916 } else {
917 ASSERT(!XFS_IS_QUOTA_ON(mp));
918
919 /*
920 * If a file system had quotas running earlier, but decided to
921 * mount without -o uquota/pquota/gquota options, revoke the
922 * quotachecked license.
923 */
924 if (mp->m_sb.sb_qflags & XFS_ALL_QUOTA_ACCT) {
Dave Chinner0b932cc2011-03-07 10:08:35 +1100925 xfs_notice(mp, "resetting quota flags");
Christoph Hellwig7d095252009-06-08 15:33:32 +0200926 error = xfs_mount_reset_sbqflags(mp);
927 if (error)
Brian Fostera70a4fa2014-07-15 07:41:25 +1000928 goto out_rtunmount;
Christoph Hellwig7d095252009-06-08 15:33:32 +0200929 }
930 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931
932 /*
933 * Finish recovering the file system. This part needed to be
934 * delayed until after the root and real-time bitmap inodes
935 * were consistently read in.
936 */
Christoph Hellwig42490232008-08-13 16:49:32 +1000937 error = xfs_log_mount_finish(mp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938 if (error) {
Dave Chinner0b932cc2011-03-07 10:08:35 +1100939 xfs_warn(mp, "log mount finish failed");
Christoph Hellwigb93b6e42009-02-04 09:33:58 +0100940 goto out_rtunmount;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700941 }
942
943 /*
944 * Complete the quota initialisation, post-log-replay component.
945 */
Christoph Hellwig7d095252009-06-08 15:33:32 +0200946 if (quotamount) {
947 ASSERT(mp->m_qflags == 0);
948 mp->m_qflags = quotaflags;
949
950 xfs_qm_mount_quotas(mp);
951 }
952
David Chinner84e1e992007-06-18 16:50:27 +1000953 /*
954 * Now we are mounted, reserve a small amount of unused space for
955 * privileged transactions. This is needed so that transaction
956 * space required for critical operations can dip into this pool
957 * when at ENOSPC. This is needed for operations like create with
958 * attr, unwritten extent conversion at ENOSPC, etc. Data allocations
959 * are not allowed to use this reserved space.
Dave Chinner8babd8a2010-03-04 01:46:25 +0000960 *
961 * This may drive us straight to ENOSPC on mount, but that implies
962 * we were already there on the last unmount. Warn if this occurs.
David Chinner84e1e992007-06-18 16:50:27 +1000963 */
Eric Sandeend5db0f92010-02-05 22:59:53 +0000964 if (!(mp->m_flags & XFS_MOUNT_RDONLY)) {
965 resblks = xfs_default_resblks(mp);
966 error = xfs_reserve_blocks(mp, &resblks, NULL);
967 if (error)
Dave Chinner0b932cc2011-03-07 10:08:35 +1100968 xfs_warn(mp,
969 "Unable to allocate reserve blocks. Continuing without reserve pool.");
Eric Sandeend5db0f92010-02-05 22:59:53 +0000970 }
David Chinner84e1e992007-06-18 16:50:27 +1000971
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972 return 0;
973
Christoph Hellwigb93b6e42009-02-04 09:33:58 +0100974 out_rtunmount:
975 xfs_rtunmount_inodes(mp);
Christoph Hellwigf9057e32009-02-04 09:31:52 +0100976 out_rele_rip:
Christoph Hellwig43355092008-03-27 18:01:08 +1100977 IRELE(rip);
Christoph Hellwigf9057e32009-02-04 09:31:52 +0100978 out_log_dealloc:
Christoph Hellwig21b699c2009-03-16 08:19:29 +0100979 xfs_log_unmount(mp);
Dave Chinnerd4f35122012-04-23 15:59:06 +1000980 out_fail_wait:
981 if (mp->m_logdev_targp && mp->m_logdev_targp != mp->m_ddev_targp)
982 xfs_wait_buftarg(mp->m_logdev_targp);
983 xfs_wait_buftarg(mp->m_ddev_targp);
Christoph Hellwigf9057e32009-02-04 09:31:52 +0100984 out_free_perag:
Christoph Hellwigff4f0382008-08-13 16:50:47 +1000985 xfs_free_perag(mp);
Dave Chinner0650b552014-06-06 15:01:58 +1000986 out_free_dir:
987 xfs_da_unmount(mp);
Christoph Hellwigf9057e32009-02-04 09:31:52 +0100988 out_remove_uuid:
Christoph Hellwig27174202009-03-30 10:21:31 +0200989 xfs_uuid_unmount(mp);
Brian Fostera31b1d32014-07-15 08:07:01 +1000990 out_remove_sysfs:
991 xfs_sysfs_del(&mp->m_kobj);
Christoph Hellwigf9057e32009-02-04 09:31:52 +0100992 out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993 return error;
994}
995
996/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700997 * This flushes out the inodes,dquots and the superblock, unmounts the
998 * log and makes sure that incore structures are freed.
999 */
Christoph Hellwig41b5c2e2008-08-13 16:49:57 +10001000void
1001xfs_unmountfs(
1002 struct xfs_mount *mp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003{
Christoph Hellwig41b5c2e2008-08-13 16:49:57 +10001004 __uint64_t resblks;
1005 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006
Brian Foster579b62f2012-11-06 09:50:47 -05001007 cancel_delayed_work_sync(&mp->m_eofblocks_work);
1008
Christoph Hellwig7d095252009-06-08 15:33:32 +02001009 xfs_qm_unmount_quotas(mp);
Christoph Hellwigb93b6e42009-02-04 09:33:58 +01001010 xfs_rtunmount_inodes(mp);
Christoph Hellwig77508ec2008-08-13 16:49:04 +10001011 IRELE(mp->m_rootip);
1012
David Chinner641c56f2007-06-18 16:50:17 +10001013 /*
1014 * We can potentially deadlock here if we have an inode cluster
Malcolm Parsons9da096f2009-03-29 09:55:42 +02001015 * that has been freed has its buffer still pinned in memory because
David Chinner641c56f2007-06-18 16:50:17 +10001016 * the transaction is still sitting in a iclog. The stale inodes
1017 * on that buffer will have their flush locks held until the
1018 * transaction hits the disk and the callbacks run. the inode
1019 * flush takes the flush lock unconditionally and with nothing to
1020 * push out the iclog we will never get that unlocked. hence we
1021 * need to force the log first.
1022 */
Christoph Hellwiga14a3482010-01-19 09:56:46 +00001023 xfs_log_force(mp, XFS_LOG_SYNC);
Dave Chinnerc8543632010-02-06 12:39:36 +11001024
1025 /*
Christoph Hellwig211e4d42012-04-23 15:58:34 +10001026 * Flush all pending changes from the AIL.
Dave Chinnerc8543632010-02-06 12:39:36 +11001027 */
Christoph Hellwig211e4d42012-04-23 15:58:34 +10001028 xfs_ail_push_all_sync(mp->m_ail);
1029
1030 /*
1031 * And reclaim all inodes. At this point there should be no dirty
Dave Chinner7e185302012-10-08 21:56:00 +11001032 * inodes and none should be pinned or locked, but use synchronous
1033 * reclaim just to be sure. We can stop background inode reclaim
1034 * here as well if it is still running.
Christoph Hellwig211e4d42012-04-23 15:58:34 +10001035 */
Dave Chinner7e185302012-10-08 21:56:00 +11001036 cancel_delayed_work_sync(&mp->m_reclaim_work);
Dave Chinnerc8543632010-02-06 12:39:36 +11001037 xfs_reclaim_inodes(mp, SYNC_WAIT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001038
Christoph Hellwig7d095252009-06-08 15:33:32 +02001039 xfs_qm_unmount(mp);
Lachlan McIlroya357a122008-10-30 16:53:25 +11001040
Linus Torvalds1da177e2005-04-16 15:20:36 -07001041 /*
David Chinner84e1e992007-06-18 16:50:27 +10001042 * Unreserve any blocks we have so that when we unmount we don't account
1043 * the reserved free space as used. This is really only necessary for
1044 * lazy superblock counting because it trusts the incore superblock
Malcolm Parsons9da096f2009-03-29 09:55:42 +02001045 * counters to be absolutely correct on clean unmount.
David Chinner84e1e992007-06-18 16:50:27 +10001046 *
1047 * We don't bother correcting this elsewhere for lazy superblock
1048 * counting because on mount of an unclean filesystem we reconstruct the
1049 * correct counter value and this is irrelevant.
1050 *
1051 * For non-lazy counter filesystems, this doesn't matter at all because
1052 * we only every apply deltas to the superblock and hence the incore
1053 * value does not matter....
1054 */
1055 resblks = 0;
David Chinner714082b2008-04-10 12:20:03 +10001056 error = xfs_reserve_blocks(mp, &resblks, NULL);
1057 if (error)
Dave Chinner0b932cc2011-03-07 10:08:35 +11001058 xfs_warn(mp, "Unable to free reserved block pool. "
David Chinner714082b2008-04-10 12:20:03 +10001059 "Freespace may not be correct on next mount.");
1060
Chandra Seetharamanadab0f62011-06-29 22:10:14 +00001061 error = xfs_log_sbcount(mp);
David Chinnere5720ee2008-04-10 12:21:18 +10001062 if (error)
Dave Chinner0b932cc2011-03-07 10:08:35 +11001063 xfs_warn(mp, "Unable to update superblock counters. "
David Chinnere5720ee2008-04-10 12:21:18 +10001064 "Freespace may not be correct on next mount.");
Christoph Hellwig87c7bec2011-09-14 14:08:26 +00001065
Christoph Hellwig21b699c2009-03-16 08:19:29 +01001066 xfs_log_unmount(mp);
Dave Chinner0650b552014-06-06 15:01:58 +10001067 xfs_da_unmount(mp);
Christoph Hellwig27174202009-03-30 10:21:31 +02001068 xfs_uuid_unmount(mp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001069
Christoph Hellwig1550d0b2008-08-13 16:17:37 +10001070#if defined(DEBUG)
Christoph Hellwig0ce4cfd2007-08-30 17:20:53 +10001071 xfs_errortag_clearall(mp, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072#endif
Christoph Hellwigff4f0382008-08-13 16:50:47 +10001073 xfs_free_perag(mp);
Brian Fostera31b1d32014-07-15 08:07:01 +10001074
1075 xfs_sysfs_del(&mp->m_kobj);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001076}
1077
Brian Foster91ee5752014-11-28 14:02:59 +11001078/*
1079 * Determine whether modifications can proceed. The caller specifies the minimum
1080 * freeze level for which modifications should not be allowed. This allows
1081 * certain operations to proceed while the freeze sequence is in progress, if
1082 * necessary.
1083 */
1084bool
1085xfs_fs_writable(
1086 struct xfs_mount *mp,
1087 int level)
David Chinner92821e22007-05-24 15:26:31 +10001088{
Brian Foster91ee5752014-11-28 14:02:59 +11001089 ASSERT(level > SB_UNFROZEN);
1090 if ((mp->m_super->s_writers.frozen >= level) ||
1091 XFS_FORCED_SHUTDOWN(mp) || (mp->m_flags & XFS_MOUNT_RDONLY))
1092 return false;
1093
1094 return true;
David Chinner92821e22007-05-24 15:26:31 +10001095}
1096
1097/*
Alex Elderb2ce3972011-07-11 09:51:44 -05001098 * xfs_log_sbcount
1099 *
Chandra Seetharamanadab0f62011-06-29 22:10:14 +00001100 * Sync the superblock counters to disk.
Alex Elderb2ce3972011-07-11 09:51:44 -05001101 *
Brian Foster91ee5752014-11-28 14:02:59 +11001102 * Note this code can be called during the process of freezing, so we use the
1103 * transaction allocator that does not block when the transaction subsystem is
1104 * in its frozen state.
David Chinner92821e22007-05-24 15:26:31 +10001105 */
1106int
Chandra Seetharamanadab0f62011-06-29 22:10:14 +00001107xfs_log_sbcount(xfs_mount_t *mp)
David Chinner92821e22007-05-24 15:26:31 +10001108{
1109 xfs_trans_t *tp;
1110 int error;
1111
Brian Foster91ee5752014-11-28 14:02:59 +11001112 /* allow this to proceed during the freeze sequence... */
1113 if (!xfs_fs_writable(mp, SB_FREEZE_COMPLETE))
David Chinner92821e22007-05-24 15:26:31 +10001114 return 0;
1115
Christoph Hellwigd4d90b52008-04-22 17:34:37 +10001116 xfs_icsb_sync_counters(mp, 0);
David Chinner92821e22007-05-24 15:26:31 +10001117
1118 /*
1119 * we don't need to do this if we are updating the superblock
1120 * counters on every modification.
1121 */
1122 if (!xfs_sb_version_haslazysbcount(&mp->m_sb))
1123 return 0;
1124
Alex Elderb2ce3972011-07-11 09:51:44 -05001125 tp = _xfs_trans_alloc(mp, XFS_TRANS_SB_COUNT, KM_SLEEP);
Jie Liu3d3c8b52013-08-12 20:49:59 +10001126 error = xfs_trans_reserve(tp, &M_RES(mp)->tr_sb, 0, 0);
David Chinner92821e22007-05-24 15:26:31 +10001127 if (error) {
1128 xfs_trans_cancel(tp, 0);
1129 return error;
1130 }
1131
1132 xfs_mod_sb(tp, XFS_SB_IFREE | XFS_SB_ICOUNT | XFS_SB_FDBLOCKS);
Chandra Seetharamanadab0f62011-06-29 22:10:14 +00001133 xfs_trans_set_sync(tp);
David Chinnere5720ee2008-04-10 12:21:18 +10001134 error = xfs_trans_commit(tp, 0);
1135 return error;
David Chinner92821e22007-05-24 15:26:31 +10001136}
1137
Linus Torvalds1da177e2005-04-16 15:20:36 -07001138/*
Zhi Yong Wu99e738b72013-08-07 10:11:01 +00001139 * xfs_mod_incore_sb_unlocked() is a utility routine commonly used to apply
Linus Torvalds1da177e2005-04-16 15:20:36 -07001140 * a delta to a specified field in the in-core superblock. Simply
1141 * switch on the field indicated and apply the delta to that field.
1142 * Fields are not allowed to dip below zero, so if the delta would
1143 * do this do not apply it and return EINVAL.
1144 *
Eric Sandeen3685c2a2007-10-11 17:42:32 +10001145 * The m_sb_lock must be held when this routine is called.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001146 */
Eric Sandeend96f8f82009-07-02 00:09:33 -05001147STATIC int
David Chinner20f4ebf2007-02-10 18:36:10 +11001148xfs_mod_incore_sb_unlocked(
1149 xfs_mount_t *mp,
1150 xfs_sb_field_t field,
1151 int64_t delta,
1152 int rsvd)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001153{
1154 int scounter; /* short counter for 32 bit fields */
1155 long long lcounter; /* long counter for 64 bit fields */
1156 long long res_used, rem;
1157
1158 /*
1159 * With the in-core superblock spin lock held, switch
1160 * on the indicated field. Apply the delta to the
1161 * proper field. If the fields value would dip below
1162 * 0, then do not apply the delta and return EINVAL.
1163 */
1164 switch (field) {
1165 case XFS_SBS_ICOUNT:
1166 lcounter = (long long)mp->m_sb.sb_icount;
1167 lcounter += delta;
1168 if (lcounter < 0) {
1169 ASSERT(0);
Dave Chinner24513372014-06-25 14:58:08 +10001170 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001171 }
1172 mp->m_sb.sb_icount = lcounter;
Jesper Juhl014c2542006-01-15 02:37:08 +01001173 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001174 case XFS_SBS_IFREE:
1175 lcounter = (long long)mp->m_sb.sb_ifree;
1176 lcounter += delta;
1177 if (lcounter < 0) {
1178 ASSERT(0);
Dave Chinner24513372014-06-25 14:58:08 +10001179 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001180 }
1181 mp->m_sb.sb_ifree = lcounter;
Jesper Juhl014c2542006-01-15 02:37:08 +01001182 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001183 case XFS_SBS_FDBLOCKS:
David Chinner4be536d2006-09-07 14:26:50 +10001184 lcounter = (long long)
1185 mp->m_sb.sb_fdblocks - XFS_ALLOC_SET_ASIDE(mp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001186 res_used = (long long)(mp->m_resblks - mp->m_resblks_avail);
1187
1188 if (delta > 0) { /* Putting blocks back */
1189 if (res_used > delta) {
1190 mp->m_resblks_avail += delta;
1191 } else {
1192 rem = delta - res_used;
1193 mp->m_resblks_avail = mp->m_resblks;
1194 lcounter += rem;
1195 }
1196 } else { /* Taking blocks away */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197 lcounter += delta;
Dave Chinner8babd8a2010-03-04 01:46:25 +00001198 if (lcounter >= 0) {
1199 mp->m_sb.sb_fdblocks = lcounter +
1200 XFS_ALLOC_SET_ASIDE(mp);
1201 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001202 }
Dave Chinner8babd8a2010-03-04 01:46:25 +00001203
1204 /*
1205 * We are out of blocks, use any available reserved
1206 * blocks if were allowed to.
1207 */
1208 if (!rsvd)
Dave Chinner24513372014-06-25 14:58:08 +10001209 return -ENOSPC;
Dave Chinner8babd8a2010-03-04 01:46:25 +00001210
1211 lcounter = (long long)mp->m_resblks_avail + delta;
1212 if (lcounter >= 0) {
1213 mp->m_resblks_avail = lcounter;
1214 return 0;
1215 }
1216 printk_once(KERN_WARNING
1217 "Filesystem \"%s\": reserve blocks depleted! "
1218 "Consider increasing reserve pool size.",
1219 mp->m_fsname);
Dave Chinner24513372014-06-25 14:58:08 +10001220 return -ENOSPC;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001221 }
1222
David Chinner4be536d2006-09-07 14:26:50 +10001223 mp->m_sb.sb_fdblocks = lcounter + XFS_ALLOC_SET_ASIDE(mp);
Jesper Juhl014c2542006-01-15 02:37:08 +01001224 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001225 case XFS_SBS_FREXTENTS:
1226 lcounter = (long long)mp->m_sb.sb_frextents;
1227 lcounter += delta;
1228 if (lcounter < 0) {
Dave Chinner24513372014-06-25 14:58:08 +10001229 return -ENOSPC;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001230 }
1231 mp->m_sb.sb_frextents = lcounter;
Jesper Juhl014c2542006-01-15 02:37:08 +01001232 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001233 case XFS_SBS_DBLOCKS:
1234 lcounter = (long long)mp->m_sb.sb_dblocks;
1235 lcounter += delta;
1236 if (lcounter < 0) {
1237 ASSERT(0);
Dave Chinner24513372014-06-25 14:58:08 +10001238 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001239 }
1240 mp->m_sb.sb_dblocks = lcounter;
Jesper Juhl014c2542006-01-15 02:37:08 +01001241 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001242 case XFS_SBS_AGCOUNT:
1243 scounter = mp->m_sb.sb_agcount;
1244 scounter += delta;
1245 if (scounter < 0) {
1246 ASSERT(0);
Dave Chinner24513372014-06-25 14:58:08 +10001247 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001248 }
1249 mp->m_sb.sb_agcount = scounter;
Jesper Juhl014c2542006-01-15 02:37:08 +01001250 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001251 case XFS_SBS_IMAX_PCT:
1252 scounter = mp->m_sb.sb_imax_pct;
1253 scounter += delta;
1254 if (scounter < 0) {
1255 ASSERT(0);
Dave Chinner24513372014-06-25 14:58:08 +10001256 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001257 }
1258 mp->m_sb.sb_imax_pct = scounter;
Jesper Juhl014c2542006-01-15 02:37:08 +01001259 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001260 case XFS_SBS_REXTSIZE:
1261 scounter = mp->m_sb.sb_rextsize;
1262 scounter += delta;
1263 if (scounter < 0) {
1264 ASSERT(0);
Dave Chinner24513372014-06-25 14:58:08 +10001265 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001266 }
1267 mp->m_sb.sb_rextsize = scounter;
Jesper Juhl014c2542006-01-15 02:37:08 +01001268 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001269 case XFS_SBS_RBMBLOCKS:
1270 scounter = mp->m_sb.sb_rbmblocks;
1271 scounter += delta;
1272 if (scounter < 0) {
1273 ASSERT(0);
Dave Chinner24513372014-06-25 14:58:08 +10001274 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275 }
1276 mp->m_sb.sb_rbmblocks = scounter;
Jesper Juhl014c2542006-01-15 02:37:08 +01001277 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001278 case XFS_SBS_RBLOCKS:
1279 lcounter = (long long)mp->m_sb.sb_rblocks;
1280 lcounter += delta;
1281 if (lcounter < 0) {
1282 ASSERT(0);
Dave Chinner24513372014-06-25 14:58:08 +10001283 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284 }
1285 mp->m_sb.sb_rblocks = lcounter;
Jesper Juhl014c2542006-01-15 02:37:08 +01001286 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001287 case XFS_SBS_REXTENTS:
1288 lcounter = (long long)mp->m_sb.sb_rextents;
1289 lcounter += delta;
1290 if (lcounter < 0) {
1291 ASSERT(0);
Dave Chinner24513372014-06-25 14:58:08 +10001292 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001293 }
1294 mp->m_sb.sb_rextents = lcounter;
Jesper Juhl014c2542006-01-15 02:37:08 +01001295 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001296 case XFS_SBS_REXTSLOG:
1297 scounter = mp->m_sb.sb_rextslog;
1298 scounter += delta;
1299 if (scounter < 0) {
1300 ASSERT(0);
Dave Chinner24513372014-06-25 14:58:08 +10001301 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302 }
1303 mp->m_sb.sb_rextslog = scounter;
Jesper Juhl014c2542006-01-15 02:37:08 +01001304 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001305 default:
1306 ASSERT(0);
Dave Chinner24513372014-06-25 14:58:08 +10001307 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308 }
1309}
1310
1311/*
1312 * xfs_mod_incore_sb() is used to change a field in the in-core
1313 * superblock structure by the specified delta. This modification
Eric Sandeen3685c2a2007-10-11 17:42:32 +10001314 * is protected by the m_sb_lock. Just use the xfs_mod_incore_sb_unlocked()
Linus Torvalds1da177e2005-04-16 15:20:36 -07001315 * routine to do the work.
1316 */
1317int
David Chinner20f4ebf2007-02-10 18:36:10 +11001318xfs_mod_incore_sb(
Christoph Hellwig96540c72010-09-30 02:25:55 +00001319 struct xfs_mount *mp,
1320 xfs_sb_field_t field,
1321 int64_t delta,
1322 int rsvd)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001323{
Christoph Hellwig96540c72010-09-30 02:25:55 +00001324 int status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001325
David Chinner8d280b92006-03-14 13:13:09 +11001326#ifdef HAVE_PERCPU_SB
Christoph Hellwig96540c72010-09-30 02:25:55 +00001327 ASSERT(field < XFS_SBS_ICOUNT || field > XFS_SBS_FDBLOCKS);
David Chinner8d280b92006-03-14 13:13:09 +11001328#endif
Christoph Hellwig96540c72010-09-30 02:25:55 +00001329 spin_lock(&mp->m_sb_lock);
1330 status = xfs_mod_incore_sb_unlocked(mp, field, delta, rsvd);
1331 spin_unlock(&mp->m_sb_lock);
David Chinner8d280b92006-03-14 13:13:09 +11001332
Jesper Juhl014c2542006-01-15 02:37:08 +01001333 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001334}
1335
1336/*
Christoph Hellwig1b040712010-09-30 02:25:56 +00001337 * Change more than one field in the in-core superblock structure at a time.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001338 *
Christoph Hellwig1b040712010-09-30 02:25:56 +00001339 * The fields and changes to those fields are specified in the array of
1340 * xfs_mod_sb structures passed in. Either all of the specified deltas
1341 * will be applied or none of them will. If any modified field dips below 0,
1342 * then all modifications will be backed out and EINVAL will be returned.
1343 *
1344 * Note that this function may not be used for the superblock values that
1345 * are tracked with the in-memory per-cpu counters - a direct call to
1346 * xfs_icsb_modify_counters is required for these.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001347 */
1348int
Christoph Hellwig1b040712010-09-30 02:25:56 +00001349xfs_mod_incore_sb_batch(
1350 struct xfs_mount *mp,
1351 xfs_mod_sb_t *msb,
1352 uint nmsb,
1353 int rsvd)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001354{
David Sterba45c51b92011-04-13 22:03:28 +00001355 xfs_mod_sb_t *msbp;
Christoph Hellwig1b040712010-09-30 02:25:56 +00001356 int error = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001357
1358 /*
Christoph Hellwig1b040712010-09-30 02:25:56 +00001359 * Loop through the array of mod structures and apply each individually.
1360 * If any fail, then back out all those which have already been applied.
1361 * Do all of this within the scope of the m_sb_lock so that all of the
1362 * changes will be atomic.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001363 */
Eric Sandeen3685c2a2007-10-11 17:42:32 +10001364 spin_lock(&mp->m_sb_lock);
David Sterba45c51b92011-04-13 22:03:28 +00001365 for (msbp = msb; msbp < (msb + nmsb); msbp++) {
Christoph Hellwig1b040712010-09-30 02:25:56 +00001366 ASSERT(msbp->msb_field < XFS_SBS_ICOUNT ||
1367 msbp->msb_field > XFS_SBS_FDBLOCKS);
David Chinner8d280b92006-03-14 13:13:09 +11001368
Christoph Hellwig1b040712010-09-30 02:25:56 +00001369 error = xfs_mod_incore_sb_unlocked(mp, msbp->msb_field,
1370 msbp->msb_delta, rsvd);
1371 if (error)
1372 goto unwind;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001373 }
Eric Sandeen3685c2a2007-10-11 17:42:32 +10001374 spin_unlock(&mp->m_sb_lock);
Christoph Hellwig1b040712010-09-30 02:25:56 +00001375 return 0;
1376
1377unwind:
1378 while (--msbp >= msb) {
1379 error = xfs_mod_incore_sb_unlocked(mp, msbp->msb_field,
1380 -msbp->msb_delta, rsvd);
1381 ASSERT(error == 0);
1382 }
1383 spin_unlock(&mp->m_sb_lock);
1384 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001385}
1386
1387/*
1388 * xfs_getsb() is called to obtain the buffer for the superblock.
1389 * The buffer is returned locked and read in from disk.
1390 * The buffer should be released with a call to xfs_brelse().
1391 *
1392 * If the flags parameter is BUF_TRYLOCK, then we'll only return
1393 * the superblock buffer if it can be locked without sleeping.
1394 * If it can't then we'll return NULL.
1395 */
Christoph Hellwig0c842ad2011-07-08 14:36:19 +02001396struct xfs_buf *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001397xfs_getsb(
Christoph Hellwig0c842ad2011-07-08 14:36:19 +02001398 struct xfs_mount *mp,
1399 int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001400{
Christoph Hellwig0c842ad2011-07-08 14:36:19 +02001401 struct xfs_buf *bp = mp->m_sb_bp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001402
Christoph Hellwig0c842ad2011-07-08 14:36:19 +02001403 if (!xfs_buf_trylock(bp)) {
1404 if (flags & XBF_TRYLOCK)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001405 return NULL;
Christoph Hellwig0c842ad2011-07-08 14:36:19 +02001406 xfs_buf_lock(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001407 }
Christoph Hellwig0c842ad2011-07-08 14:36:19 +02001408
Chandra Seetharaman72790aa2011-07-22 23:40:04 +00001409 xfs_buf_hold(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001410 ASSERT(XFS_BUF_ISDONE(bp));
Jesper Juhl014c2542006-01-15 02:37:08 +01001411 return bp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001412}
1413
1414/*
1415 * Used to free the superblock along various error paths.
1416 */
1417void
1418xfs_freesb(
Dave Chinner26af6552010-09-22 10:47:20 +10001419 struct xfs_mount *mp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420{
Dave Chinner26af6552010-09-22 10:47:20 +10001421 struct xfs_buf *bp = mp->m_sb_bp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001422
Dave Chinner26af6552010-09-22 10:47:20 +10001423 xfs_buf_lock(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001424 mp->m_sb_bp = NULL;
Dave Chinner26af6552010-09-22 10:47:20 +10001425 xfs_buf_relse(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001426}
1427
1428/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001429 * Used to log changes to the superblock unit and width fields which could
Eric Sandeene6957ea42008-04-10 12:19:34 +10001430 * be altered by the mount options, as well as any potential sb_features2
1431 * fixup. Only the first superblock is updated.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001432 */
Christoph Hellwig7884bc82009-01-19 02:04:07 +01001433int
David Chinneree1c0902008-03-06 13:45:50 +11001434xfs_mount_log_sb(
Linus Torvalds1da177e2005-04-16 15:20:36 -07001435 xfs_mount_t *mp,
1436 __int64_t fields)
1437{
1438 xfs_trans_t *tp;
David Chinnere5720ee2008-04-10 12:21:18 +10001439 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001440
David Chinneree1c0902008-03-06 13:45:50 +11001441 ASSERT(fields & (XFS_SB_UNIT | XFS_SB_WIDTH | XFS_SB_UUID |
David Chinner4b166de2008-05-20 11:30:27 +10001442 XFS_SB_FEATURES2 | XFS_SB_BAD_FEATURES2 |
1443 XFS_SB_VERSIONNUM));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001444
1445 tp = xfs_trans_alloc(mp, XFS_TRANS_SB_UNIT);
Jie Liu3d3c8b52013-08-12 20:49:59 +10001446 error = xfs_trans_reserve(tp, &M_RES(mp)->tr_sb, 0, 0);
David Chinnere5720ee2008-04-10 12:21:18 +10001447 if (error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001448 xfs_trans_cancel(tp, 0);
David Chinnere5720ee2008-04-10 12:21:18 +10001449 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001450 }
1451 xfs_mod_sb(tp, fields);
David Chinnere5720ee2008-04-10 12:21:18 +10001452 error = xfs_trans_commit(tp, 0);
1453 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001454}
David Chinner8d280b92006-03-14 13:13:09 +11001455
Christoph Hellwigdda35b82010-02-15 09:44:46 +00001456/*
1457 * If the underlying (data/log/rt) device is readonly, there are some
1458 * operations that cannot proceed.
1459 */
1460int
1461xfs_dev_is_read_only(
1462 struct xfs_mount *mp,
1463 char *message)
1464{
1465 if (xfs_readonly_buftarg(mp->m_ddev_targp) ||
1466 xfs_readonly_buftarg(mp->m_logdev_targp) ||
1467 (mp->m_rtdev_targp && xfs_readonly_buftarg(mp->m_rtdev_targp))) {
Dave Chinner0b932cc2011-03-07 10:08:35 +11001468 xfs_notice(mp, "%s required on read-only device.", message);
1469 xfs_notice(mp, "write access unavailable, cannot proceed.");
Dave Chinner24513372014-06-25 14:58:08 +10001470 return -EROFS;
Christoph Hellwigdda35b82010-02-15 09:44:46 +00001471 }
1472 return 0;
1473}
David Chinner8d280b92006-03-14 13:13:09 +11001474
1475#ifdef HAVE_PERCPU_SB
1476/*
1477 * Per-cpu incore superblock counters
1478 *
1479 * Simple concept, difficult implementation
1480 *
1481 * Basically, replace the incore superblock counters with a distributed per cpu
1482 * counter for contended fields (e.g. free block count).
1483 *
1484 * Difficulties arise in that the incore sb is used for ENOSPC checking, and
1485 * hence needs to be accurately read when we are running low on space. Hence
1486 * there is a method to enable and disable the per-cpu counters based on how
1487 * much "stuff" is available in them.
1488 *
1489 * Basically, a counter is enabled if there is enough free resource to justify
1490 * running a per-cpu fast-path. If the per-cpu counter runs out (i.e. a local
1491 * ENOSPC), then we disable the counters to synchronise all callers and
1492 * re-distribute the available resources.
1493 *
1494 * If, once we redistributed the available resources, we still get a failure,
1495 * we disable the per-cpu counter and go through the slow path.
1496 *
1497 * The slow path is the current xfs_mod_incore_sb() function. This means that
Malcolm Parsons9da096f2009-03-29 09:55:42 +02001498 * when we disable a per-cpu counter, we need to drain its resources back to
David Chinner8d280b92006-03-14 13:13:09 +11001499 * the global superblock. We do this after disabling the counter to prevent
1500 * more threads from queueing up on the counter.
1501 *
1502 * Essentially, this means that we still need a lock in the fast path to enable
1503 * synchronisation between the global counters and the per-cpu counters. This
1504 * is not a problem because the lock will be local to a CPU almost all the time
1505 * and have little contention except when we get to ENOSPC conditions.
1506 *
1507 * Basically, this lock becomes a barrier that enables us to lock out the fast
1508 * path while we do things like enabling and disabling counters and
1509 * synchronising the counters.
1510 *
1511 * Locking rules:
1512 *
Eric Sandeen3685c2a2007-10-11 17:42:32 +10001513 * 1. m_sb_lock before picking up per-cpu locks
David Chinner8d280b92006-03-14 13:13:09 +11001514 * 2. per-cpu locks always picked up via for_each_online_cpu() order
Eric Sandeen3685c2a2007-10-11 17:42:32 +10001515 * 3. accurate counter sync requires m_sb_lock + per cpu locks
David Chinner8d280b92006-03-14 13:13:09 +11001516 * 4. modifying per-cpu counters requires holding per-cpu lock
Eric Sandeen3685c2a2007-10-11 17:42:32 +10001517 * 5. modifying global counters requires holding m_sb_lock
1518 * 6. enabling or disabling a counter requires holding the m_sb_lock
David Chinner8d280b92006-03-14 13:13:09 +11001519 * and _none_ of the per-cpu locks.
1520 *
1521 * Disabled counters are only ever re-enabled by a balance operation
1522 * that results in more free resources per CPU than a given threshold.
1523 * To ensure counters don't remain disabled, they are rebalanced when
1524 * the global resource goes above a higher threshold (i.e. some hysteresis
1525 * is present to prevent thrashing).
David Chinner8d280b92006-03-14 13:13:09 +11001526 */
David Chinnere8234a62006-03-14 13:23:52 +11001527
Chandra Seetharaman5a67e4c2006-06-27 02:54:11 -07001528#ifdef CONFIG_HOTPLUG_CPU
David Chinnere8234a62006-03-14 13:23:52 +11001529/*
1530 * hot-plug CPU notifier support.
1531 *
Chandra Seetharaman5a67e4c2006-06-27 02:54:11 -07001532 * We need a notifier per filesystem as we need to be able to identify
1533 * the filesystem to balance the counters out. This is achieved by
1534 * having a notifier block embedded in the xfs_mount_t and doing pointer
1535 * magic to get the mount pointer from the notifier block address.
David Chinnere8234a62006-03-14 13:23:52 +11001536 */
1537STATIC int
1538xfs_icsb_cpu_notify(
1539 struct notifier_block *nfb,
1540 unsigned long action,
1541 void *hcpu)
1542{
1543 xfs_icsb_cnts_t *cntp;
1544 xfs_mount_t *mp;
David Chinnere8234a62006-03-14 13:23:52 +11001545
1546 mp = (xfs_mount_t *)container_of(nfb, xfs_mount_t, m_icsb_notifier);
1547 cntp = (xfs_icsb_cnts_t *)
1548 per_cpu_ptr(mp->m_sb_cnts, (unsigned long)hcpu);
1549 switch (action) {
1550 case CPU_UP_PREPARE:
Rafael J. Wysocki8bb78442007-05-09 02:35:10 -07001551 case CPU_UP_PREPARE_FROZEN:
David Chinnere8234a62006-03-14 13:23:52 +11001552 /* Easy Case - initialize the area and locks, and
1553 * then rebalance when online does everything else for us. */
David Chinner01e1b692006-03-14 13:29:16 +11001554 memset(cntp, 0, sizeof(xfs_icsb_cnts_t));
David Chinnere8234a62006-03-14 13:23:52 +11001555 break;
1556 case CPU_ONLINE:
Rafael J. Wysocki8bb78442007-05-09 02:35:10 -07001557 case CPU_ONLINE_FROZEN:
David Chinner03135cf2007-02-10 18:35:15 +11001558 xfs_icsb_lock(mp);
Christoph Hellwig45af6c62008-04-22 17:34:44 +10001559 xfs_icsb_balance_counter(mp, XFS_SBS_ICOUNT, 0);
1560 xfs_icsb_balance_counter(mp, XFS_SBS_IFREE, 0);
1561 xfs_icsb_balance_counter(mp, XFS_SBS_FDBLOCKS, 0);
David Chinner03135cf2007-02-10 18:35:15 +11001562 xfs_icsb_unlock(mp);
David Chinnere8234a62006-03-14 13:23:52 +11001563 break;
1564 case CPU_DEAD:
Rafael J. Wysocki8bb78442007-05-09 02:35:10 -07001565 case CPU_DEAD_FROZEN:
David Chinnere8234a62006-03-14 13:23:52 +11001566 /* Disable all the counters, then fold the dead cpu's
1567 * count into the total on the global superblock and
1568 * re-enable the counters. */
David Chinner03135cf2007-02-10 18:35:15 +11001569 xfs_icsb_lock(mp);
Eric Sandeen3685c2a2007-10-11 17:42:32 +10001570 spin_lock(&mp->m_sb_lock);
David Chinnere8234a62006-03-14 13:23:52 +11001571 xfs_icsb_disable_counter(mp, XFS_SBS_ICOUNT);
1572 xfs_icsb_disable_counter(mp, XFS_SBS_IFREE);
1573 xfs_icsb_disable_counter(mp, XFS_SBS_FDBLOCKS);
1574
1575 mp->m_sb.sb_icount += cntp->icsb_icount;
1576 mp->m_sb.sb_ifree += cntp->icsb_ifree;
1577 mp->m_sb.sb_fdblocks += cntp->icsb_fdblocks;
1578
David Chinner01e1b692006-03-14 13:29:16 +11001579 memset(cntp, 0, sizeof(xfs_icsb_cnts_t));
David Chinnere8234a62006-03-14 13:23:52 +11001580
Christoph Hellwig45af6c62008-04-22 17:34:44 +10001581 xfs_icsb_balance_counter_locked(mp, XFS_SBS_ICOUNT, 0);
1582 xfs_icsb_balance_counter_locked(mp, XFS_SBS_IFREE, 0);
1583 xfs_icsb_balance_counter_locked(mp, XFS_SBS_FDBLOCKS, 0);
Eric Sandeen3685c2a2007-10-11 17:42:32 +10001584 spin_unlock(&mp->m_sb_lock);
David Chinner03135cf2007-02-10 18:35:15 +11001585 xfs_icsb_unlock(mp);
David Chinnere8234a62006-03-14 13:23:52 +11001586 break;
1587 }
1588
1589 return NOTIFY_OK;
1590}
Chandra Seetharaman5a67e4c2006-06-27 02:54:11 -07001591#endif /* CONFIG_HOTPLUG_CPU */
David Chinnere8234a62006-03-14 13:23:52 +11001592
David Chinner8d280b92006-03-14 13:13:09 +11001593int
1594xfs_icsb_init_counters(
1595 xfs_mount_t *mp)
1596{
1597 xfs_icsb_cnts_t *cntp;
1598 int i;
1599
1600 mp->m_sb_cnts = alloc_percpu(xfs_icsb_cnts_t);
1601 if (mp->m_sb_cnts == NULL)
1602 return -ENOMEM;
1603
1604 for_each_online_cpu(i) {
1605 cntp = (xfs_icsb_cnts_t *)per_cpu_ptr(mp->m_sb_cnts, i);
David Chinner01e1b692006-03-14 13:29:16 +11001606 memset(cntp, 0, sizeof(xfs_icsb_cnts_t));
David Chinner8d280b92006-03-14 13:13:09 +11001607 }
David Chinner20b64282007-02-10 18:35:09 +11001608
1609 mutex_init(&mp->m_icsb_mutex);
1610
David Chinner8d280b92006-03-14 13:13:09 +11001611 /*
1612 * start with all counters disabled so that the
1613 * initial balance kicks us off correctly
1614 */
1615 mp->m_icsb_counters = -1;
Richard Weinberger46677e62013-08-19 22:56:44 +02001616
1617#ifdef CONFIG_HOTPLUG_CPU
1618 mp->m_icsb_notifier.notifier_call = xfs_icsb_cpu_notify;
1619 mp->m_icsb_notifier.priority = 0;
1620 register_hotcpu_notifier(&mp->m_icsb_notifier);
1621#endif /* CONFIG_HOTPLUG_CPU */
1622
David Chinner8d280b92006-03-14 13:13:09 +11001623 return 0;
1624}
1625
Lachlan McIlroy5478eea2007-02-10 18:36:29 +11001626void
1627xfs_icsb_reinit_counters(
1628 xfs_mount_t *mp)
1629{
1630 xfs_icsb_lock(mp);
1631 /*
1632 * start with all counters disabled so that the
1633 * initial balance kicks us off correctly
1634 */
1635 mp->m_icsb_counters = -1;
Christoph Hellwig45af6c62008-04-22 17:34:44 +10001636 xfs_icsb_balance_counter(mp, XFS_SBS_ICOUNT, 0);
1637 xfs_icsb_balance_counter(mp, XFS_SBS_IFREE, 0);
1638 xfs_icsb_balance_counter(mp, XFS_SBS_FDBLOCKS, 0);
Lachlan McIlroy5478eea2007-02-10 18:36:29 +11001639 xfs_icsb_unlock(mp);
1640}
1641
Christoph Hellwigc962fb72008-05-20 15:10:52 +10001642void
David Chinner8d280b92006-03-14 13:13:09 +11001643xfs_icsb_destroy_counters(
1644 xfs_mount_t *mp)
1645{
David Chinnere8234a62006-03-14 13:23:52 +11001646 if (mp->m_sb_cnts) {
Chandra Seetharaman5a67e4c2006-06-27 02:54:11 -07001647 unregister_hotcpu_notifier(&mp->m_icsb_notifier);
David Chinner8d280b92006-03-14 13:13:09 +11001648 free_percpu(mp->m_sb_cnts);
David Chinnere8234a62006-03-14 13:23:52 +11001649 }
David Chinner03135cf2007-02-10 18:35:15 +11001650 mutex_destroy(&mp->m_icsb_mutex);
David Chinner8d280b92006-03-14 13:13:09 +11001651}
1652
Christoph Hellwigb8f82a42009-11-14 16:17:22 +00001653STATIC void
David Chinner01e1b692006-03-14 13:29:16 +11001654xfs_icsb_lock_cntr(
1655 xfs_icsb_cnts_t *icsbp)
1656{
1657 while (test_and_set_bit(XFS_ICSB_FLAG_LOCK, &icsbp->icsb_flags)) {
1658 ndelay(1000);
1659 }
1660}
1661
Christoph Hellwigb8f82a42009-11-14 16:17:22 +00001662STATIC void
David Chinner01e1b692006-03-14 13:29:16 +11001663xfs_icsb_unlock_cntr(
1664 xfs_icsb_cnts_t *icsbp)
1665{
1666 clear_bit(XFS_ICSB_FLAG_LOCK, &icsbp->icsb_flags);
1667}
1668
David Chinner8d280b92006-03-14 13:13:09 +11001669
Christoph Hellwigb8f82a42009-11-14 16:17:22 +00001670STATIC void
David Chinner8d280b92006-03-14 13:13:09 +11001671xfs_icsb_lock_all_counters(
1672 xfs_mount_t *mp)
1673{
1674 xfs_icsb_cnts_t *cntp;
1675 int i;
1676
1677 for_each_online_cpu(i) {
1678 cntp = (xfs_icsb_cnts_t *)per_cpu_ptr(mp->m_sb_cnts, i);
David Chinner01e1b692006-03-14 13:29:16 +11001679 xfs_icsb_lock_cntr(cntp);
David Chinner8d280b92006-03-14 13:13:09 +11001680 }
1681}
1682
Christoph Hellwigb8f82a42009-11-14 16:17:22 +00001683STATIC void
David Chinner8d280b92006-03-14 13:13:09 +11001684xfs_icsb_unlock_all_counters(
1685 xfs_mount_t *mp)
1686{
1687 xfs_icsb_cnts_t *cntp;
1688 int i;
1689
1690 for_each_online_cpu(i) {
1691 cntp = (xfs_icsb_cnts_t *)per_cpu_ptr(mp->m_sb_cnts, i);
David Chinner01e1b692006-03-14 13:29:16 +11001692 xfs_icsb_unlock_cntr(cntp);
David Chinner8d280b92006-03-14 13:13:09 +11001693 }
1694}
1695
1696STATIC void
1697xfs_icsb_count(
1698 xfs_mount_t *mp,
1699 xfs_icsb_cnts_t *cnt,
1700 int flags)
1701{
1702 xfs_icsb_cnts_t *cntp;
1703 int i;
1704
1705 memset(cnt, 0, sizeof(xfs_icsb_cnts_t));
1706
1707 if (!(flags & XFS_ICSB_LAZY_COUNT))
1708 xfs_icsb_lock_all_counters(mp);
1709
1710 for_each_online_cpu(i) {
1711 cntp = (xfs_icsb_cnts_t *)per_cpu_ptr(mp->m_sb_cnts, i);
1712 cnt->icsb_icount += cntp->icsb_icount;
1713 cnt->icsb_ifree += cntp->icsb_ifree;
1714 cnt->icsb_fdblocks += cntp->icsb_fdblocks;
1715 }
1716
1717 if (!(flags & XFS_ICSB_LAZY_COUNT))
1718 xfs_icsb_unlock_all_counters(mp);
1719}
1720
1721STATIC int
1722xfs_icsb_counter_disabled(
1723 xfs_mount_t *mp,
1724 xfs_sb_field_t field)
1725{
1726 ASSERT((field >= XFS_SBS_ICOUNT) && (field <= XFS_SBS_FDBLOCKS));
1727 return test_bit(field, &mp->m_icsb_counters);
1728}
1729
David Chinner36fbe6e2008-04-10 12:19:56 +10001730STATIC void
David Chinner8d280b92006-03-14 13:13:09 +11001731xfs_icsb_disable_counter(
1732 xfs_mount_t *mp,
1733 xfs_sb_field_t field)
1734{
1735 xfs_icsb_cnts_t cnt;
1736
1737 ASSERT((field >= XFS_SBS_ICOUNT) && (field <= XFS_SBS_FDBLOCKS));
1738
David Chinner20b64282007-02-10 18:35:09 +11001739 /*
1740 * If we are already disabled, then there is nothing to do
1741 * here. We check before locking all the counters to avoid
1742 * the expensive lock operation when being called in the
1743 * slow path and the counter is already disabled. This is
1744 * safe because the only time we set or clear this state is under
1745 * the m_icsb_mutex.
1746 */
1747 if (xfs_icsb_counter_disabled(mp, field))
David Chinner36fbe6e2008-04-10 12:19:56 +10001748 return;
David Chinner20b64282007-02-10 18:35:09 +11001749
David Chinner8d280b92006-03-14 13:13:09 +11001750 xfs_icsb_lock_all_counters(mp);
1751 if (!test_and_set_bit(field, &mp->m_icsb_counters)) {
1752 /* drain back to superblock */
1753
Christoph Hellwigce461932008-04-22 17:34:50 +10001754 xfs_icsb_count(mp, &cnt, XFS_ICSB_LAZY_COUNT);
David Chinner8d280b92006-03-14 13:13:09 +11001755 switch(field) {
1756 case XFS_SBS_ICOUNT:
1757 mp->m_sb.sb_icount = cnt.icsb_icount;
1758 break;
1759 case XFS_SBS_IFREE:
1760 mp->m_sb.sb_ifree = cnt.icsb_ifree;
1761 break;
1762 case XFS_SBS_FDBLOCKS:
1763 mp->m_sb.sb_fdblocks = cnt.icsb_fdblocks;
1764 break;
1765 default:
1766 BUG();
1767 }
1768 }
1769
1770 xfs_icsb_unlock_all_counters(mp);
David Chinner8d280b92006-03-14 13:13:09 +11001771}
1772
1773STATIC void
1774xfs_icsb_enable_counter(
1775 xfs_mount_t *mp,
1776 xfs_sb_field_t field,
1777 uint64_t count,
1778 uint64_t resid)
1779{
1780 xfs_icsb_cnts_t *cntp;
1781 int i;
1782
1783 ASSERT((field >= XFS_SBS_ICOUNT) && (field <= XFS_SBS_FDBLOCKS));
1784
1785 xfs_icsb_lock_all_counters(mp);
1786 for_each_online_cpu(i) {
1787 cntp = per_cpu_ptr(mp->m_sb_cnts, i);
1788 switch (field) {
1789 case XFS_SBS_ICOUNT:
1790 cntp->icsb_icount = count + resid;
1791 break;
1792 case XFS_SBS_IFREE:
1793 cntp->icsb_ifree = count + resid;
1794 break;
1795 case XFS_SBS_FDBLOCKS:
1796 cntp->icsb_fdblocks = count + resid;
1797 break;
1798 default:
1799 BUG();
1800 break;
1801 }
1802 resid = 0;
1803 }
1804 clear_bit(field, &mp->m_icsb_counters);
1805 xfs_icsb_unlock_all_counters(mp);
1806}
1807
David Chinnerdbcabad2007-02-10 18:36:17 +11001808void
Christoph Hellwigd4d90b52008-04-22 17:34:37 +10001809xfs_icsb_sync_counters_locked(
David Chinner8d280b92006-03-14 13:13:09 +11001810 xfs_mount_t *mp,
1811 int flags)
1812{
1813 xfs_icsb_cnts_t cnt;
David Chinner8d280b92006-03-14 13:13:09 +11001814
David Chinner8d280b92006-03-14 13:13:09 +11001815 xfs_icsb_count(mp, &cnt, flags);
1816
David Chinner8d280b92006-03-14 13:13:09 +11001817 if (!xfs_icsb_counter_disabled(mp, XFS_SBS_ICOUNT))
1818 mp->m_sb.sb_icount = cnt.icsb_icount;
1819 if (!xfs_icsb_counter_disabled(mp, XFS_SBS_IFREE))
1820 mp->m_sb.sb_ifree = cnt.icsb_ifree;
1821 if (!xfs_icsb_counter_disabled(mp, XFS_SBS_FDBLOCKS))
1822 mp->m_sb.sb_fdblocks = cnt.icsb_fdblocks;
David Chinner8d280b92006-03-14 13:13:09 +11001823}
1824
1825/*
1826 * Accurate update of per-cpu counters to incore superblock
1827 */
Christoph Hellwigd4d90b52008-04-22 17:34:37 +10001828void
David Chinner8d280b92006-03-14 13:13:09 +11001829xfs_icsb_sync_counters(
Christoph Hellwigd4d90b52008-04-22 17:34:37 +10001830 xfs_mount_t *mp,
1831 int flags)
David Chinner8d280b92006-03-14 13:13:09 +11001832{
Christoph Hellwigd4d90b52008-04-22 17:34:37 +10001833 spin_lock(&mp->m_sb_lock);
1834 xfs_icsb_sync_counters_locked(mp, flags);
1835 spin_unlock(&mp->m_sb_lock);
David Chinner8d280b92006-03-14 13:13:09 +11001836}
1837
1838/*
1839 * Balance and enable/disable counters as necessary.
1840 *
David Chinner20b64282007-02-10 18:35:09 +11001841 * Thresholds for re-enabling counters are somewhat magic. inode counts are
1842 * chosen to be the same number as single on disk allocation chunk per CPU, and
1843 * free blocks is something far enough zero that we aren't going thrash when we
1844 * get near ENOSPC. We also need to supply a minimum we require per cpu to
1845 * prevent looping endlessly when xfs_alloc_space asks for more than will
1846 * be distributed to a single CPU but each CPU has enough blocks to be
1847 * reenabled.
1848 *
1849 * Note that we can be called when counters are already disabled.
1850 * xfs_icsb_disable_counter() optimises the counter locking in this case to
1851 * prevent locking every per-cpu counter needlessly.
David Chinner8d280b92006-03-14 13:13:09 +11001852 */
David Chinner20b64282007-02-10 18:35:09 +11001853
1854#define XFS_ICSB_INO_CNTR_REENABLE (uint64_t)64
David Chinner4be536d2006-09-07 14:26:50 +10001855#define XFS_ICSB_FDBLK_CNTR_REENABLE(mp) \
David Chinner20b64282007-02-10 18:35:09 +11001856 (uint64_t)(512 + XFS_ALLOC_SET_ASIDE(mp))
David Chinner8d280b92006-03-14 13:13:09 +11001857STATIC void
Christoph Hellwig45af6c62008-04-22 17:34:44 +10001858xfs_icsb_balance_counter_locked(
David Chinner8d280b92006-03-14 13:13:09 +11001859 xfs_mount_t *mp,
1860 xfs_sb_field_t field,
David Chinner20b64282007-02-10 18:35:09 +11001861 int min_per_cpu)
David Chinner8d280b92006-03-14 13:13:09 +11001862{
Nathan Scott6fdf8cc2006-06-28 10:13:52 +10001863 uint64_t count, resid;
David Chinner8d280b92006-03-14 13:13:09 +11001864 int weight = num_online_cpus();
David Chinner20b64282007-02-10 18:35:09 +11001865 uint64_t min = (uint64_t)min_per_cpu;
David Chinner8d280b92006-03-14 13:13:09 +11001866
David Chinner8d280b92006-03-14 13:13:09 +11001867 /* disable counter and sync counter */
1868 xfs_icsb_disable_counter(mp, field);
1869
1870 /* update counters - first CPU gets residual*/
1871 switch (field) {
1872 case XFS_SBS_ICOUNT:
1873 count = mp->m_sb.sb_icount;
1874 resid = do_div(count, weight);
David Chinner20b64282007-02-10 18:35:09 +11001875 if (count < max(min, XFS_ICSB_INO_CNTR_REENABLE))
Christoph Hellwig45af6c62008-04-22 17:34:44 +10001876 return;
David Chinner8d280b92006-03-14 13:13:09 +11001877 break;
1878 case XFS_SBS_IFREE:
1879 count = mp->m_sb.sb_ifree;
1880 resid = do_div(count, weight);
David Chinner20b64282007-02-10 18:35:09 +11001881 if (count < max(min, XFS_ICSB_INO_CNTR_REENABLE))
Christoph Hellwig45af6c62008-04-22 17:34:44 +10001882 return;
David Chinner8d280b92006-03-14 13:13:09 +11001883 break;
1884 case XFS_SBS_FDBLOCKS:
1885 count = mp->m_sb.sb_fdblocks;
1886 resid = do_div(count, weight);
David Chinner20b64282007-02-10 18:35:09 +11001887 if (count < max(min, XFS_ICSB_FDBLK_CNTR_REENABLE(mp)))
Christoph Hellwig45af6c62008-04-22 17:34:44 +10001888 return;
David Chinner8d280b92006-03-14 13:13:09 +11001889 break;
1890 default:
1891 BUG();
Nathan Scott6fdf8cc2006-06-28 10:13:52 +10001892 count = resid = 0; /* quiet, gcc */
David Chinner8d280b92006-03-14 13:13:09 +11001893 break;
1894 }
1895
1896 xfs_icsb_enable_counter(mp, field, count, resid);
Christoph Hellwig45af6c62008-04-22 17:34:44 +10001897}
1898
1899STATIC void
1900xfs_icsb_balance_counter(
1901 xfs_mount_t *mp,
1902 xfs_sb_field_t fields,
1903 int min_per_cpu)
1904{
1905 spin_lock(&mp->m_sb_lock);
1906 xfs_icsb_balance_counter_locked(mp, fields, min_per_cpu);
1907 spin_unlock(&mp->m_sb_lock);
David Chinner8d280b92006-03-14 13:13:09 +11001908}
1909
Christoph Hellwig1b040712010-09-30 02:25:56 +00001910int
David Chinner20b64282007-02-10 18:35:09 +11001911xfs_icsb_modify_counters(
David Chinner8d280b92006-03-14 13:13:09 +11001912 xfs_mount_t *mp,
1913 xfs_sb_field_t field,
David Chinner20f4ebf2007-02-10 18:36:10 +11001914 int64_t delta,
David Chinner20b64282007-02-10 18:35:09 +11001915 int rsvd)
David Chinner8d280b92006-03-14 13:13:09 +11001916{
1917 xfs_icsb_cnts_t *icsbp;
1918 long long lcounter; /* long counter for 64 bit fields */
Christoph Lameter7a9e02d2009-10-03 19:48:23 +09001919 int ret = 0;
David Chinner8d280b92006-03-14 13:13:09 +11001920
David Chinner20b64282007-02-10 18:35:09 +11001921 might_sleep();
David Chinner8d280b92006-03-14 13:13:09 +11001922again:
Christoph Lameter7a9e02d2009-10-03 19:48:23 +09001923 preempt_disable();
1924 icsbp = this_cpu_ptr(mp->m_sb_cnts);
David Chinner20b64282007-02-10 18:35:09 +11001925
1926 /*
1927 * if the counter is disabled, go to slow path
1928 */
David Chinner8d280b92006-03-14 13:13:09 +11001929 if (unlikely(xfs_icsb_counter_disabled(mp, field)))
1930 goto slow_path;
David Chinner20b64282007-02-10 18:35:09 +11001931 xfs_icsb_lock_cntr(icsbp);
1932 if (unlikely(xfs_icsb_counter_disabled(mp, field))) {
1933 xfs_icsb_unlock_cntr(icsbp);
1934 goto slow_path;
1935 }
David Chinner8d280b92006-03-14 13:13:09 +11001936
1937 switch (field) {
1938 case XFS_SBS_ICOUNT:
1939 lcounter = icsbp->icsb_icount;
1940 lcounter += delta;
1941 if (unlikely(lcounter < 0))
David Chinner20b64282007-02-10 18:35:09 +11001942 goto balance_counter;
David Chinner8d280b92006-03-14 13:13:09 +11001943 icsbp->icsb_icount = lcounter;
1944 break;
1945
1946 case XFS_SBS_IFREE:
1947 lcounter = icsbp->icsb_ifree;
1948 lcounter += delta;
1949 if (unlikely(lcounter < 0))
David Chinner20b64282007-02-10 18:35:09 +11001950 goto balance_counter;
David Chinner8d280b92006-03-14 13:13:09 +11001951 icsbp->icsb_ifree = lcounter;
1952 break;
1953
1954 case XFS_SBS_FDBLOCKS:
1955 BUG_ON((mp->m_resblks - mp->m_resblks_avail) != 0);
1956
David Chinner4be536d2006-09-07 14:26:50 +10001957 lcounter = icsbp->icsb_fdblocks - XFS_ALLOC_SET_ASIDE(mp);
David Chinner8d280b92006-03-14 13:13:09 +11001958 lcounter += delta;
1959 if (unlikely(lcounter < 0))
David Chinner20b64282007-02-10 18:35:09 +11001960 goto balance_counter;
David Chinner4be536d2006-09-07 14:26:50 +10001961 icsbp->icsb_fdblocks = lcounter + XFS_ALLOC_SET_ASIDE(mp);
David Chinner8d280b92006-03-14 13:13:09 +11001962 break;
1963 default:
1964 BUG();
1965 break;
1966 }
David Chinner01e1b692006-03-14 13:29:16 +11001967 xfs_icsb_unlock_cntr(icsbp);
Christoph Lameter7a9e02d2009-10-03 19:48:23 +09001968 preempt_enable();
David Chinner8d280b92006-03-14 13:13:09 +11001969 return 0;
1970
David Chinner8d280b92006-03-14 13:13:09 +11001971slow_path:
Christoph Lameter7a9e02d2009-10-03 19:48:23 +09001972 preempt_enable();
David Chinner20b64282007-02-10 18:35:09 +11001973
1974 /*
1975 * serialise with a mutex so we don't burn lots of cpu on
1976 * the superblock lock. We still need to hold the superblock
1977 * lock, however, when we modify the global structures.
1978 */
David Chinner03135cf2007-02-10 18:35:15 +11001979 xfs_icsb_lock(mp);
David Chinner20b64282007-02-10 18:35:09 +11001980
1981 /*
1982 * Now running atomically.
1983 *
1984 * If the counter is enabled, someone has beaten us to rebalancing.
1985 * Drop the lock and try again in the fast path....
1986 */
1987 if (!(xfs_icsb_counter_disabled(mp, field))) {
David Chinner03135cf2007-02-10 18:35:15 +11001988 xfs_icsb_unlock(mp);
David Chinner20b64282007-02-10 18:35:09 +11001989 goto again;
1990 }
1991
1992 /*
1993 * The counter is currently disabled. Because we are
1994 * running atomically here, we know a rebalance cannot
1995 * be in progress. Hence we can go straight to operating
1996 * on the global superblock. We do not call xfs_mod_incore_sb()
Eric Sandeen3685c2a2007-10-11 17:42:32 +10001997 * here even though we need to get the m_sb_lock. Doing so
David Chinner20b64282007-02-10 18:35:09 +11001998 * will cause us to re-enter this function and deadlock.
Eric Sandeen3685c2a2007-10-11 17:42:32 +10001999 * Hence we get the m_sb_lock ourselves and then call
David Chinner20b64282007-02-10 18:35:09 +11002000 * xfs_mod_incore_sb_unlocked() as the unlocked path operates
2001 * directly on the global counters.
2002 */
Eric Sandeen3685c2a2007-10-11 17:42:32 +10002003 spin_lock(&mp->m_sb_lock);
David Chinner20b64282007-02-10 18:35:09 +11002004 ret = xfs_mod_incore_sb_unlocked(mp, field, delta, rsvd);
Eric Sandeen3685c2a2007-10-11 17:42:32 +10002005 spin_unlock(&mp->m_sb_lock);
David Chinner20b64282007-02-10 18:35:09 +11002006
2007 /*
2008 * Now that we've modified the global superblock, we
2009 * may be able to re-enable the distributed counters
2010 * (e.g. lots of space just got freed). After that
2011 * we are done.
2012 */
Dave Chinner24513372014-06-25 14:58:08 +10002013 if (ret != -ENOSPC)
Christoph Hellwig45af6c62008-04-22 17:34:44 +10002014 xfs_icsb_balance_counter(mp, field, 0);
David Chinner03135cf2007-02-10 18:35:15 +11002015 xfs_icsb_unlock(mp);
David Chinner20b64282007-02-10 18:35:09 +11002016 return ret;
2017
2018balance_counter:
David Chinner01e1b692006-03-14 13:29:16 +11002019 xfs_icsb_unlock_cntr(icsbp);
Christoph Lameter7a9e02d2009-10-03 19:48:23 +09002020 preempt_enable();
David Chinner8d280b92006-03-14 13:13:09 +11002021
David Chinner20b64282007-02-10 18:35:09 +11002022 /*
2023 * We may have multiple threads here if multiple per-cpu
2024 * counters run dry at the same time. This will mean we can
2025 * do more balances than strictly necessary but it is not
2026 * the common slowpath case.
2027 */
David Chinner03135cf2007-02-10 18:35:15 +11002028 xfs_icsb_lock(mp);
David Chinner8d280b92006-03-14 13:13:09 +11002029
David Chinner20b64282007-02-10 18:35:09 +11002030 /*
2031 * running atomically.
2032 *
2033 * This will leave the counter in the correct state for future
2034 * accesses. After the rebalance, we simply try again and our retry
2035 * will either succeed through the fast path or slow path without
2036 * another balance operation being required.
2037 */
Christoph Hellwig45af6c62008-04-22 17:34:44 +10002038 xfs_icsb_balance_counter(mp, field, delta);
David Chinner03135cf2007-02-10 18:35:15 +11002039 xfs_icsb_unlock(mp);
David Chinner20b64282007-02-10 18:35:09 +11002040 goto again;
David Chinner8d280b92006-03-14 13:13:09 +11002041}
2042
David Chinner8d280b92006-03-14 13:13:09 +11002043#endif