blob: d7bf38c8cd1c47dc5bc19887072889267825bd91 [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"
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include "xfs_types.h"
Nathan Scotta844f452005-11-02 14:38:42 +110021#include "xfs_bit.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#include "xfs_log.h"
Nathan Scotta844f452005-11-02 14:38:42 +110023#include "xfs_inum.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#include "xfs_trans.h"
25#include "xfs_sb.h"
26#include "xfs_ag.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include "xfs_dir2.h"
28#include "xfs_dmapi.h"
29#include "xfs_mount.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070030#include "xfs_bmap_btree.h"
Nathan Scotta844f452005-11-02 14:38:42 +110031#include "xfs_alloc_btree.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#include "xfs_ialloc_btree.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#include "xfs_dir2_sf.h"
Nathan Scotta844f452005-11-02 14:38:42 +110034#include "xfs_attr_sf.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#include "xfs_dinode.h"
36#include "xfs_inode.h"
Nathan Scotta844f452005-11-02 14:38:42 +110037#include "xfs_btree.h"
38#include "xfs_ialloc.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070039#include "xfs_alloc.h"
40#include "xfs_rtalloc.h"
41#include "xfs_bmap.h"
42#include "xfs_error.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070043#include "xfs_rw.h"
44#include "xfs_quota.h"
45#include "xfs_fsops.h"
Christoph Hellwig43355092008-03-27 18:01:08 +110046#include "xfs_utils.h"
Christoph Hellwig0b1b2132009-12-14 23:14:59 +000047#include "xfs_trace.h"
48
Linus Torvalds1da177e2005-04-16 15:20:36 -070049
Christoph Hellwigba0f32d2005-06-21 15:36:52 +100050STATIC void xfs_unmountfs_wait(xfs_mount_t *);
Linus Torvalds1da177e2005-04-16 15:20:36 -070051
David Chinner8d280b92006-03-14 13:13:09 +110052
53#ifdef HAVE_PERCPU_SB
David Chinner20f4ebf2007-02-10 18:36:10 +110054STATIC void xfs_icsb_balance_counter(xfs_mount_t *, xfs_sb_field_t,
Christoph Hellwig45af6c62008-04-22 17:34:44 +100055 int);
56STATIC void xfs_icsb_balance_counter_locked(xfs_mount_t *, xfs_sb_field_t,
57 int);
David Chinner8d280b92006-03-14 13:13:09 +110058STATIC int xfs_icsb_modify_counters(xfs_mount_t *, xfs_sb_field_t,
David Chinner20f4ebf2007-02-10 18:36:10 +110059 int64_t, int);
David Chinner36fbe6e2008-04-10 12:19:56 +100060STATIC void xfs_icsb_disable_counter(xfs_mount_t *, xfs_sb_field_t);
David Chinner8d280b92006-03-14 13:13:09 +110061
62#else
63
Christoph Hellwig45af6c62008-04-22 17:34:44 +100064#define xfs_icsb_balance_counter(mp, a, b) do { } while (0)
65#define xfs_icsb_balance_counter_locked(mp, a, b) do { } while (0)
David Chinner8d280b92006-03-14 13:13:09 +110066#define xfs_icsb_modify_counters(mp, a, b, c) do { } while (0)
David Chinner8d280b92006-03-14 13:13:09 +110067
68#endif
69
Christoph Hellwig1df84c92006-01-11 15:29:52 +110070static const struct {
David Chinner8d280b92006-03-14 13:13:09 +110071 short offset;
72 short type; /* 0 = integer
73 * 1 = binary / string (no translation)
74 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070075} xfs_sb_info[] = {
76 { offsetof(xfs_sb_t, sb_magicnum), 0 },
77 { offsetof(xfs_sb_t, sb_blocksize), 0 },
78 { offsetof(xfs_sb_t, sb_dblocks), 0 },
79 { offsetof(xfs_sb_t, sb_rblocks), 0 },
80 { offsetof(xfs_sb_t, sb_rextents), 0 },
81 { offsetof(xfs_sb_t, sb_uuid), 1 },
82 { offsetof(xfs_sb_t, sb_logstart), 0 },
83 { offsetof(xfs_sb_t, sb_rootino), 0 },
84 { offsetof(xfs_sb_t, sb_rbmino), 0 },
85 { offsetof(xfs_sb_t, sb_rsumino), 0 },
86 { offsetof(xfs_sb_t, sb_rextsize), 0 },
87 { offsetof(xfs_sb_t, sb_agblocks), 0 },
88 { offsetof(xfs_sb_t, sb_agcount), 0 },
89 { offsetof(xfs_sb_t, sb_rbmblocks), 0 },
90 { offsetof(xfs_sb_t, sb_logblocks), 0 },
91 { offsetof(xfs_sb_t, sb_versionnum), 0 },
92 { offsetof(xfs_sb_t, sb_sectsize), 0 },
93 { offsetof(xfs_sb_t, sb_inodesize), 0 },
94 { offsetof(xfs_sb_t, sb_inopblock), 0 },
95 { offsetof(xfs_sb_t, sb_fname[0]), 1 },
96 { offsetof(xfs_sb_t, sb_blocklog), 0 },
97 { offsetof(xfs_sb_t, sb_sectlog), 0 },
98 { offsetof(xfs_sb_t, sb_inodelog), 0 },
99 { offsetof(xfs_sb_t, sb_inopblog), 0 },
100 { offsetof(xfs_sb_t, sb_agblklog), 0 },
101 { offsetof(xfs_sb_t, sb_rextslog), 0 },
102 { offsetof(xfs_sb_t, sb_inprogress), 0 },
103 { offsetof(xfs_sb_t, sb_imax_pct), 0 },
104 { offsetof(xfs_sb_t, sb_icount), 0 },
105 { offsetof(xfs_sb_t, sb_ifree), 0 },
106 { offsetof(xfs_sb_t, sb_fdblocks), 0 },
107 { offsetof(xfs_sb_t, sb_frextents), 0 },
108 { offsetof(xfs_sb_t, sb_uquotino), 0 },
109 { offsetof(xfs_sb_t, sb_gquotino), 0 },
110 { offsetof(xfs_sb_t, sb_qflags), 0 },
111 { offsetof(xfs_sb_t, sb_flags), 0 },
112 { offsetof(xfs_sb_t, sb_shared_vn), 0 },
113 { offsetof(xfs_sb_t, sb_inoalignmt), 0 },
114 { offsetof(xfs_sb_t, sb_unit), 0 },
115 { offsetof(xfs_sb_t, sb_width), 0 },
116 { offsetof(xfs_sb_t, sb_dirblklog), 0 },
117 { offsetof(xfs_sb_t, sb_logsectlog), 0 },
118 { offsetof(xfs_sb_t, sb_logsectsize),0 },
119 { offsetof(xfs_sb_t, sb_logsunit), 0 },
120 { offsetof(xfs_sb_t, sb_features2), 0 },
David Chinneree1c0902008-03-06 13:45:50 +1100121 { offsetof(xfs_sb_t, sb_bad_features2), 0 },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122 { sizeof(xfs_sb_t), 0 }
123};
124
Christoph Hellwig27174202009-03-30 10:21:31 +0200125static DEFINE_MUTEX(xfs_uuid_table_mutex);
126static int xfs_uuid_table_size;
127static uuid_t *xfs_uuid_table;
128
129/*
130 * See if the UUID is unique among mounted XFS filesystems.
131 * Mount fails if UUID is nil or a FS with the same UUID is already mounted.
132 */
133STATIC int
134xfs_uuid_mount(
135 struct xfs_mount *mp)
136{
137 uuid_t *uuid = &mp->m_sb.sb_uuid;
138 int hole, i;
139
140 if (mp->m_flags & XFS_MOUNT_NOUUID)
141 return 0;
142
143 if (uuid_is_nil(uuid)) {
144 cmn_err(CE_WARN,
145 "XFS: Filesystem %s has nil UUID - can't mount",
146 mp->m_fsname);
147 return XFS_ERROR(EINVAL);
148 }
149
150 mutex_lock(&xfs_uuid_table_mutex);
151 for (i = 0, hole = -1; i < xfs_uuid_table_size; i++) {
152 if (uuid_is_nil(&xfs_uuid_table[i])) {
153 hole = i;
154 continue;
155 }
156 if (uuid_equal(uuid, &xfs_uuid_table[i]))
157 goto out_duplicate;
158 }
159
160 if (hole < 0) {
161 xfs_uuid_table = kmem_realloc(xfs_uuid_table,
162 (xfs_uuid_table_size + 1) * sizeof(*xfs_uuid_table),
163 xfs_uuid_table_size * sizeof(*xfs_uuid_table),
164 KM_SLEEP);
165 hole = xfs_uuid_table_size++;
166 }
167 xfs_uuid_table[hole] = *uuid;
168 mutex_unlock(&xfs_uuid_table_mutex);
169
170 return 0;
171
172 out_duplicate:
173 mutex_unlock(&xfs_uuid_table_mutex);
174 cmn_err(CE_WARN, "XFS: Filesystem %s has duplicate UUID - can't mount",
175 mp->m_fsname);
176 return XFS_ERROR(EINVAL);
177}
178
179STATIC void
180xfs_uuid_unmount(
181 struct xfs_mount *mp)
182{
183 uuid_t *uuid = &mp->m_sb.sb_uuid;
184 int i;
185
186 if (mp->m_flags & XFS_MOUNT_NOUUID)
187 return;
188
189 mutex_lock(&xfs_uuid_table_mutex);
190 for (i = 0; i < xfs_uuid_table_size; i++) {
191 if (uuid_is_nil(&xfs_uuid_table[i]))
192 continue;
193 if (!uuid_equal(uuid, &xfs_uuid_table[i]))
194 continue;
195 memset(&xfs_uuid_table[i], 0, sizeof(uuid_t));
196 break;
197 }
198 ASSERT(i < xfs_uuid_table_size);
199 mutex_unlock(&xfs_uuid_table_mutex);
200}
201
202
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203/*
Dave Chinner0fa800f2010-01-11 11:47:46 +0000204 * Reference counting access wrappers to the perag structures.
205 */
206struct xfs_perag *
207xfs_perag_get(struct xfs_mount *mp, xfs_agnumber_t agno)
208{
209 struct xfs_perag *pag;
210 int ref = 0;
211
212 spin_lock(&mp->m_perag_lock);
213 pag = radix_tree_lookup(&mp->m_perag_tree, agno);
214 if (pag) {
215 ASSERT(atomic_read(&pag->pag_ref) >= 0);
216 /* catch leaks in the positive direction during testing */
217 ASSERT(atomic_read(&pag->pag_ref) < 1000);
218 ref = atomic_inc_return(&pag->pag_ref);
219 }
220 spin_unlock(&mp->m_perag_lock);
221 trace_xfs_perag_get(mp, agno, ref, _RET_IP_);
222 return pag;
223}
224
225void
226xfs_perag_put(struct xfs_perag *pag)
227{
228 int ref;
229
230 ASSERT(atomic_read(&pag->pag_ref) > 0);
231 ref = atomic_dec_return(&pag->pag_ref);
232 trace_xfs_perag_put(pag->pag_mount, pag->pag_agno, ref, _RET_IP_);
233}
234
235/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236 * Free up the resources associated with a mount structure. Assume that
237 * the structure was initially zeroed, so we can tell which fields got
238 * initialized.
239 */
Christoph Hellwigc962fb72008-05-20 15:10:52 +1000240STATIC void
Christoph Hellwigff4f0382008-08-13 16:50:47 +1000241xfs_free_perag(
Christoph Hellwig745f6912007-08-30 17:20:39 +1000242 xfs_mount_t *mp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243{
Dave Chinner1c1c6eb2010-01-11 11:47:44 +0000244 xfs_agnumber_t agno;
245 struct xfs_perag *pag;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246
Dave Chinner1c1c6eb2010-01-11 11:47:44 +0000247 for (agno = 0; agno < mp->m_sb.sb_agcount; agno++) {
248 spin_lock(&mp->m_perag_lock);
249 pag = radix_tree_delete(&mp->m_perag_tree, agno);
Dave Chinnere57336f2010-01-11 11:47:49 +0000250 ASSERT(pag);
Dave Chinneraed3bb92010-01-11 11:47:45 +0000251 ASSERT(atomic_read(&pag->pag_ref) == 0);
Dave Chinner1c1c6eb2010-01-11 11:47:44 +0000252 spin_unlock(&mp->m_perag_lock);
Dave Chinner1c1c6eb2010-01-11 11:47:44 +0000253 kmem_free(pag);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255}
256
Nathan Scott4cc929e2007-05-14 18:24:02 +1000257/*
258 * Check size of device based on the (data/realtime) block count.
259 * Note: this check is used by the growfs code as well as mount.
260 */
261int
262xfs_sb_validate_fsb_count(
263 xfs_sb_t *sbp,
264 __uint64_t nblocks)
265{
266 ASSERT(PAGE_SHIFT >= sbp->sb_blocklog);
267 ASSERT(sbp->sb_blocklog >= BBSHIFT);
268
269#if XFS_BIG_BLKNOS /* Limited by ULONG_MAX of page cache index */
270 if (nblocks >> (PAGE_CACHE_SHIFT - sbp->sb_blocklog) > ULONG_MAX)
271 return E2BIG;
272#else /* Limited by UINT_MAX of sectors */
273 if (nblocks << (sbp->sb_blocklog - BBSHIFT) > UINT_MAX)
274 return E2BIG;
275#endif
276 return 0;
277}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278
279/*
280 * Check the validity of the SB found.
281 */
282STATIC int
283xfs_mount_validate_sb(
284 xfs_mount_t *mp,
Nathan Scott764d1f82006-03-31 13:04:17 +1000285 xfs_sb_t *sbp,
286 int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287{
288 /*
289 * If the log device and data device have the
290 * same device number, the log is internal.
291 * Consequently, the sb_logstart should be non-zero. If
292 * we have a zero sb_logstart in this case, we may be trying to mount
293 * a volume filesystem in a non-volume manner.
294 */
295 if (sbp->sb_magicnum != XFS_SB_MAGIC) {
Nathan Scott764d1f82006-03-31 13:04:17 +1000296 xfs_fs_mount_cmn_err(flags, "bad magic number");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297 return XFS_ERROR(EWRONGFS);
298 }
299
Eric Sandeen62118702008-03-06 13:44:28 +1100300 if (!xfs_sb_good_version(sbp)) {
Nathan Scott764d1f82006-03-31 13:04:17 +1000301 xfs_fs_mount_cmn_err(flags, "bad version");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 return XFS_ERROR(EWRONGFS);
303 }
304
305 if (unlikely(
306 sbp->sb_logstart == 0 && mp->m_logdev_targp == mp->m_ddev_targp)) {
Nathan Scott764d1f82006-03-31 13:04:17 +1000307 xfs_fs_mount_cmn_err(flags,
308 "filesystem is marked as having an external log; "
309 "specify logdev on the\nmount command line.");
310 return XFS_ERROR(EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311 }
312
313 if (unlikely(
314 sbp->sb_logstart != 0 && mp->m_logdev_targp != mp->m_ddev_targp)) {
Nathan Scott764d1f82006-03-31 13:04:17 +1000315 xfs_fs_mount_cmn_err(flags,
316 "filesystem is marked as having an internal log; "
317 "do not specify logdev on\nthe mount command line.");
318 return XFS_ERROR(EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319 }
320
321 /*
322 * More sanity checking. These were stolen directly from
323 * xfs_repair.
324 */
325 if (unlikely(
326 sbp->sb_agcount <= 0 ||
327 sbp->sb_sectsize < XFS_MIN_SECTORSIZE ||
328 sbp->sb_sectsize > XFS_MAX_SECTORSIZE ||
329 sbp->sb_sectlog < XFS_MIN_SECTORSIZE_LOG ||
330 sbp->sb_sectlog > XFS_MAX_SECTORSIZE_LOG ||
Olaf Weber2ac00af2009-04-17 16:12:45 -0500331 sbp->sb_sectsize != (1 << sbp->sb_sectlog) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332 sbp->sb_blocksize < XFS_MIN_BLOCKSIZE ||
333 sbp->sb_blocksize > XFS_MAX_BLOCKSIZE ||
334 sbp->sb_blocklog < XFS_MIN_BLOCKSIZE_LOG ||
335 sbp->sb_blocklog > XFS_MAX_BLOCKSIZE_LOG ||
Olaf Weber2ac00af2009-04-17 16:12:45 -0500336 sbp->sb_blocksize != (1 << sbp->sb_blocklog) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337 sbp->sb_inodesize < XFS_DINODE_MIN_SIZE ||
338 sbp->sb_inodesize > XFS_DINODE_MAX_SIZE ||
Nathan Scott9f989c92006-03-14 13:29:32 +1100339 sbp->sb_inodelog < XFS_DINODE_MIN_LOG ||
340 sbp->sb_inodelog > XFS_DINODE_MAX_LOG ||
Olaf Weber2ac00af2009-04-17 16:12:45 -0500341 sbp->sb_inodesize != (1 << sbp->sb_inodelog) ||
Nathan Scott9f989c92006-03-14 13:29:32 +1100342 (sbp->sb_blocklog - sbp->sb_inodelog != sbp->sb_inopblog) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343 (sbp->sb_rextsize * sbp->sb_blocksize > XFS_MAX_RTEXTSIZE) ||
344 (sbp->sb_rextsize * sbp->sb_blocksize < XFS_MIN_RTEXTSIZE) ||
Nathan Scotte50bd162006-04-11 15:10:45 +1000345 (sbp->sb_imax_pct > 100 /* zero sb_imax_pct is valid */))) {
Nathan Scott764d1f82006-03-31 13:04:17 +1000346 xfs_fs_mount_cmn_err(flags, "SB sanity check 1 failed");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 return XFS_ERROR(EFSCORRUPTED);
348 }
349
350 /*
351 * Sanity check AG count, size fields against data size field
352 */
353 if (unlikely(
354 sbp->sb_dblocks == 0 ||
355 sbp->sb_dblocks >
356 (xfs_drfsbno_t)sbp->sb_agcount * sbp->sb_agblocks ||
357 sbp->sb_dblocks < (xfs_drfsbno_t)(sbp->sb_agcount - 1) *
358 sbp->sb_agblocks + XFS_MIN_AG_BLOCKS)) {
Nathan Scott764d1f82006-03-31 13:04:17 +1000359 xfs_fs_mount_cmn_err(flags, "SB sanity check 2 failed");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360 return XFS_ERROR(EFSCORRUPTED);
361 }
362
Lachlan McIlroy2edbddd2008-06-27 13:34:34 +1000363 /*
364 * Until this is fixed only page-sized or smaller data blocks work.
365 */
366 if (unlikely(sbp->sb_blocksize > PAGE_SIZE)) {
367 xfs_fs_mount_cmn_err(flags,
368 "file system with blocksize %d bytes",
369 sbp->sb_blocksize);
370 xfs_fs_mount_cmn_err(flags,
371 "only pagesize (%ld) or less will currently work.",
372 PAGE_SIZE);
373 return XFS_ERROR(ENOSYS);
374 }
375
Christoph Hellwig1a5902c2009-03-29 19:26:46 +0200376 /*
377 * Currently only very few inode sizes are supported.
378 */
379 switch (sbp->sb_inodesize) {
380 case 256:
381 case 512:
382 case 1024:
383 case 2048:
384 break;
385 default:
386 xfs_fs_mount_cmn_err(flags,
387 "inode size of %d bytes not supported",
388 sbp->sb_inodesize);
389 return XFS_ERROR(ENOSYS);
390 }
391
Nathan Scott4cc929e2007-05-14 18:24:02 +1000392 if (xfs_sb_validate_fsb_count(sbp, sbp->sb_dblocks) ||
393 xfs_sb_validate_fsb_count(sbp, sbp->sb_rblocks)) {
Nathan Scott764d1f82006-03-31 13:04:17 +1000394 xfs_fs_mount_cmn_err(flags,
395 "file system too large to be mounted on this system.");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396 return XFS_ERROR(E2BIG);
397 }
398
399 if (unlikely(sbp->sb_inprogress)) {
Nathan Scott764d1f82006-03-31 13:04:17 +1000400 xfs_fs_mount_cmn_err(flags, "file system busy");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401 return XFS_ERROR(EFSCORRUPTED);
402 }
403
404 /*
Nathan Scottde206142005-05-05 13:24:13 -0700405 * Version 1 directory format has never worked on Linux.
406 */
Eric Sandeen62118702008-03-06 13:44:28 +1100407 if (unlikely(!xfs_sb_version_hasdirv2(sbp))) {
Nathan Scott764d1f82006-03-31 13:04:17 +1000408 xfs_fs_mount_cmn_err(flags,
409 "file system using version 1 directory format");
Nathan Scottde206142005-05-05 13:24:13 -0700410 return XFS_ERROR(ENOSYS);
411 }
412
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413 return 0;
414}
415
David Chinnerda353b02007-08-28 14:00:13 +1000416STATIC void
417xfs_initialize_perag_icache(
418 xfs_perag_t *pag)
419{
420 if (!pag->pag_ici_init) {
421 rwlock_init(&pag->pag_ici_lock);
422 INIT_RADIX_TREE(&pag->pag_ici_root, GFP_ATOMIC);
423 pag->pag_ici_init = 1;
424 }
425}
426
Dave Chinner1c1c6eb2010-01-11 11:47:44 +0000427int
Nathan Scottc11e2c32005-11-02 15:11:45 +1100428xfs_initialize_perag(
Nathan Scottc11e2c32005-11-02 15:11:45 +1100429 xfs_mount_t *mp,
Dave Chinner1c1c6eb2010-01-11 11:47:44 +0000430 xfs_agnumber_t agcount,
431 xfs_agnumber_t *maxagi)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432{
433 xfs_agnumber_t index, max_metadata;
Dave Chinner8b26c582010-01-11 11:47:48 +0000434 xfs_agnumber_t first_initialised = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435 xfs_perag_t *pag;
436 xfs_agino_t agino;
437 xfs_ino_t ino;
438 xfs_sb_t *sbp = &mp->m_sb;
439 xfs_ino_t max_inum = XFS_MAXINUMBER_32;
Dave Chinner8b26c582010-01-11 11:47:48 +0000440 int error = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441
442 /* Check to see if the filesystem can overflow 32 bit inodes */
443 agino = XFS_OFFBNO_TO_AGINO(mp, sbp->sb_agblocks - 1, 0);
444 ino = XFS_AGINO_TO_INO(mp, agcount - 1, agino);
445
Dave Chinner1c1c6eb2010-01-11 11:47:44 +0000446 /*
447 * Walk the current per-ag tree so we don't try to initialise AGs
448 * that already exist (growfs case). Allocate and insert all the
449 * AGs we don't find ready for initialisation.
450 */
451 for (index = 0; index < agcount; index++) {
452 pag = xfs_perag_get(mp, index);
453 if (pag) {
454 xfs_perag_put(pag);
455 continue;
456 }
Dave Chinner8b26c582010-01-11 11:47:48 +0000457 if (!first_initialised)
458 first_initialised = index;
Dave Chinner1c1c6eb2010-01-11 11:47:44 +0000459 pag = kmem_zalloc(sizeof(*pag), KM_MAYFAIL);
460 if (!pag)
Dave Chinner8b26c582010-01-11 11:47:48 +0000461 goto out_unwind;
Dave Chinner1c1c6eb2010-01-11 11:47:44 +0000462 if (radix_tree_preload(GFP_NOFS))
Dave Chinner8b26c582010-01-11 11:47:48 +0000463 goto out_unwind;
Dave Chinner1c1c6eb2010-01-11 11:47:44 +0000464 spin_lock(&mp->m_perag_lock);
465 if (radix_tree_insert(&mp->m_perag_tree, index, pag)) {
466 BUG();
467 spin_unlock(&mp->m_perag_lock);
Dave Chinner8b26c582010-01-11 11:47:48 +0000468 radix_tree_preload_end();
469 error = -EEXIST;
470 goto out_unwind;
Dave Chinner1c1c6eb2010-01-11 11:47:44 +0000471 }
Dave Chinner0fa800f2010-01-11 11:47:46 +0000472 pag->pag_agno = index;
473 pag->pag_mount = mp;
Dave Chinner1c1c6eb2010-01-11 11:47:44 +0000474 spin_unlock(&mp->m_perag_lock);
475 radix_tree_preload_end();
476 }
477
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478 /* Clear the mount flag if no inode can overflow 32 bits
479 * on this filesystem, or if specifically requested..
480 */
Christoph Hellwigbd186aa2007-08-30 17:21:12 +1000481 if ((mp->m_flags & XFS_MOUNT_SMALL_INUMS) && ino > max_inum) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482 mp->m_flags |= XFS_MOUNT_32BITINODES;
483 } else {
484 mp->m_flags &= ~XFS_MOUNT_32BITINODES;
485 }
486
487 /* If we can overflow then setup the ag headers accordingly */
488 if (mp->m_flags & XFS_MOUNT_32BITINODES) {
489 /* Calculate how much should be reserved for inodes to
490 * meet the max inode percentage.
491 */
492 if (mp->m_maxicount) {
493 __uint64_t icount;
494
495 icount = sbp->sb_dblocks * sbp->sb_imax_pct;
496 do_div(icount, 100);
497 icount += sbp->sb_agblocks - 1;
Eric Sandeena749ee82005-11-02 15:13:42 +1100498 do_div(icount, sbp->sb_agblocks);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499 max_metadata = icount;
500 } else {
501 max_metadata = agcount;
502 }
503 for (index = 0; index < agcount; index++) {
504 ino = XFS_AGINO_TO_INO(mp, index, agino);
505 if (ino > max_inum) {
506 index++;
507 break;
508 }
509
Nathan Scottc41564b2006-03-29 08:55:14 +1000510 /* This ag is preferred for inodes */
Dave Chinner44b56e02010-01-11 11:47:43 +0000511 pag = xfs_perag_get(mp, index);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512 pag->pagi_inodeok = 1;
513 if (index < max_metadata)
514 pag->pagf_metadata = 1;
David Chinnerda353b02007-08-28 14:00:13 +1000515 xfs_initialize_perag_icache(pag);
Dave Chinner44b56e02010-01-11 11:47:43 +0000516 xfs_perag_put(pag);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517 }
518 } else {
519 /* Setup default behavior for smaller filesystems */
520 for (index = 0; index < agcount; index++) {
Dave Chinner44b56e02010-01-11 11:47:43 +0000521 pag = xfs_perag_get(mp, index);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522 pag->pagi_inodeok = 1;
David Chinnerda353b02007-08-28 14:00:13 +1000523 xfs_initialize_perag_icache(pag);
Dave Chinner44b56e02010-01-11 11:47:43 +0000524 xfs_perag_put(pag);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525 }
526 }
Dave Chinner1c1c6eb2010-01-11 11:47:44 +0000527 if (maxagi)
528 *maxagi = index;
529 return 0;
Dave Chinner8b26c582010-01-11 11:47:48 +0000530
531out_unwind:
532 kmem_free(pag);
533 for (; index > first_initialised; index--) {
534 pag = radix_tree_delete(&mp->m_perag_tree, index);
535 kmem_free(pag);
536 }
537 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538}
539
Christoph Hellwig2bdf7cd2007-08-28 13:58:06 +1000540void
541xfs_sb_from_disk(
542 xfs_sb_t *to,
543 xfs_dsb_t *from)
544{
545 to->sb_magicnum = be32_to_cpu(from->sb_magicnum);
546 to->sb_blocksize = be32_to_cpu(from->sb_blocksize);
547 to->sb_dblocks = be64_to_cpu(from->sb_dblocks);
548 to->sb_rblocks = be64_to_cpu(from->sb_rblocks);
549 to->sb_rextents = be64_to_cpu(from->sb_rextents);
550 memcpy(&to->sb_uuid, &from->sb_uuid, sizeof(to->sb_uuid));
551 to->sb_logstart = be64_to_cpu(from->sb_logstart);
552 to->sb_rootino = be64_to_cpu(from->sb_rootino);
553 to->sb_rbmino = be64_to_cpu(from->sb_rbmino);
554 to->sb_rsumino = be64_to_cpu(from->sb_rsumino);
555 to->sb_rextsize = be32_to_cpu(from->sb_rextsize);
556 to->sb_agblocks = be32_to_cpu(from->sb_agblocks);
557 to->sb_agcount = be32_to_cpu(from->sb_agcount);
558 to->sb_rbmblocks = be32_to_cpu(from->sb_rbmblocks);
559 to->sb_logblocks = be32_to_cpu(from->sb_logblocks);
560 to->sb_versionnum = be16_to_cpu(from->sb_versionnum);
561 to->sb_sectsize = be16_to_cpu(from->sb_sectsize);
562 to->sb_inodesize = be16_to_cpu(from->sb_inodesize);
563 to->sb_inopblock = be16_to_cpu(from->sb_inopblock);
564 memcpy(&to->sb_fname, &from->sb_fname, sizeof(to->sb_fname));
565 to->sb_blocklog = from->sb_blocklog;
566 to->sb_sectlog = from->sb_sectlog;
567 to->sb_inodelog = from->sb_inodelog;
568 to->sb_inopblog = from->sb_inopblog;
569 to->sb_agblklog = from->sb_agblklog;
570 to->sb_rextslog = from->sb_rextslog;
571 to->sb_inprogress = from->sb_inprogress;
572 to->sb_imax_pct = from->sb_imax_pct;
573 to->sb_icount = be64_to_cpu(from->sb_icount);
574 to->sb_ifree = be64_to_cpu(from->sb_ifree);
575 to->sb_fdblocks = be64_to_cpu(from->sb_fdblocks);
576 to->sb_frextents = be64_to_cpu(from->sb_frextents);
577 to->sb_uquotino = be64_to_cpu(from->sb_uquotino);
578 to->sb_gquotino = be64_to_cpu(from->sb_gquotino);
579 to->sb_qflags = be16_to_cpu(from->sb_qflags);
580 to->sb_flags = from->sb_flags;
581 to->sb_shared_vn = from->sb_shared_vn;
582 to->sb_inoalignmt = be32_to_cpu(from->sb_inoalignmt);
583 to->sb_unit = be32_to_cpu(from->sb_unit);
584 to->sb_width = be32_to_cpu(from->sb_width);
585 to->sb_dirblklog = from->sb_dirblklog;
586 to->sb_logsectlog = from->sb_logsectlog;
587 to->sb_logsectsize = be16_to_cpu(from->sb_logsectsize);
588 to->sb_logsunit = be32_to_cpu(from->sb_logsunit);
589 to->sb_features2 = be32_to_cpu(from->sb_features2);
David Chinneree1c0902008-03-06 13:45:50 +1100590 to->sb_bad_features2 = be32_to_cpu(from->sb_bad_features2);
Christoph Hellwig2bdf7cd2007-08-28 13:58:06 +1000591}
592
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593/*
Christoph Hellwig2bdf7cd2007-08-28 13:58:06 +1000594 * Copy in core superblock to ondisk one.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595 *
Christoph Hellwig2bdf7cd2007-08-28 13:58:06 +1000596 * The fields argument is mask of superblock fields to copy.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597 */
598void
Christoph Hellwig2bdf7cd2007-08-28 13:58:06 +1000599xfs_sb_to_disk(
600 xfs_dsb_t *to,
601 xfs_sb_t *from,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602 __int64_t fields)
603{
Christoph Hellwig2bdf7cd2007-08-28 13:58:06 +1000604 xfs_caddr_t to_ptr = (xfs_caddr_t)to;
605 xfs_caddr_t from_ptr = (xfs_caddr_t)from;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606 xfs_sb_field_t f;
607 int first;
608 int size;
609
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610 ASSERT(fields);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611 if (!fields)
612 return;
613
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614 while (fields) {
615 f = (xfs_sb_field_t)xfs_lowbit64((__uint64_t)fields);
616 first = xfs_sb_info[f].offset;
617 size = xfs_sb_info[f + 1].offset - first;
618
619 ASSERT(xfs_sb_info[f].type == 0 || xfs_sb_info[f].type == 1);
620
621 if (size == 1 || xfs_sb_info[f].type == 1) {
Christoph Hellwig2bdf7cd2007-08-28 13:58:06 +1000622 memcpy(to_ptr + first, from_ptr + first, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623 } else {
624 switch (size) {
625 case 2:
Christoph Hellwig2bdf7cd2007-08-28 13:58:06 +1000626 *(__be16 *)(to_ptr + first) =
627 cpu_to_be16(*(__u16 *)(from_ptr + first));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628 break;
629 case 4:
Christoph Hellwig2bdf7cd2007-08-28 13:58:06 +1000630 *(__be32 *)(to_ptr + first) =
631 cpu_to_be32(*(__u32 *)(from_ptr + first));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632 break;
633 case 8:
Christoph Hellwig2bdf7cd2007-08-28 13:58:06 +1000634 *(__be64 *)(to_ptr + first) =
635 cpu_to_be64(*(__u64 *)(from_ptr + first));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636 break;
637 default:
638 ASSERT(0);
639 }
640 }
641
642 fields &= ~(1LL << f);
643 }
644}
645
646/*
647 * xfs_readsb
648 *
649 * Does the initial read of the superblock.
650 */
651int
Nathan Scott764d1f82006-03-31 13:04:17 +1000652xfs_readsb(xfs_mount_t *mp, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653{
654 unsigned int sector_size;
655 unsigned int extra_flags;
656 xfs_buf_t *bp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657 int error;
658
659 ASSERT(mp->m_sb_bp == NULL);
660 ASSERT(mp->m_ddev_targp != NULL);
661
662 /*
663 * Allocate a (locked) buffer to hold the superblock.
664 * This will be kept around at all times to optimize
665 * access to the superblock.
666 */
667 sector_size = xfs_getsize_buftarg(mp->m_ddev_targp);
Christoph Hellwig0cadda12010-01-19 09:56:44 +0000668 extra_flags = XBF_LOCK | XBF_FS_MANAGED | XBF_MAPPED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669
Christoph Hellwig6ad112b2009-11-24 18:02:23 +0000670 bp = xfs_buf_read(mp->m_ddev_targp, XFS_SB_DADDR, BTOBB(sector_size),
671 extra_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672 if (!bp || XFS_BUF_ISERROR(bp)) {
Nathan Scott764d1f82006-03-31 13:04:17 +1000673 xfs_fs_mount_cmn_err(flags, "SB read failed");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674 error = bp ? XFS_BUF_GETERROR(bp) : ENOMEM;
675 goto fail;
676 }
677 ASSERT(XFS_BUF_ISBUSY(bp));
678 ASSERT(XFS_BUF_VALUSEMA(bp) <= 0);
679
680 /*
681 * Initialize the mount structure from the superblock.
682 * But first do some basic consistency checking.
683 */
Christoph Hellwig2bdf7cd2007-08-28 13:58:06 +1000684 xfs_sb_from_disk(&mp->m_sb, XFS_BUF_TO_SBP(bp));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685
Nathan Scott764d1f82006-03-31 13:04:17 +1000686 error = xfs_mount_validate_sb(mp, &(mp->m_sb), flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687 if (error) {
Nathan Scott764d1f82006-03-31 13:04:17 +1000688 xfs_fs_mount_cmn_err(flags, "SB validate failed");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689 goto fail;
690 }
691
692 /*
693 * We must be able to do sector-sized and sector-aligned IO.
694 */
695 if (sector_size > mp->m_sb.sb_sectsize) {
Nathan Scott764d1f82006-03-31 13:04:17 +1000696 xfs_fs_mount_cmn_err(flags,
697 "device supports only %u byte sectors (not %u)",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698 sector_size, mp->m_sb.sb_sectsize);
699 error = ENOSYS;
700 goto fail;
701 }
702
703 /*
704 * If device sector size is smaller than the superblock size,
705 * re-read the superblock so the buffer is correctly sized.
706 */
707 if (sector_size < mp->m_sb.sb_sectsize) {
708 XFS_BUF_UNMANAGE(bp);
709 xfs_buf_relse(bp);
710 sector_size = mp->m_sb.sb_sectsize;
Christoph Hellwig6ad112b2009-11-24 18:02:23 +0000711 bp = xfs_buf_read(mp->m_ddev_targp, XFS_SB_DADDR,
712 BTOBB(sector_size), extra_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713 if (!bp || XFS_BUF_ISERROR(bp)) {
Nathan Scott764d1f82006-03-31 13:04:17 +1000714 xfs_fs_mount_cmn_err(flags, "SB re-read failed");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715 error = bp ? XFS_BUF_GETERROR(bp) : ENOMEM;
716 goto fail;
717 }
718 ASSERT(XFS_BUF_ISBUSY(bp));
719 ASSERT(XFS_BUF_VALUSEMA(bp) <= 0);
720 }
721
Lachlan McIlroy5478eea2007-02-10 18:36:29 +1100722 /* Initialize per-cpu counters */
723 xfs_icsb_reinit_counters(mp);
David Chinner8d280b92006-03-14 13:13:09 +1100724
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725 mp->m_sb_bp = bp;
726 xfs_buf_relse(bp);
727 ASSERT(XFS_BUF_VALUSEMA(bp) > 0);
728 return 0;
729
730 fail:
731 if (bp) {
732 XFS_BUF_UNMANAGE(bp);
733 xfs_buf_relse(bp);
734 }
735 return error;
736}
737
738
739/*
740 * xfs_mount_common
741 *
742 * Mount initialization code establishing various mount
743 * fields from the superblock associated with the given
744 * mount structure
745 */
Christoph Hellwigba0f32d2005-06-21 15:36:52 +1000746STATIC void
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747xfs_mount_common(xfs_mount_t *mp, xfs_sb_t *sbp)
748{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749 mp->m_agfrotor = mp->m_agirotor = 0;
Eric Sandeen007c61c2007-10-11 17:43:56 +1000750 spin_lock_init(&mp->m_agirotor_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751 mp->m_maxagi = mp->m_sb.sb_agcount;
752 mp->m_blkbit_log = sbp->sb_blocklog + XFS_NBBYLOG;
753 mp->m_blkbb_log = sbp->sb_blocklog - BBSHIFT;
754 mp->m_sectbb_log = sbp->sb_sectlog - BBSHIFT;
755 mp->m_agno_log = xfs_highbit32(sbp->sb_agcount - 1) + 1;
756 mp->m_agino_log = sbp->sb_inopblog + sbp->sb_agblklog;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757 mp->m_blockmask = sbp->sb_blocksize - 1;
758 mp->m_blockwsize = sbp->sb_blocksize >> XFS_WORDLOG;
759 mp->m_blockwmask = mp->m_blockwsize - 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760
Christoph Hellwig60197e82008-10-30 17:11:19 +1100761 mp->m_alloc_mxr[0] = xfs_allocbt_maxrecs(mp, sbp->sb_blocksize, 1);
762 mp->m_alloc_mxr[1] = xfs_allocbt_maxrecs(mp, sbp->sb_blocksize, 0);
763 mp->m_alloc_mnr[0] = mp->m_alloc_mxr[0] / 2;
764 mp->m_alloc_mnr[1] = mp->m_alloc_mxr[1] / 2;
765
766 mp->m_inobt_mxr[0] = xfs_inobt_maxrecs(mp, sbp->sb_blocksize, 1);
767 mp->m_inobt_mxr[1] = xfs_inobt_maxrecs(mp, sbp->sb_blocksize, 0);
768 mp->m_inobt_mnr[0] = mp->m_inobt_mxr[0] / 2;
769 mp->m_inobt_mnr[1] = mp->m_inobt_mxr[1] / 2;
770
771 mp->m_bmap_dmxr[0] = xfs_bmbt_maxrecs(mp, sbp->sb_blocksize, 1);
772 mp->m_bmap_dmxr[1] = xfs_bmbt_maxrecs(mp, sbp->sb_blocksize, 0);
773 mp->m_bmap_dmnr[0] = mp->m_bmap_dmxr[0] / 2;
774 mp->m_bmap_dmnr[1] = mp->m_bmap_dmxr[1] / 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775
776 mp->m_bsize = XFS_FSB_TO_BB(mp, 1);
777 mp->m_ialloc_inos = (int)MAX((__uint16_t)XFS_INODES_PER_CHUNK,
778 sbp->sb_inopblock);
779 mp->m_ialloc_blks = mp->m_ialloc_inos >> sbp->sb_inopblog;
780}
David Chinner92821e22007-05-24 15:26:31 +1000781
782/*
783 * xfs_initialize_perag_data
784 *
785 * Read in each per-ag structure so we can count up the number of
786 * allocated inodes, free inodes and used filesystem blocks as this
787 * information is no longer persistent in the superblock. Once we have
788 * this information, write it into the in-core superblock structure.
789 */
790STATIC int
791xfs_initialize_perag_data(xfs_mount_t *mp, xfs_agnumber_t agcount)
792{
793 xfs_agnumber_t index;
794 xfs_perag_t *pag;
795 xfs_sb_t *sbp = &mp->m_sb;
796 uint64_t ifree = 0;
797 uint64_t ialloc = 0;
798 uint64_t bfree = 0;
799 uint64_t bfreelst = 0;
800 uint64_t btree = 0;
801 int error;
David Chinner92821e22007-05-24 15:26:31 +1000802
803 for (index = 0; index < agcount; index++) {
804 /*
805 * read the agf, then the agi. This gets us
Malcolm Parsons9da096f2009-03-29 09:55:42 +0200806 * all the information we need and populates the
David Chinner92821e22007-05-24 15:26:31 +1000807 * per-ag structures for us.
808 */
809 error = xfs_alloc_pagf_init(mp, NULL, index, 0);
810 if (error)
811 return error;
812
813 error = xfs_ialloc_pagi_init(mp, NULL, index);
814 if (error)
815 return error;
Dave Chinner44b56e02010-01-11 11:47:43 +0000816 pag = xfs_perag_get(mp, index);
David Chinner92821e22007-05-24 15:26:31 +1000817 ifree += pag->pagi_freecount;
818 ialloc += pag->pagi_count;
819 bfree += pag->pagf_freeblks;
820 bfreelst += pag->pagf_flcount;
821 btree += pag->pagf_btreeblks;
Dave Chinner44b56e02010-01-11 11:47:43 +0000822 xfs_perag_put(pag);
David Chinner92821e22007-05-24 15:26:31 +1000823 }
824 /*
825 * Overwrite incore superblock counters with just-read data
826 */
Eric Sandeen3685c2a2007-10-11 17:42:32 +1000827 spin_lock(&mp->m_sb_lock);
David Chinner92821e22007-05-24 15:26:31 +1000828 sbp->sb_ifree = ifree;
829 sbp->sb_icount = ialloc;
830 sbp->sb_fdblocks = bfree + bfreelst + btree;
Eric Sandeen3685c2a2007-10-11 17:42:32 +1000831 spin_unlock(&mp->m_sb_lock);
David Chinner92821e22007-05-24 15:26:31 +1000832
833 /* Fixup the per-cpu counters as well. */
834 xfs_icsb_reinit_counters(mp);
835
836 return 0;
837}
838
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839/*
Eric Sandeen0771fb42007-10-12 11:03:40 +1000840 * Update alignment values based on mount options and sb values
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841 */
Eric Sandeen0771fb42007-10-12 11:03:40 +1000842STATIC int
Christoph Hellwig7884bc82009-01-19 02:04:07 +0100843xfs_update_alignment(xfs_mount_t *mp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845 xfs_sb_t *sbp = &(mp->m_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846
Christoph Hellwig42490232008-08-13 16:49:32 +1000847 if (mp->m_dalign) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848 /*
849 * If stripe unit and stripe width are not multiples
850 * of the fs blocksize turn off alignment.
851 */
852 if ((BBTOB(mp->m_dalign) & mp->m_blockmask) ||
853 (BBTOB(mp->m_swidth) & mp->m_blockmask)) {
854 if (mp->m_flags & XFS_MOUNT_RETERR) {
855 cmn_err(CE_WARN,
856 "XFS: alignment check 1 failed");
Eric Sandeen0771fb42007-10-12 11:03:40 +1000857 return XFS_ERROR(EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858 }
859 mp->m_dalign = mp->m_swidth = 0;
860 } else {
861 /*
862 * Convert the stripe unit and width to FSBs.
863 */
864 mp->m_dalign = XFS_BB_TO_FSBT(mp, mp->m_dalign);
865 if (mp->m_dalign && (sbp->sb_agblocks % mp->m_dalign)) {
866 if (mp->m_flags & XFS_MOUNT_RETERR) {
Eric Sandeen0771fb42007-10-12 11:03:40 +1000867 return XFS_ERROR(EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868 }
869 xfs_fs_cmn_err(CE_WARN, mp,
870"stripe alignment turned off: sunit(%d)/swidth(%d) incompatible with agsize(%d)",
871 mp->m_dalign, mp->m_swidth,
872 sbp->sb_agblocks);
873
874 mp->m_dalign = 0;
875 mp->m_swidth = 0;
876 } else if (mp->m_dalign) {
877 mp->m_swidth = XFS_BB_TO_FSBT(mp, mp->m_swidth);
878 } else {
879 if (mp->m_flags & XFS_MOUNT_RETERR) {
880 xfs_fs_cmn_err(CE_WARN, mp,
881"stripe alignment turned off: sunit(%d) less than bsize(%d)",
882 mp->m_dalign,
883 mp->m_blockmask +1);
Eric Sandeen0771fb42007-10-12 11:03:40 +1000884 return XFS_ERROR(EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885 }
886 mp->m_swidth = 0;
887 }
888 }
889
890 /*
891 * Update superblock with new values
892 * and log changes
893 */
Eric Sandeen62118702008-03-06 13:44:28 +1100894 if (xfs_sb_version_hasdalign(sbp)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895 if (sbp->sb_unit != mp->m_dalign) {
896 sbp->sb_unit = mp->m_dalign;
Christoph Hellwig7884bc82009-01-19 02:04:07 +0100897 mp->m_update_flags |= XFS_SB_UNIT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898 }
899 if (sbp->sb_width != mp->m_swidth) {
900 sbp->sb_width = mp->m_swidth;
Christoph Hellwig7884bc82009-01-19 02:04:07 +0100901 mp->m_update_flags |= XFS_SB_WIDTH;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902 }
903 }
904 } else if ((mp->m_flags & XFS_MOUNT_NOALIGN) != XFS_MOUNT_NOALIGN &&
Eric Sandeen62118702008-03-06 13:44:28 +1100905 xfs_sb_version_hasdalign(&mp->m_sb)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906 mp->m_dalign = sbp->sb_unit;
907 mp->m_swidth = sbp->sb_width;
908 }
909
Eric Sandeen0771fb42007-10-12 11:03:40 +1000910 return 0;
911}
912
913/*
914 * Set the maximum inode count for this filesystem
915 */
916STATIC void
917xfs_set_maxicount(xfs_mount_t *mp)
918{
919 xfs_sb_t *sbp = &(mp->m_sb);
920 __uint64_t icount;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921
922 if (sbp->sb_imax_pct) {
Eric Sandeen0771fb42007-10-12 11:03:40 +1000923 /*
924 * Make sure the maximum inode count is a multiple
925 * of the units we allocate inodes in.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700926 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927 icount = sbp->sb_dblocks * sbp->sb_imax_pct;
928 do_div(icount, 100);
929 do_div(icount, mp->m_ialloc_blks);
930 mp->m_maxicount = (icount * mp->m_ialloc_blks) <<
931 sbp->sb_inopblog;
Eric Sandeen0771fb42007-10-12 11:03:40 +1000932 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933 mp->m_maxicount = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934 }
Eric Sandeen0771fb42007-10-12 11:03:40 +1000935}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936
Eric Sandeen0771fb42007-10-12 11:03:40 +1000937/*
938 * Set the default minimum read and write sizes unless
939 * already specified in a mount option.
940 * We use smaller I/O sizes when the file system
941 * is being used for NFS service (wsync mount option).
942 */
943STATIC void
944xfs_set_rw_sizes(xfs_mount_t *mp)
945{
946 xfs_sb_t *sbp = &(mp->m_sb);
947 int readio_log, writeio_log;
948
Linus Torvalds1da177e2005-04-16 15:20:36 -0700949 if (!(mp->m_flags & XFS_MOUNT_DFLT_IOSIZE)) {
950 if (mp->m_flags & XFS_MOUNT_WSYNC) {
951 readio_log = XFS_WSYNC_READIO_LOG;
952 writeio_log = XFS_WSYNC_WRITEIO_LOG;
953 } else {
954 readio_log = XFS_READIO_LOG_LARGE;
955 writeio_log = XFS_WRITEIO_LOG_LARGE;
956 }
957 } else {
958 readio_log = mp->m_readio_log;
959 writeio_log = mp->m_writeio_log;
960 }
961
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962 if (sbp->sb_blocklog > readio_log) {
963 mp->m_readio_log = sbp->sb_blocklog;
964 } else {
965 mp->m_readio_log = readio_log;
966 }
967 mp->m_readio_blocks = 1 << (mp->m_readio_log - sbp->sb_blocklog);
968 if (sbp->sb_blocklog > writeio_log) {
969 mp->m_writeio_log = sbp->sb_blocklog;
970 } else {
971 mp->m_writeio_log = writeio_log;
972 }
973 mp->m_writeio_blocks = 1 << (mp->m_writeio_log - sbp->sb_blocklog);
Eric Sandeen0771fb42007-10-12 11:03:40 +1000974}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700975
Eric Sandeen0771fb42007-10-12 11:03:40 +1000976/*
977 * Set whether we're using inode alignment.
978 */
979STATIC void
980xfs_set_inoalignment(xfs_mount_t *mp)
981{
Eric Sandeen62118702008-03-06 13:44:28 +1100982 if (xfs_sb_version_hasalign(&mp->m_sb) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983 mp->m_sb.sb_inoalignmt >=
984 XFS_B_TO_FSBT(mp, mp->m_inode_cluster_size))
985 mp->m_inoalign_mask = mp->m_sb.sb_inoalignmt - 1;
986 else
987 mp->m_inoalign_mask = 0;
988 /*
989 * If we are using stripe alignment, check whether
990 * the stripe unit is a multiple of the inode alignment
991 */
992 if (mp->m_dalign && mp->m_inoalign_mask &&
993 !(mp->m_dalign & mp->m_inoalign_mask))
994 mp->m_sinoalign = mp->m_dalign;
995 else
996 mp->m_sinoalign = 0;
Eric Sandeen0771fb42007-10-12 11:03:40 +1000997}
998
999/*
1000 * Check that the data (and log if separate) are an ok size.
1001 */
1002STATIC int
Christoph Hellwig42490232008-08-13 16:49:32 +10001003xfs_check_sizes(xfs_mount_t *mp)
Eric Sandeen0771fb42007-10-12 11:03:40 +10001004{
1005 xfs_buf_t *bp;
1006 xfs_daddr_t d;
1007 int error;
1008
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009 d = (xfs_daddr_t)XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks);
1010 if (XFS_BB_TO_FSB(mp, d) != mp->m_sb.sb_dblocks) {
1011 cmn_err(CE_WARN, "XFS: size check 1 failed");
Eric Sandeen0771fb42007-10-12 11:03:40 +10001012 return XFS_ERROR(E2BIG);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001013 }
1014 error = xfs_read_buf(mp, mp->m_ddev_targp,
1015 d - XFS_FSS_TO_BB(mp, 1),
1016 XFS_FSS_TO_BB(mp, 1), 0, &bp);
1017 if (!error) {
1018 xfs_buf_relse(bp);
1019 } else {
1020 cmn_err(CE_WARN, "XFS: size check 2 failed");
Eric Sandeen0771fb42007-10-12 11:03:40 +10001021 if (error == ENOSPC)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022 error = XFS_ERROR(E2BIG);
Eric Sandeen0771fb42007-10-12 11:03:40 +10001023 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001024 }
1025
Christoph Hellwig42490232008-08-13 16:49:32 +10001026 if (mp->m_logdev_targp != mp->m_ddev_targp) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001027 d = (xfs_daddr_t)XFS_FSB_TO_BB(mp, mp->m_sb.sb_logblocks);
1028 if (XFS_BB_TO_FSB(mp, d) != mp->m_sb.sb_logblocks) {
1029 cmn_err(CE_WARN, "XFS: size check 3 failed");
Eric Sandeen0771fb42007-10-12 11:03:40 +10001030 return XFS_ERROR(E2BIG);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001031 }
1032 error = xfs_read_buf(mp, mp->m_logdev_targp,
1033 d - XFS_FSB_TO_BB(mp, 1),
1034 XFS_FSB_TO_BB(mp, 1), 0, &bp);
1035 if (!error) {
1036 xfs_buf_relse(bp);
1037 } else {
1038 cmn_err(CE_WARN, "XFS: size check 3 failed");
Eric Sandeen0771fb42007-10-12 11:03:40 +10001039 if (error == ENOSPC)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040 error = XFS_ERROR(E2BIG);
Eric Sandeen0771fb42007-10-12 11:03:40 +10001041 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001042 }
1043 }
Eric Sandeen0771fb42007-10-12 11:03:40 +10001044 return 0;
1045}
1046
1047/*
Christoph Hellwig7d095252009-06-08 15:33:32 +02001048 * Clear the quotaflags in memory and in the superblock.
1049 */
1050int
1051xfs_mount_reset_sbqflags(
1052 struct xfs_mount *mp)
1053{
1054 int error;
1055 struct xfs_trans *tp;
1056
1057 mp->m_qflags = 0;
1058
1059 /*
1060 * It is OK to look at sb_qflags here in mount path,
1061 * without m_sb_lock.
1062 */
1063 if (mp->m_sb.sb_qflags == 0)
1064 return 0;
1065 spin_lock(&mp->m_sb_lock);
1066 mp->m_sb.sb_qflags = 0;
1067 spin_unlock(&mp->m_sb_lock);
1068
1069 /*
1070 * If the fs is readonly, let the incore superblock run
1071 * with quotas off but don't flush the update out to disk
1072 */
1073 if (mp->m_flags & XFS_MOUNT_RDONLY)
1074 return 0;
1075
1076#ifdef QUOTADEBUG
1077 xfs_fs_cmn_err(CE_NOTE, mp, "Writing superblock quota changes");
1078#endif
1079
1080 tp = xfs_trans_alloc(mp, XFS_TRANS_QM_SBCHANGE);
1081 error = xfs_trans_reserve(tp, 0, mp->m_sb.sb_sectsize + 128, 0, 0,
1082 XFS_DEFAULT_LOG_COUNT);
1083 if (error) {
1084 xfs_trans_cancel(tp, 0);
1085 xfs_fs_cmn_err(CE_ALERT, mp,
1086 "xfs_mount_reset_sbqflags: Superblock update failed!");
1087 return error;
1088 }
1089
1090 xfs_mod_sb(tp, XFS_SB_QFLAGS);
1091 return xfs_trans_commit(tp, 0);
1092}
1093
Eric Sandeend5db0f92010-02-05 22:59:53 +00001094__uint64_t
1095xfs_default_resblks(xfs_mount_t *mp)
1096{
1097 __uint64_t resblks;
1098
1099 /*
Dave Chinner8babd8a2010-03-04 01:46:25 +00001100 * We default to 5% or 8192 fsbs of space reserved, whichever is
1101 * smaller. This is intended to cover concurrent allocation
1102 * transactions when we initially hit enospc. These each require a 4
1103 * block reservation. Hence by default we cover roughly 2000 concurrent
1104 * allocation reservations.
Eric Sandeend5db0f92010-02-05 22:59:53 +00001105 */
1106 resblks = mp->m_sb.sb_dblocks;
1107 do_div(resblks, 20);
Dave Chinner8babd8a2010-03-04 01:46:25 +00001108 resblks = min_t(__uint64_t, resblks, 8192);
Eric Sandeend5db0f92010-02-05 22:59:53 +00001109 return resblks;
1110}
1111
Christoph Hellwig7d095252009-06-08 15:33:32 +02001112/*
Eric Sandeen0771fb42007-10-12 11:03:40 +10001113 * This function does the following on an initial mount of a file system:
1114 * - reads the superblock from disk and init the mount struct
1115 * - if we're a 32-bit kernel, do a size check on the superblock
1116 * so we don't mount terabyte filesystems
1117 * - init mount struct realtime fields
1118 * - allocate inode hash table for fs
1119 * - init directory manager
1120 * - perform recovery and init the log manager
1121 */
1122int
1123xfs_mountfs(
Christoph Hellwig42490232008-08-13 16:49:32 +10001124 xfs_mount_t *mp)
Eric Sandeen0771fb42007-10-12 11:03:40 +10001125{
1126 xfs_sb_t *sbp = &(mp->m_sb);
1127 xfs_inode_t *rip;
Eric Sandeen0771fb42007-10-12 11:03:40 +10001128 __uint64_t resblks;
Christoph Hellwig7d095252009-06-08 15:33:32 +02001129 uint quotamount = 0;
1130 uint quotaflags = 0;
Eric Sandeen0771fb42007-10-12 11:03:40 +10001131 int error = 0;
1132
Eric Sandeen0771fb42007-10-12 11:03:40 +10001133 xfs_mount_common(mp, sbp);
1134
1135 /*
Eric Sandeene6957ea2008-04-10 12:19:34 +10001136 * Check for a mismatched features2 values. Older kernels
1137 * read & wrote into the wrong sb offset for sb_features2
1138 * on some platforms due to xfs_sb_t not being 64bit size aligned
1139 * when sb_features2 was added, which made older superblock
1140 * reading/writing routines swap it as a 64-bit value.
David Chinneree1c0902008-03-06 13:45:50 +11001141 *
Eric Sandeene6957ea2008-04-10 12:19:34 +10001142 * For backwards compatibility, we make both slots equal.
1143 *
1144 * If we detect a mismatched field, we OR the set bits into the
1145 * existing features2 field in case it has already been modified; we
1146 * don't want to lose any features. We then update the bad location
1147 * with the ORed value so that older kernels will see any features2
1148 * flags, and mark the two fields as needing updates once the
1149 * transaction subsystem is online.
David Chinneree1c0902008-03-06 13:45:50 +11001150 */
Eric Sandeene6957ea2008-04-10 12:19:34 +10001151 if (xfs_sb_has_mismatched_features2(sbp)) {
David Chinneree1c0902008-03-06 13:45:50 +11001152 cmn_err(CE_WARN,
1153 "XFS: correcting sb_features alignment problem");
1154 sbp->sb_features2 |= sbp->sb_bad_features2;
Eric Sandeene6957ea2008-04-10 12:19:34 +10001155 sbp->sb_bad_features2 = sbp->sb_features2;
Christoph Hellwig7884bc82009-01-19 02:04:07 +01001156 mp->m_update_flags |= XFS_SB_FEATURES2 | XFS_SB_BAD_FEATURES2;
Eric Sandeene6957ea2008-04-10 12:19:34 +10001157
1158 /*
1159 * Re-check for ATTR2 in case it was found in bad_features2
1160 * slot.
1161 */
Tim Shimmin7c12f292008-04-30 18:15:28 +10001162 if (xfs_sb_version_hasattr2(&mp->m_sb) &&
1163 !(mp->m_flags & XFS_MOUNT_NOATTR2))
Eric Sandeene6957ea2008-04-10 12:19:34 +10001164 mp->m_flags |= XFS_MOUNT_ATTR2;
Tim Shimmin7c12f292008-04-30 18:15:28 +10001165 }
Eric Sandeene6957ea2008-04-10 12:19:34 +10001166
Tim Shimmin7c12f292008-04-30 18:15:28 +10001167 if (xfs_sb_version_hasattr2(&mp->m_sb) &&
1168 (mp->m_flags & XFS_MOUNT_NOATTR2)) {
1169 xfs_sb_version_removeattr2(&mp->m_sb);
Christoph Hellwig7884bc82009-01-19 02:04:07 +01001170 mp->m_update_flags |= XFS_SB_FEATURES2;
Tim Shimmin7c12f292008-04-30 18:15:28 +10001171
1172 /* update sb_versionnum for the clearing of the morebits */
1173 if (!sbp->sb_features2)
Christoph Hellwig7884bc82009-01-19 02:04:07 +01001174 mp->m_update_flags |= XFS_SB_VERSIONNUM;
David Chinneree1c0902008-03-06 13:45:50 +11001175 }
1176
1177 /*
Eric Sandeen0771fb42007-10-12 11:03:40 +10001178 * Check if sb_agblocks is aligned at stripe boundary
1179 * If sb_agblocks is NOT aligned turn off m_dalign since
1180 * allocator alignment is within an ag, therefore ag has
1181 * to be aligned at stripe boundary.
1182 */
Christoph Hellwig7884bc82009-01-19 02:04:07 +01001183 error = xfs_update_alignment(mp);
Eric Sandeen0771fb42007-10-12 11:03:40 +10001184 if (error)
Christoph Hellwigf9057e32009-02-04 09:31:52 +01001185 goto out;
Eric Sandeen0771fb42007-10-12 11:03:40 +10001186
1187 xfs_alloc_compute_maxlevels(mp);
1188 xfs_bmap_compute_maxlevels(mp, XFS_DATA_FORK);
1189 xfs_bmap_compute_maxlevels(mp, XFS_ATTR_FORK);
1190 xfs_ialloc_compute_maxlevels(mp);
1191
1192 xfs_set_maxicount(mp);
1193
1194 mp->m_maxioffset = xfs_max_file_offset(sbp->sb_blocklog);
1195
Christoph Hellwig27174202009-03-30 10:21:31 +02001196 error = xfs_uuid_mount(mp);
1197 if (error)
1198 goto out;
Eric Sandeen0771fb42007-10-12 11:03:40 +10001199
1200 /*
1201 * Set the minimum read and write sizes
1202 */
1203 xfs_set_rw_sizes(mp);
1204
1205 /*
1206 * Set the inode cluster size.
1207 * This may still be overridden by the file system
1208 * block size if it is larger than the chosen cluster size.
1209 */
1210 mp->m_inode_cluster_size = XFS_INODE_BIG_CLUSTER_SIZE;
1211
1212 /*
1213 * Set inode alignment fields
1214 */
1215 xfs_set_inoalignment(mp);
1216
1217 /*
1218 * Check that the data (and log if separate) are an ok size.
1219 */
Christoph Hellwig42490232008-08-13 16:49:32 +10001220 error = xfs_check_sizes(mp);
Eric Sandeen0771fb42007-10-12 11:03:40 +10001221 if (error)
Christoph Hellwigf9057e32009-02-04 09:31:52 +01001222 goto out_remove_uuid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001223
1224 /*
1225 * Initialize realtime fields in the mount structure
1226 */
Eric Sandeen0771fb42007-10-12 11:03:40 +10001227 error = xfs_rtmount_init(mp);
1228 if (error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001229 cmn_err(CE_WARN, "XFS: RT mount failed");
Christoph Hellwigf9057e32009-02-04 09:31:52 +01001230 goto out_remove_uuid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001231 }
1232
1233 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001234 * Copies the low order bits of the timestamp and the randomly
1235 * set "sequence" number out of a UUID.
1236 */
1237 uuid_getnodeuniq(&sbp->sb_uuid, mp->m_fixedfsid);
1238
Linus Torvalds1da177e2005-04-16 15:20:36 -07001239 mp->m_dmevmask = 0; /* not persistent; set after each mount */
1240
Nathan Scottf6c2d1f2006-06-20 13:04:51 +10001241 xfs_dir_mount(mp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001242
1243 /*
1244 * Initialize the attribute manager's entries.
1245 */
1246 mp->m_attr_magicpct = (mp->m_sb.sb_blocksize * 37) / 100;
1247
1248 /*
1249 * Initialize the precomputed transaction reservations values.
1250 */
1251 xfs_trans_init(mp);
1252
1253 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001254 * Allocate and initialize the per-ag data.
1255 */
Dave Chinner1c1c6eb2010-01-11 11:47:44 +00001256 spin_lock_init(&mp->m_perag_lock);
1257 INIT_RADIX_TREE(&mp->m_perag_tree, GFP_NOFS);
1258 error = xfs_initialize_perag(mp, sbp->sb_agcount, &mp->m_maxagi);
1259 if (error) {
1260 cmn_err(CE_WARN, "XFS: Failed per-ag init: %d", error);
Christoph Hellwigf9057e32009-02-04 09:31:52 +01001261 goto out_remove_uuid;
Dave Chinner1c1c6eb2010-01-11 11:47:44 +00001262 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001263
Christoph Hellwigf9057e32009-02-04 09:31:52 +01001264 if (!sbp->sb_logblocks) {
1265 cmn_err(CE_WARN, "XFS: no log defined");
1266 XFS_ERROR_REPORT("xfs_mountfs", XFS_ERRLEVEL_LOW, mp);
1267 error = XFS_ERROR(EFSCORRUPTED);
1268 goto out_free_perag;
1269 }
1270
Linus Torvalds1da177e2005-04-16 15:20:36 -07001271 /*
1272 * log's mount-time initialization. Perform 1st part recovery if needed
1273 */
Christoph Hellwigf9057e32009-02-04 09:31:52 +01001274 error = xfs_log_mount(mp, mp->m_logdev_targp,
1275 XFS_FSB_TO_DADDR(mp, sbp->sb_logstart),
1276 XFS_FSB_TO_BB(mp, sbp->sb_logblocks));
1277 if (error) {
1278 cmn_err(CE_WARN, "XFS: log mount failed");
1279 goto out_free_perag;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001280 }
1281
1282 /*
David Chinner92821e22007-05-24 15:26:31 +10001283 * Now the log is mounted, we know if it was an unclean shutdown or
1284 * not. If it was, with the first phase of recovery has completed, we
1285 * have consistent AG blocks on disk. We have not recovered EFIs yet,
1286 * but they are recovered transactionally in the second recovery phase
1287 * later.
1288 *
1289 * Hence we can safely re-initialise incore superblock counters from
1290 * the per-ag data. These may not be correct if the filesystem was not
1291 * cleanly unmounted, so we need to wait for recovery to finish before
1292 * doing this.
1293 *
1294 * If the filesystem was cleanly unmounted, then we can trust the
1295 * values in the superblock to be correct and we don't need to do
1296 * anything here.
1297 *
1298 * If we are currently making the filesystem, the initialisation will
1299 * fail as the perag data is in an undefined state.
1300 */
David Chinner92821e22007-05-24 15:26:31 +10001301 if (xfs_sb_version_haslazysbcount(&mp->m_sb) &&
1302 !XFS_LAST_UNMOUNT_WAS_CLEAN(mp) &&
1303 !mp->m_sb.sb_inprogress) {
1304 error = xfs_initialize_perag_data(mp, sbp->sb_agcount);
Christoph Hellwigf9057e32009-02-04 09:31:52 +01001305 if (error)
1306 goto out_free_perag;
David Chinner92821e22007-05-24 15:26:31 +10001307 }
Christoph Hellwigf9057e32009-02-04 09:31:52 +01001308
David Chinner92821e22007-05-24 15:26:31 +10001309 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310 * Get and sanity-check the root inode.
1311 * Save the pointer to it in the mount structure.
1312 */
1313 error = xfs_iget(mp, NULL, sbp->sb_rootino, 0, XFS_ILOCK_EXCL, &rip, 0);
1314 if (error) {
1315 cmn_err(CE_WARN, "XFS: failed to read root inode");
Christoph Hellwigf9057e32009-02-04 09:31:52 +01001316 goto out_log_dealloc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001317 }
1318
1319 ASSERT(rip != NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001320
1321 if (unlikely((rip->i_d.di_mode & S_IFMT) != S_IFDIR)) {
1322 cmn_err(CE_WARN, "XFS: corrupted root inode");
Nathan Scottb6574522006-06-09 15:29:40 +10001323 cmn_err(CE_WARN, "Device %s - root %llu is not a directory",
1324 XFS_BUFTARG_NAME(mp->m_ddev_targp),
1325 (unsigned long long)rip->i_ino);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001326 xfs_iunlock(rip, XFS_ILOCK_EXCL);
1327 XFS_ERROR_REPORT("xfs_mountfs_int(2)", XFS_ERRLEVEL_LOW,
1328 mp);
1329 error = XFS_ERROR(EFSCORRUPTED);
Christoph Hellwigf9057e32009-02-04 09:31:52 +01001330 goto out_rele_rip;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001331 }
1332 mp->m_rootip = rip; /* save it */
1333
1334 xfs_iunlock(rip, XFS_ILOCK_EXCL);
1335
1336 /*
1337 * Initialize realtime inode pointers in the mount structure
1338 */
Eric Sandeen0771fb42007-10-12 11:03:40 +10001339 error = xfs_rtmount_inodes(mp);
1340 if (error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341 /*
1342 * Free up the root inode.
1343 */
1344 cmn_err(CE_WARN, "XFS: failed to read RT inodes");
Christoph Hellwigf9057e32009-02-04 09:31:52 +01001345 goto out_rele_rip;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346 }
1347
1348 /*
Christoph Hellwig7884bc82009-01-19 02:04:07 +01001349 * If this is a read-only mount defer the superblock updates until
1350 * the next remount into writeable mode. Otherwise we would never
1351 * perform the update e.g. for the root filesystem.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001352 */
Christoph Hellwig7884bc82009-01-19 02:04:07 +01001353 if (mp->m_update_flags && !(mp->m_flags & XFS_MOUNT_RDONLY)) {
1354 error = xfs_mount_log_sb(mp, mp->m_update_flags);
David Chinnere5720ee2008-04-10 12:21:18 +10001355 if (error) {
1356 cmn_err(CE_WARN, "XFS: failed to write sb changes");
Christoph Hellwigb93b6e42009-02-04 09:33:58 +01001357 goto out_rtunmount;
David Chinnere5720ee2008-04-10 12:21:18 +10001358 }
1359 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001360
1361 /*
1362 * Initialise the XFS quota management subsystem for this mount
1363 */
Christoph Hellwig7d095252009-06-08 15:33:32 +02001364 if (XFS_IS_QUOTA_RUNNING(mp)) {
1365 error = xfs_qm_newmount(mp, &quotamount, &quotaflags);
1366 if (error)
1367 goto out_rtunmount;
1368 } else {
1369 ASSERT(!XFS_IS_QUOTA_ON(mp));
1370
1371 /*
1372 * If a file system had quotas running earlier, but decided to
1373 * mount without -o uquota/pquota/gquota options, revoke the
1374 * quotachecked license.
1375 */
1376 if (mp->m_sb.sb_qflags & XFS_ALL_QUOTA_ACCT) {
1377 cmn_err(CE_NOTE,
1378 "XFS: resetting qflags for filesystem %s",
1379 mp->m_fsname);
1380
1381 error = xfs_mount_reset_sbqflags(mp);
1382 if (error)
1383 return error;
1384 }
1385 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001386
1387 /*
1388 * Finish recovering the file system. This part needed to be
1389 * delayed until after the root and real-time bitmap inodes
1390 * were consistently read in.
1391 */
Christoph Hellwig42490232008-08-13 16:49:32 +10001392 error = xfs_log_mount_finish(mp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001393 if (error) {
1394 cmn_err(CE_WARN, "XFS: log mount finish failed");
Christoph Hellwigb93b6e42009-02-04 09:33:58 +01001395 goto out_rtunmount;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001396 }
1397
1398 /*
1399 * Complete the quota initialisation, post-log-replay component.
1400 */
Christoph Hellwig7d095252009-06-08 15:33:32 +02001401 if (quotamount) {
1402 ASSERT(mp->m_qflags == 0);
1403 mp->m_qflags = quotaflags;
1404
1405 xfs_qm_mount_quotas(mp);
1406 }
1407
David Chinner84e1e992007-06-18 16:50:27 +10001408 /*
1409 * Now we are mounted, reserve a small amount of unused space for
1410 * privileged transactions. This is needed so that transaction
1411 * space required for critical operations can dip into this pool
1412 * when at ENOSPC. This is needed for operations like create with
1413 * attr, unwritten extent conversion at ENOSPC, etc. Data allocations
1414 * are not allowed to use this reserved space.
Dave Chinner8babd8a2010-03-04 01:46:25 +00001415 *
1416 * This may drive us straight to ENOSPC on mount, but that implies
1417 * we were already there on the last unmount. Warn if this occurs.
David Chinner84e1e992007-06-18 16:50:27 +10001418 */
Eric Sandeend5db0f92010-02-05 22:59:53 +00001419 if (!(mp->m_flags & XFS_MOUNT_RDONLY)) {
1420 resblks = xfs_default_resblks(mp);
1421 error = xfs_reserve_blocks(mp, &resblks, NULL);
1422 if (error)
1423 cmn_err(CE_WARN, "XFS: Unable to allocate reserve "
1424 "blocks. Continuing without a reserve pool.");
1425 }
David Chinner84e1e992007-06-18 16:50:27 +10001426
Linus Torvalds1da177e2005-04-16 15:20:36 -07001427 return 0;
1428
Christoph Hellwigb93b6e42009-02-04 09:33:58 +01001429 out_rtunmount:
1430 xfs_rtunmount_inodes(mp);
Christoph Hellwigf9057e32009-02-04 09:31:52 +01001431 out_rele_rip:
Christoph Hellwig43355092008-03-27 18:01:08 +11001432 IRELE(rip);
Christoph Hellwigf9057e32009-02-04 09:31:52 +01001433 out_log_dealloc:
Christoph Hellwig21b699c2009-03-16 08:19:29 +01001434 xfs_log_unmount(mp);
Christoph Hellwigf9057e32009-02-04 09:31:52 +01001435 out_free_perag:
Christoph Hellwigff4f0382008-08-13 16:50:47 +10001436 xfs_free_perag(mp);
Christoph Hellwigf9057e32009-02-04 09:31:52 +01001437 out_remove_uuid:
Christoph Hellwig27174202009-03-30 10:21:31 +02001438 xfs_uuid_unmount(mp);
Christoph Hellwigf9057e32009-02-04 09:31:52 +01001439 out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001440 return error;
1441}
1442
1443/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001444 * This flushes out the inodes,dquots and the superblock, unmounts the
1445 * log and makes sure that incore structures are freed.
1446 */
Christoph Hellwig41b5c2e2008-08-13 16:49:57 +10001447void
1448xfs_unmountfs(
1449 struct xfs_mount *mp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001450{
Christoph Hellwig41b5c2e2008-08-13 16:49:57 +10001451 __uint64_t resblks;
1452 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001453
Christoph Hellwig7d095252009-06-08 15:33:32 +02001454 xfs_qm_unmount_quotas(mp);
Christoph Hellwigb93b6e42009-02-04 09:33:58 +01001455 xfs_rtunmount_inodes(mp);
Christoph Hellwig77508ec2008-08-13 16:49:04 +10001456 IRELE(mp->m_rootip);
1457
David Chinner641c56f2007-06-18 16:50:17 +10001458 /*
1459 * We can potentially deadlock here if we have an inode cluster
Malcolm Parsons9da096f2009-03-29 09:55:42 +02001460 * that has been freed has its buffer still pinned in memory because
David Chinner641c56f2007-06-18 16:50:17 +10001461 * the transaction is still sitting in a iclog. The stale inodes
1462 * on that buffer will have their flush locks held until the
1463 * transaction hits the disk and the callbacks run. the inode
1464 * flush takes the flush lock unconditionally and with nothing to
1465 * push out the iclog we will never get that unlocked. hence we
1466 * need to force the log first.
1467 */
Christoph Hellwiga14a3482010-01-19 09:56:46 +00001468 xfs_log_force(mp, XFS_LOG_SYNC);
Dave Chinnerc8543632010-02-06 12:39:36 +11001469
1470 /*
1471 * Do a delwri reclaim pass first so that as many dirty inodes are
1472 * queued up for IO as possible. Then flush the buffers before making
1473 * a synchronous path to catch all the remaining inodes are reclaimed.
1474 * This makes the reclaim process as quick as possible by avoiding
1475 * synchronous writeout and blocking on inodes already in the delwri
1476 * state as much as possible.
1477 */
1478 xfs_reclaim_inodes(mp, 0);
1479 XFS_bflush(mp->m_ddev_targp);
1480 xfs_reclaim_inodes(mp, SYNC_WAIT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001481
Christoph Hellwig7d095252009-06-08 15:33:32 +02001482 xfs_qm_unmount(mp);
Lachlan McIlroya357a122008-10-30 16:53:25 +11001483
Linus Torvalds1da177e2005-04-16 15:20:36 -07001484 /*
1485 * Flush out the log synchronously so that we know for sure
1486 * that nothing is pinned. This is important because bflush()
1487 * will skip pinned buffers.
1488 */
Christoph Hellwiga14a3482010-01-19 09:56:46 +00001489 xfs_log_force(mp, XFS_LOG_SYNC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001490
1491 xfs_binval(mp->m_ddev_targp);
1492 if (mp->m_rtdev_targp) {
1493 xfs_binval(mp->m_rtdev_targp);
1494 }
1495
David Chinner84e1e992007-06-18 16:50:27 +10001496 /*
1497 * Unreserve any blocks we have so that when we unmount we don't account
1498 * the reserved free space as used. This is really only necessary for
1499 * lazy superblock counting because it trusts the incore superblock
Malcolm Parsons9da096f2009-03-29 09:55:42 +02001500 * counters to be absolutely correct on clean unmount.
David Chinner84e1e992007-06-18 16:50:27 +10001501 *
1502 * We don't bother correcting this elsewhere for lazy superblock
1503 * counting because on mount of an unclean filesystem we reconstruct the
1504 * correct counter value and this is irrelevant.
1505 *
1506 * For non-lazy counter filesystems, this doesn't matter at all because
1507 * we only every apply deltas to the superblock and hence the incore
1508 * value does not matter....
1509 */
1510 resblks = 0;
David Chinner714082b2008-04-10 12:20:03 +10001511 error = xfs_reserve_blocks(mp, &resblks, NULL);
1512 if (error)
1513 cmn_err(CE_WARN, "XFS: Unable to free reserved block pool. "
1514 "Freespace may not be correct on next mount.");
1515
David Chinnere5720ee2008-04-10 12:21:18 +10001516 error = xfs_log_sbcount(mp, 1);
1517 if (error)
1518 cmn_err(CE_WARN, "XFS: Unable to update superblock counters. "
1519 "Freespace may not be correct on next mount.");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001520 xfs_unmountfs_writesb(mp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001521 xfs_unmountfs_wait(mp); /* wait for async bufs */
Christoph Hellwig21b699c2009-03-16 08:19:29 +01001522 xfs_log_unmount_write(mp);
1523 xfs_log_unmount(mp);
Christoph Hellwig27174202009-03-30 10:21:31 +02001524 xfs_uuid_unmount(mp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001525
Christoph Hellwig1550d0b2008-08-13 16:17:37 +10001526#if defined(DEBUG)
Christoph Hellwig0ce4cfd2007-08-30 17:20:53 +10001527 xfs_errortag_clearall(mp, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001528#endif
Christoph Hellwigff4f0382008-08-13 16:50:47 +10001529 xfs_free_perag(mp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001530}
1531
Christoph Hellwigba0f32d2005-06-21 15:36:52 +10001532STATIC void
Linus Torvalds1da177e2005-04-16 15:20:36 -07001533xfs_unmountfs_wait(xfs_mount_t *mp)
1534{
1535 if (mp->m_logdev_targp != mp->m_ddev_targp)
1536 xfs_wait_buftarg(mp->m_logdev_targp);
1537 if (mp->m_rtdev_targp)
1538 xfs_wait_buftarg(mp->m_rtdev_targp);
1539 xfs_wait_buftarg(mp->m_ddev_targp);
1540}
1541
1542int
David Chinner92821e22007-05-24 15:26:31 +10001543xfs_fs_writable(xfs_mount_t *mp)
1544{
Christoph Hellwigb267ce92007-08-30 17:21:30 +10001545 return !(xfs_test_for_freeze(mp) || XFS_FORCED_SHUTDOWN(mp) ||
Christoph Hellwigbd186aa2007-08-30 17:21:12 +10001546 (mp->m_flags & XFS_MOUNT_RDONLY));
David Chinner92821e22007-05-24 15:26:31 +10001547}
1548
1549/*
1550 * xfs_log_sbcount
1551 *
1552 * Called either periodically to keep the on disk superblock values
1553 * roughly up to date or from unmount to make sure the values are
1554 * correct on a clean unmount.
1555 *
1556 * Note this code can be called during the process of freezing, so
1557 * we may need to use the transaction allocator which does not not
1558 * block when the transaction subsystem is in its frozen state.
1559 */
1560int
1561xfs_log_sbcount(
1562 xfs_mount_t *mp,
1563 uint sync)
1564{
1565 xfs_trans_t *tp;
1566 int error;
1567
1568 if (!xfs_fs_writable(mp))
1569 return 0;
1570
Christoph Hellwigd4d90b52008-04-22 17:34:37 +10001571 xfs_icsb_sync_counters(mp, 0);
David Chinner92821e22007-05-24 15:26:31 +10001572
1573 /*
1574 * we don't need to do this if we are updating the superblock
1575 * counters on every modification.
1576 */
1577 if (!xfs_sb_version_haslazysbcount(&mp->m_sb))
1578 return 0;
1579
Christoph Hellwig80641dc2009-10-19 04:00:03 +00001580 tp = _xfs_trans_alloc(mp, XFS_TRANS_SB_COUNT, KM_SLEEP);
David Chinner92821e22007-05-24 15:26:31 +10001581 error = xfs_trans_reserve(tp, 0, mp->m_sb.sb_sectsize + 128, 0, 0,
1582 XFS_DEFAULT_LOG_COUNT);
1583 if (error) {
1584 xfs_trans_cancel(tp, 0);
1585 return error;
1586 }
1587
1588 xfs_mod_sb(tp, XFS_SB_IFREE | XFS_SB_ICOUNT | XFS_SB_FDBLOCKS);
1589 if (sync)
1590 xfs_trans_set_sync(tp);
David Chinnere5720ee2008-04-10 12:21:18 +10001591 error = xfs_trans_commit(tp, 0);
1592 return error;
David Chinner92821e22007-05-24 15:26:31 +10001593}
1594
1595int
Linus Torvalds1da177e2005-04-16 15:20:36 -07001596xfs_unmountfs_writesb(xfs_mount_t *mp)
1597{
1598 xfs_buf_t *sbp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001599 int error = 0;
1600
1601 /*
1602 * skip superblock write if fs is read-only, or
1603 * if we are doing a forced umount.
1604 */
Christoph Hellwigbd186aa2007-08-30 17:21:12 +10001605 if (!((mp->m_flags & XFS_MOUNT_RDONLY) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -07001606 XFS_FORCED_SHUTDOWN(mp))) {
David Chinner8d280b92006-03-14 13:13:09 +11001607
David Chinner92821e22007-05-24 15:26:31 +10001608 sbp = xfs_getsb(mp, 0);
David Chinner8d280b92006-03-14 13:13:09 +11001609
Linus Torvalds1da177e2005-04-16 15:20:36 -07001610 XFS_BUF_UNDONE(sbp);
1611 XFS_BUF_UNREAD(sbp);
1612 XFS_BUF_UNDELAYWRITE(sbp);
1613 XFS_BUF_WRITE(sbp);
1614 XFS_BUF_UNASYNC(sbp);
1615 ASSERT(XFS_BUF_TARGET(sbp) == mp->m_ddev_targp);
1616 xfsbdstrat(mp, sbp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001617 error = xfs_iowait(sbp);
1618 if (error)
1619 xfs_ioerror_alert("xfs_unmountfs_writesb",
1620 mp, sbp, XFS_BUF_ADDR(sbp));
David Chinner92821e22007-05-24 15:26:31 +10001621 xfs_buf_relse(sbp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001622 }
Jesper Juhl014c2542006-01-15 02:37:08 +01001623 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001624}
1625
1626/*
1627 * xfs_mod_sb() can be used to copy arbitrary changes to the
1628 * in-core superblock into the superblock buffer to be logged.
1629 * It does not provide the higher level of locking that is
1630 * needed to protect the in-core superblock from concurrent
1631 * access.
1632 */
1633void
1634xfs_mod_sb(xfs_trans_t *tp, __int64_t fields)
1635{
1636 xfs_buf_t *bp;
1637 int first;
1638 int last;
1639 xfs_mount_t *mp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001640 xfs_sb_field_t f;
1641
1642 ASSERT(fields);
1643 if (!fields)
1644 return;
1645 mp = tp->t_mountp;
1646 bp = xfs_trans_getsb(tp, mp, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001647 first = sizeof(xfs_sb_t);
1648 last = 0;
1649
1650 /* translate/copy */
1651
Christoph Hellwig2bdf7cd2007-08-28 13:58:06 +10001652 xfs_sb_to_disk(XFS_BUF_TO_SBP(bp), &mp->m_sb, fields);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001653
1654 /* find modified range */
Dave Chinner587aa0f2010-01-20 12:04:53 +11001655 f = (xfs_sb_field_t)xfs_highbit64((__uint64_t)fields);
1656 ASSERT((1LL << f) & XFS_SB_MOD_BITS);
1657 last = xfs_sb_info[f + 1].offset - 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001658
1659 f = (xfs_sb_field_t)xfs_lowbit64((__uint64_t)fields);
1660 ASSERT((1LL << f) & XFS_SB_MOD_BITS);
1661 first = xfs_sb_info[f].offset;
1662
Linus Torvalds1da177e2005-04-16 15:20:36 -07001663 xfs_trans_log_buf(tp, bp, first, last);
1664}
Yingping Lud210a282006-06-09 14:55:18 +10001665
Yingping Lud210a282006-06-09 14:55:18 +10001666
Linus Torvalds1da177e2005-04-16 15:20:36 -07001667/*
1668 * xfs_mod_incore_sb_unlocked() is a utility routine common used to apply
1669 * a delta to a specified field in the in-core superblock. Simply
1670 * switch on the field indicated and apply the delta to that field.
1671 * Fields are not allowed to dip below zero, so if the delta would
1672 * do this do not apply it and return EINVAL.
1673 *
Eric Sandeen3685c2a2007-10-11 17:42:32 +10001674 * The m_sb_lock must be held when this routine is called.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001675 */
Eric Sandeend96f8f82009-07-02 00:09:33 -05001676STATIC int
David Chinner20f4ebf2007-02-10 18:36:10 +11001677xfs_mod_incore_sb_unlocked(
1678 xfs_mount_t *mp,
1679 xfs_sb_field_t field,
1680 int64_t delta,
1681 int rsvd)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001682{
1683 int scounter; /* short counter for 32 bit fields */
1684 long long lcounter; /* long counter for 64 bit fields */
1685 long long res_used, rem;
1686
1687 /*
1688 * With the in-core superblock spin lock held, switch
1689 * on the indicated field. Apply the delta to the
1690 * proper field. If the fields value would dip below
1691 * 0, then do not apply the delta and return EINVAL.
1692 */
1693 switch (field) {
1694 case XFS_SBS_ICOUNT:
1695 lcounter = (long long)mp->m_sb.sb_icount;
1696 lcounter += delta;
1697 if (lcounter < 0) {
1698 ASSERT(0);
Jesper Juhl014c2542006-01-15 02:37:08 +01001699 return XFS_ERROR(EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001700 }
1701 mp->m_sb.sb_icount = lcounter;
Jesper Juhl014c2542006-01-15 02:37:08 +01001702 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001703 case XFS_SBS_IFREE:
1704 lcounter = (long long)mp->m_sb.sb_ifree;
1705 lcounter += delta;
1706 if (lcounter < 0) {
1707 ASSERT(0);
Jesper Juhl014c2542006-01-15 02:37:08 +01001708 return XFS_ERROR(EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001709 }
1710 mp->m_sb.sb_ifree = lcounter;
Jesper Juhl014c2542006-01-15 02:37:08 +01001711 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001712 case XFS_SBS_FDBLOCKS:
David Chinner4be536d2006-09-07 14:26:50 +10001713 lcounter = (long long)
1714 mp->m_sb.sb_fdblocks - XFS_ALLOC_SET_ASIDE(mp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001715 res_used = (long long)(mp->m_resblks - mp->m_resblks_avail);
1716
1717 if (delta > 0) { /* Putting blocks back */
1718 if (res_used > delta) {
1719 mp->m_resblks_avail += delta;
1720 } else {
1721 rem = delta - res_used;
1722 mp->m_resblks_avail = mp->m_resblks;
1723 lcounter += rem;
1724 }
1725 } else { /* Taking blocks away */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001726 lcounter += delta;
Dave Chinner8babd8a2010-03-04 01:46:25 +00001727 if (lcounter >= 0) {
1728 mp->m_sb.sb_fdblocks = lcounter +
1729 XFS_ALLOC_SET_ASIDE(mp);
1730 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001731 }
Dave Chinner8babd8a2010-03-04 01:46:25 +00001732
1733 /*
1734 * We are out of blocks, use any available reserved
1735 * blocks if were allowed to.
1736 */
1737 if (!rsvd)
1738 return XFS_ERROR(ENOSPC);
1739
1740 lcounter = (long long)mp->m_resblks_avail + delta;
1741 if (lcounter >= 0) {
1742 mp->m_resblks_avail = lcounter;
1743 return 0;
1744 }
1745 printk_once(KERN_WARNING
1746 "Filesystem \"%s\": reserve blocks depleted! "
1747 "Consider increasing reserve pool size.",
1748 mp->m_fsname);
1749 return XFS_ERROR(ENOSPC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001750 }
1751
David Chinner4be536d2006-09-07 14:26:50 +10001752 mp->m_sb.sb_fdblocks = lcounter + XFS_ALLOC_SET_ASIDE(mp);
Jesper Juhl014c2542006-01-15 02:37:08 +01001753 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001754 case XFS_SBS_FREXTENTS:
1755 lcounter = (long long)mp->m_sb.sb_frextents;
1756 lcounter += delta;
1757 if (lcounter < 0) {
Jesper Juhl014c2542006-01-15 02:37:08 +01001758 return XFS_ERROR(ENOSPC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001759 }
1760 mp->m_sb.sb_frextents = lcounter;
Jesper Juhl014c2542006-01-15 02:37:08 +01001761 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001762 case XFS_SBS_DBLOCKS:
1763 lcounter = (long long)mp->m_sb.sb_dblocks;
1764 lcounter += delta;
1765 if (lcounter < 0) {
1766 ASSERT(0);
Jesper Juhl014c2542006-01-15 02:37:08 +01001767 return XFS_ERROR(EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001768 }
1769 mp->m_sb.sb_dblocks = lcounter;
Jesper Juhl014c2542006-01-15 02:37:08 +01001770 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001771 case XFS_SBS_AGCOUNT:
1772 scounter = mp->m_sb.sb_agcount;
1773 scounter += delta;
1774 if (scounter < 0) {
1775 ASSERT(0);
Jesper Juhl014c2542006-01-15 02:37:08 +01001776 return XFS_ERROR(EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001777 }
1778 mp->m_sb.sb_agcount = scounter;
Jesper Juhl014c2542006-01-15 02:37:08 +01001779 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001780 case XFS_SBS_IMAX_PCT:
1781 scounter = mp->m_sb.sb_imax_pct;
1782 scounter += delta;
1783 if (scounter < 0) {
1784 ASSERT(0);
Jesper Juhl014c2542006-01-15 02:37:08 +01001785 return XFS_ERROR(EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001786 }
1787 mp->m_sb.sb_imax_pct = scounter;
Jesper Juhl014c2542006-01-15 02:37:08 +01001788 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001789 case XFS_SBS_REXTSIZE:
1790 scounter = mp->m_sb.sb_rextsize;
1791 scounter += delta;
1792 if (scounter < 0) {
1793 ASSERT(0);
Jesper Juhl014c2542006-01-15 02:37:08 +01001794 return XFS_ERROR(EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001795 }
1796 mp->m_sb.sb_rextsize = scounter;
Jesper Juhl014c2542006-01-15 02:37:08 +01001797 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001798 case XFS_SBS_RBMBLOCKS:
1799 scounter = mp->m_sb.sb_rbmblocks;
1800 scounter += delta;
1801 if (scounter < 0) {
1802 ASSERT(0);
Jesper Juhl014c2542006-01-15 02:37:08 +01001803 return XFS_ERROR(EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001804 }
1805 mp->m_sb.sb_rbmblocks = scounter;
Jesper Juhl014c2542006-01-15 02:37:08 +01001806 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001807 case XFS_SBS_RBLOCKS:
1808 lcounter = (long long)mp->m_sb.sb_rblocks;
1809 lcounter += delta;
1810 if (lcounter < 0) {
1811 ASSERT(0);
Jesper Juhl014c2542006-01-15 02:37:08 +01001812 return XFS_ERROR(EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001813 }
1814 mp->m_sb.sb_rblocks = lcounter;
Jesper Juhl014c2542006-01-15 02:37:08 +01001815 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001816 case XFS_SBS_REXTENTS:
1817 lcounter = (long long)mp->m_sb.sb_rextents;
1818 lcounter += delta;
1819 if (lcounter < 0) {
1820 ASSERT(0);
Jesper Juhl014c2542006-01-15 02:37:08 +01001821 return XFS_ERROR(EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001822 }
1823 mp->m_sb.sb_rextents = lcounter;
Jesper Juhl014c2542006-01-15 02:37:08 +01001824 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001825 case XFS_SBS_REXTSLOG:
1826 scounter = mp->m_sb.sb_rextslog;
1827 scounter += delta;
1828 if (scounter < 0) {
1829 ASSERT(0);
Jesper Juhl014c2542006-01-15 02:37:08 +01001830 return XFS_ERROR(EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001831 }
1832 mp->m_sb.sb_rextslog = scounter;
Jesper Juhl014c2542006-01-15 02:37:08 +01001833 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001834 default:
1835 ASSERT(0);
Jesper Juhl014c2542006-01-15 02:37:08 +01001836 return XFS_ERROR(EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001837 }
1838}
1839
1840/*
1841 * xfs_mod_incore_sb() is used to change a field in the in-core
1842 * superblock structure by the specified delta. This modification
Eric Sandeen3685c2a2007-10-11 17:42:32 +10001843 * is protected by the m_sb_lock. Just use the xfs_mod_incore_sb_unlocked()
Linus Torvalds1da177e2005-04-16 15:20:36 -07001844 * routine to do the work.
1845 */
1846int
David Chinner20f4ebf2007-02-10 18:36:10 +11001847xfs_mod_incore_sb(
1848 xfs_mount_t *mp,
1849 xfs_sb_field_t field,
1850 int64_t delta,
1851 int rsvd)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001852{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001853 int status;
1854
David Chinner8d280b92006-03-14 13:13:09 +11001855 /* check for per-cpu counters */
1856 switch (field) {
1857#ifdef HAVE_PERCPU_SB
1858 case XFS_SBS_ICOUNT:
1859 case XFS_SBS_IFREE:
1860 case XFS_SBS_FDBLOCKS:
1861 if (!(mp->m_flags & XFS_MOUNT_NO_PERCPU_SB)) {
1862 status = xfs_icsb_modify_counters(mp, field,
1863 delta, rsvd);
1864 break;
1865 }
1866 /* FALLTHROUGH */
1867#endif
1868 default:
Eric Sandeen3685c2a2007-10-11 17:42:32 +10001869 spin_lock(&mp->m_sb_lock);
David Chinner8d280b92006-03-14 13:13:09 +11001870 status = xfs_mod_incore_sb_unlocked(mp, field, delta, rsvd);
Eric Sandeen3685c2a2007-10-11 17:42:32 +10001871 spin_unlock(&mp->m_sb_lock);
David Chinner8d280b92006-03-14 13:13:09 +11001872 break;
1873 }
1874
Jesper Juhl014c2542006-01-15 02:37:08 +01001875 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001876}
1877
1878/*
1879 * xfs_mod_incore_sb_batch() is used to change more than one field
1880 * in the in-core superblock structure at a time. This modification
1881 * is protected by a lock internal to this module. The fields and
1882 * changes to those fields are specified in the array of xfs_mod_sb
1883 * structures passed in.
1884 *
1885 * Either all of the specified deltas will be applied or none of
1886 * them will. If any modified field dips below 0, then all modifications
1887 * will be backed out and EINVAL will be returned.
1888 */
1889int
1890xfs_mod_incore_sb_batch(xfs_mount_t *mp, xfs_mod_sb_t *msb, uint nmsb, int rsvd)
1891{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001892 int status=0;
1893 xfs_mod_sb_t *msbp;
1894
1895 /*
1896 * Loop through the array of mod structures and apply each
1897 * individually. If any fail, then back out all those
1898 * which have already been applied. Do all of this within
Eric Sandeen3685c2a2007-10-11 17:42:32 +10001899 * the scope of the m_sb_lock so that all of the changes will
Linus Torvalds1da177e2005-04-16 15:20:36 -07001900 * be atomic.
1901 */
Eric Sandeen3685c2a2007-10-11 17:42:32 +10001902 spin_lock(&mp->m_sb_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001903 msbp = &msb[0];
1904 for (msbp = &msbp[0]; msbp < (msb + nmsb); msbp++) {
1905 /*
1906 * Apply the delta at index n. If it fails, break
1907 * from the loop so we'll fall into the undo loop
1908 * below.
1909 */
David Chinner8d280b92006-03-14 13:13:09 +11001910 switch (msbp->msb_field) {
1911#ifdef HAVE_PERCPU_SB
1912 case XFS_SBS_ICOUNT:
1913 case XFS_SBS_IFREE:
1914 case XFS_SBS_FDBLOCKS:
1915 if (!(mp->m_flags & XFS_MOUNT_NO_PERCPU_SB)) {
Eric Sandeen3685c2a2007-10-11 17:42:32 +10001916 spin_unlock(&mp->m_sb_lock);
David Chinner20b64282007-02-10 18:35:09 +11001917 status = xfs_icsb_modify_counters(mp,
David Chinner8d280b92006-03-14 13:13:09 +11001918 msbp->msb_field,
1919 msbp->msb_delta, rsvd);
Eric Sandeen3685c2a2007-10-11 17:42:32 +10001920 spin_lock(&mp->m_sb_lock);
David Chinner8d280b92006-03-14 13:13:09 +11001921 break;
1922 }
1923 /* FALLTHROUGH */
1924#endif
1925 default:
1926 status = xfs_mod_incore_sb_unlocked(mp,
1927 msbp->msb_field,
1928 msbp->msb_delta, rsvd);
1929 break;
1930 }
1931
Linus Torvalds1da177e2005-04-16 15:20:36 -07001932 if (status != 0) {
1933 break;
1934 }
1935 }
1936
1937 /*
1938 * If we didn't complete the loop above, then back out
1939 * any changes made to the superblock. If you add code
1940 * between the loop above and here, make sure that you
1941 * preserve the value of status. Loop back until
1942 * we step below the beginning of the array. Make sure
1943 * we don't touch anything back there.
1944 */
1945 if (status != 0) {
1946 msbp--;
1947 while (msbp >= msb) {
David Chinner8d280b92006-03-14 13:13:09 +11001948 switch (msbp->msb_field) {
1949#ifdef HAVE_PERCPU_SB
1950 case XFS_SBS_ICOUNT:
1951 case XFS_SBS_IFREE:
1952 case XFS_SBS_FDBLOCKS:
1953 if (!(mp->m_flags & XFS_MOUNT_NO_PERCPU_SB)) {
Eric Sandeen3685c2a2007-10-11 17:42:32 +10001954 spin_unlock(&mp->m_sb_lock);
David Chinner20b64282007-02-10 18:35:09 +11001955 status = xfs_icsb_modify_counters(mp,
David Chinner8d280b92006-03-14 13:13:09 +11001956 msbp->msb_field,
1957 -(msbp->msb_delta),
1958 rsvd);
Eric Sandeen3685c2a2007-10-11 17:42:32 +10001959 spin_lock(&mp->m_sb_lock);
David Chinner8d280b92006-03-14 13:13:09 +11001960 break;
1961 }
1962 /* FALLTHROUGH */
1963#endif
1964 default:
1965 status = xfs_mod_incore_sb_unlocked(mp,
1966 msbp->msb_field,
1967 -(msbp->msb_delta),
1968 rsvd);
1969 break;
1970 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001971 ASSERT(status == 0);
1972 msbp--;
1973 }
1974 }
Eric Sandeen3685c2a2007-10-11 17:42:32 +10001975 spin_unlock(&mp->m_sb_lock);
Jesper Juhl014c2542006-01-15 02:37:08 +01001976 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001977}
1978
1979/*
1980 * xfs_getsb() is called to obtain the buffer for the superblock.
1981 * The buffer is returned locked and read in from disk.
1982 * The buffer should be released with a call to xfs_brelse().
1983 *
1984 * If the flags parameter is BUF_TRYLOCK, then we'll only return
1985 * the superblock buffer if it can be locked without sleeping.
1986 * If it can't then we'll return NULL.
1987 */
1988xfs_buf_t *
1989xfs_getsb(
1990 xfs_mount_t *mp,
1991 int flags)
1992{
1993 xfs_buf_t *bp;
1994
1995 ASSERT(mp->m_sb_bp != NULL);
1996 bp = mp->m_sb_bp;
Christoph Hellwig0cadda12010-01-19 09:56:44 +00001997 if (flags & XBF_TRYLOCK) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001998 if (!XFS_BUF_CPSEMA(bp)) {
1999 return NULL;
2000 }
2001 } else {
2002 XFS_BUF_PSEMA(bp, PRIBIO);
2003 }
2004 XFS_BUF_HOLD(bp);
2005 ASSERT(XFS_BUF_ISDONE(bp));
Jesper Juhl014c2542006-01-15 02:37:08 +01002006 return bp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002007}
2008
2009/*
2010 * Used to free the superblock along various error paths.
2011 */
2012void
2013xfs_freesb(
2014 xfs_mount_t *mp)
2015{
2016 xfs_buf_t *bp;
2017
2018 /*
2019 * Use xfs_getsb() so that the buffer will be locked
2020 * when we call xfs_buf_relse().
2021 */
2022 bp = xfs_getsb(mp, 0);
2023 XFS_BUF_UNMANAGE(bp);
2024 xfs_buf_relse(bp);
2025 mp->m_sb_bp = NULL;
2026}
2027
2028/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002029 * Used to log changes to the superblock unit and width fields which could
Eric Sandeene6957ea2008-04-10 12:19:34 +10002030 * be altered by the mount options, as well as any potential sb_features2
2031 * fixup. Only the first superblock is updated.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002032 */
Christoph Hellwig7884bc82009-01-19 02:04:07 +01002033int
David Chinneree1c0902008-03-06 13:45:50 +11002034xfs_mount_log_sb(
Linus Torvalds1da177e2005-04-16 15:20:36 -07002035 xfs_mount_t *mp,
2036 __int64_t fields)
2037{
2038 xfs_trans_t *tp;
David Chinnere5720ee2008-04-10 12:21:18 +10002039 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002040
David Chinneree1c0902008-03-06 13:45:50 +11002041 ASSERT(fields & (XFS_SB_UNIT | XFS_SB_WIDTH | XFS_SB_UUID |
David Chinner4b166de2008-05-20 11:30:27 +10002042 XFS_SB_FEATURES2 | XFS_SB_BAD_FEATURES2 |
2043 XFS_SB_VERSIONNUM));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002044
2045 tp = xfs_trans_alloc(mp, XFS_TRANS_SB_UNIT);
David Chinnere5720ee2008-04-10 12:21:18 +10002046 error = xfs_trans_reserve(tp, 0, mp->m_sb.sb_sectsize + 128, 0, 0,
2047 XFS_DEFAULT_LOG_COUNT);
2048 if (error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002049 xfs_trans_cancel(tp, 0);
David Chinnere5720ee2008-04-10 12:21:18 +10002050 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002051 }
2052 xfs_mod_sb(tp, fields);
David Chinnere5720ee2008-04-10 12:21:18 +10002053 error = xfs_trans_commit(tp, 0);
2054 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002055}
David Chinner8d280b92006-03-14 13:13:09 +11002056
Christoph Hellwigdda35b82010-02-15 09:44:46 +00002057/*
2058 * If the underlying (data/log/rt) device is readonly, there are some
2059 * operations that cannot proceed.
2060 */
2061int
2062xfs_dev_is_read_only(
2063 struct xfs_mount *mp,
2064 char *message)
2065{
2066 if (xfs_readonly_buftarg(mp->m_ddev_targp) ||
2067 xfs_readonly_buftarg(mp->m_logdev_targp) ||
2068 (mp->m_rtdev_targp && xfs_readonly_buftarg(mp->m_rtdev_targp))) {
2069 cmn_err(CE_NOTE,
2070 "XFS: %s required on read-only device.", message);
2071 cmn_err(CE_NOTE,
2072 "XFS: write access unavailable, cannot proceed.");
2073 return EROFS;
2074 }
2075 return 0;
2076}
David Chinner8d280b92006-03-14 13:13:09 +11002077
2078#ifdef HAVE_PERCPU_SB
2079/*
2080 * Per-cpu incore superblock counters
2081 *
2082 * Simple concept, difficult implementation
2083 *
2084 * Basically, replace the incore superblock counters with a distributed per cpu
2085 * counter for contended fields (e.g. free block count).
2086 *
2087 * Difficulties arise in that the incore sb is used for ENOSPC checking, and
2088 * hence needs to be accurately read when we are running low on space. Hence
2089 * there is a method to enable and disable the per-cpu counters based on how
2090 * much "stuff" is available in them.
2091 *
2092 * Basically, a counter is enabled if there is enough free resource to justify
2093 * running a per-cpu fast-path. If the per-cpu counter runs out (i.e. a local
2094 * ENOSPC), then we disable the counters to synchronise all callers and
2095 * re-distribute the available resources.
2096 *
2097 * If, once we redistributed the available resources, we still get a failure,
2098 * we disable the per-cpu counter and go through the slow path.
2099 *
2100 * The slow path is the current xfs_mod_incore_sb() function. This means that
Malcolm Parsons9da096f2009-03-29 09:55:42 +02002101 * when we disable a per-cpu counter, we need to drain its resources back to
David Chinner8d280b92006-03-14 13:13:09 +11002102 * the global superblock. We do this after disabling the counter to prevent
2103 * more threads from queueing up on the counter.
2104 *
2105 * Essentially, this means that we still need a lock in the fast path to enable
2106 * synchronisation between the global counters and the per-cpu counters. This
2107 * is not a problem because the lock will be local to a CPU almost all the time
2108 * and have little contention except when we get to ENOSPC conditions.
2109 *
2110 * Basically, this lock becomes a barrier that enables us to lock out the fast
2111 * path while we do things like enabling and disabling counters and
2112 * synchronising the counters.
2113 *
2114 * Locking rules:
2115 *
Eric Sandeen3685c2a2007-10-11 17:42:32 +10002116 * 1. m_sb_lock before picking up per-cpu locks
David Chinner8d280b92006-03-14 13:13:09 +11002117 * 2. per-cpu locks always picked up via for_each_online_cpu() order
Eric Sandeen3685c2a2007-10-11 17:42:32 +10002118 * 3. accurate counter sync requires m_sb_lock + per cpu locks
David Chinner8d280b92006-03-14 13:13:09 +11002119 * 4. modifying per-cpu counters requires holding per-cpu lock
Eric Sandeen3685c2a2007-10-11 17:42:32 +10002120 * 5. modifying global counters requires holding m_sb_lock
2121 * 6. enabling or disabling a counter requires holding the m_sb_lock
David Chinner8d280b92006-03-14 13:13:09 +11002122 * and _none_ of the per-cpu locks.
2123 *
2124 * Disabled counters are only ever re-enabled by a balance operation
2125 * that results in more free resources per CPU than a given threshold.
2126 * To ensure counters don't remain disabled, they are rebalanced when
2127 * the global resource goes above a higher threshold (i.e. some hysteresis
2128 * is present to prevent thrashing).
David Chinner8d280b92006-03-14 13:13:09 +11002129 */
David Chinnere8234a62006-03-14 13:23:52 +11002130
Chandra Seetharaman5a67e4c2006-06-27 02:54:11 -07002131#ifdef CONFIG_HOTPLUG_CPU
David Chinnere8234a62006-03-14 13:23:52 +11002132/*
2133 * hot-plug CPU notifier support.
2134 *
Chandra Seetharaman5a67e4c2006-06-27 02:54:11 -07002135 * We need a notifier per filesystem as we need to be able to identify
2136 * the filesystem to balance the counters out. This is achieved by
2137 * having a notifier block embedded in the xfs_mount_t and doing pointer
2138 * magic to get the mount pointer from the notifier block address.
David Chinnere8234a62006-03-14 13:23:52 +11002139 */
2140STATIC int
2141xfs_icsb_cpu_notify(
2142 struct notifier_block *nfb,
2143 unsigned long action,
2144 void *hcpu)
2145{
2146 xfs_icsb_cnts_t *cntp;
2147 xfs_mount_t *mp;
David Chinnere8234a62006-03-14 13:23:52 +11002148
2149 mp = (xfs_mount_t *)container_of(nfb, xfs_mount_t, m_icsb_notifier);
2150 cntp = (xfs_icsb_cnts_t *)
2151 per_cpu_ptr(mp->m_sb_cnts, (unsigned long)hcpu);
2152 switch (action) {
2153 case CPU_UP_PREPARE:
Rafael J. Wysocki8bb78442007-05-09 02:35:10 -07002154 case CPU_UP_PREPARE_FROZEN:
David Chinnere8234a62006-03-14 13:23:52 +11002155 /* Easy Case - initialize the area and locks, and
2156 * then rebalance when online does everything else for us. */
David Chinner01e1b692006-03-14 13:29:16 +11002157 memset(cntp, 0, sizeof(xfs_icsb_cnts_t));
David Chinnere8234a62006-03-14 13:23:52 +11002158 break;
2159 case CPU_ONLINE:
Rafael J. Wysocki8bb78442007-05-09 02:35:10 -07002160 case CPU_ONLINE_FROZEN:
David Chinner03135cf2007-02-10 18:35:15 +11002161 xfs_icsb_lock(mp);
Christoph Hellwig45af6c62008-04-22 17:34:44 +10002162 xfs_icsb_balance_counter(mp, XFS_SBS_ICOUNT, 0);
2163 xfs_icsb_balance_counter(mp, XFS_SBS_IFREE, 0);
2164 xfs_icsb_balance_counter(mp, XFS_SBS_FDBLOCKS, 0);
David Chinner03135cf2007-02-10 18:35:15 +11002165 xfs_icsb_unlock(mp);
David Chinnere8234a62006-03-14 13:23:52 +11002166 break;
2167 case CPU_DEAD:
Rafael J. Wysocki8bb78442007-05-09 02:35:10 -07002168 case CPU_DEAD_FROZEN:
David Chinnere8234a62006-03-14 13:23:52 +11002169 /* Disable all the counters, then fold the dead cpu's
2170 * count into the total on the global superblock and
2171 * re-enable the counters. */
David Chinner03135cf2007-02-10 18:35:15 +11002172 xfs_icsb_lock(mp);
Eric Sandeen3685c2a2007-10-11 17:42:32 +10002173 spin_lock(&mp->m_sb_lock);
David Chinnere8234a62006-03-14 13:23:52 +11002174 xfs_icsb_disable_counter(mp, XFS_SBS_ICOUNT);
2175 xfs_icsb_disable_counter(mp, XFS_SBS_IFREE);
2176 xfs_icsb_disable_counter(mp, XFS_SBS_FDBLOCKS);
2177
2178 mp->m_sb.sb_icount += cntp->icsb_icount;
2179 mp->m_sb.sb_ifree += cntp->icsb_ifree;
2180 mp->m_sb.sb_fdblocks += cntp->icsb_fdblocks;
2181
David Chinner01e1b692006-03-14 13:29:16 +11002182 memset(cntp, 0, sizeof(xfs_icsb_cnts_t));
David Chinnere8234a62006-03-14 13:23:52 +11002183
Christoph Hellwig45af6c62008-04-22 17:34:44 +10002184 xfs_icsb_balance_counter_locked(mp, XFS_SBS_ICOUNT, 0);
2185 xfs_icsb_balance_counter_locked(mp, XFS_SBS_IFREE, 0);
2186 xfs_icsb_balance_counter_locked(mp, XFS_SBS_FDBLOCKS, 0);
Eric Sandeen3685c2a2007-10-11 17:42:32 +10002187 spin_unlock(&mp->m_sb_lock);
David Chinner03135cf2007-02-10 18:35:15 +11002188 xfs_icsb_unlock(mp);
David Chinnere8234a62006-03-14 13:23:52 +11002189 break;
2190 }
2191
2192 return NOTIFY_OK;
2193}
Chandra Seetharaman5a67e4c2006-06-27 02:54:11 -07002194#endif /* CONFIG_HOTPLUG_CPU */
David Chinnere8234a62006-03-14 13:23:52 +11002195
David Chinner8d280b92006-03-14 13:13:09 +11002196int
2197xfs_icsb_init_counters(
2198 xfs_mount_t *mp)
2199{
2200 xfs_icsb_cnts_t *cntp;
2201 int i;
2202
2203 mp->m_sb_cnts = alloc_percpu(xfs_icsb_cnts_t);
2204 if (mp->m_sb_cnts == NULL)
2205 return -ENOMEM;
2206
Chandra Seetharaman5a67e4c2006-06-27 02:54:11 -07002207#ifdef CONFIG_HOTPLUG_CPU
David Chinnere8234a62006-03-14 13:23:52 +11002208 mp->m_icsb_notifier.notifier_call = xfs_icsb_cpu_notify;
2209 mp->m_icsb_notifier.priority = 0;
Chandra Seetharaman5a67e4c2006-06-27 02:54:11 -07002210 register_hotcpu_notifier(&mp->m_icsb_notifier);
2211#endif /* CONFIG_HOTPLUG_CPU */
David Chinnere8234a62006-03-14 13:23:52 +11002212
David Chinner8d280b92006-03-14 13:13:09 +11002213 for_each_online_cpu(i) {
2214 cntp = (xfs_icsb_cnts_t *)per_cpu_ptr(mp->m_sb_cnts, i);
David Chinner01e1b692006-03-14 13:29:16 +11002215 memset(cntp, 0, sizeof(xfs_icsb_cnts_t));
David Chinner8d280b92006-03-14 13:13:09 +11002216 }
David Chinner20b64282007-02-10 18:35:09 +11002217
2218 mutex_init(&mp->m_icsb_mutex);
2219
David Chinner8d280b92006-03-14 13:13:09 +11002220 /*
2221 * start with all counters disabled so that the
2222 * initial balance kicks us off correctly
2223 */
2224 mp->m_icsb_counters = -1;
2225 return 0;
2226}
2227
Lachlan McIlroy5478eea2007-02-10 18:36:29 +11002228void
2229xfs_icsb_reinit_counters(
2230 xfs_mount_t *mp)
2231{
2232 xfs_icsb_lock(mp);
2233 /*
2234 * start with all counters disabled so that the
2235 * initial balance kicks us off correctly
2236 */
2237 mp->m_icsb_counters = -1;
Christoph Hellwig45af6c62008-04-22 17:34:44 +10002238 xfs_icsb_balance_counter(mp, XFS_SBS_ICOUNT, 0);
2239 xfs_icsb_balance_counter(mp, XFS_SBS_IFREE, 0);
2240 xfs_icsb_balance_counter(mp, XFS_SBS_FDBLOCKS, 0);
Lachlan McIlroy5478eea2007-02-10 18:36:29 +11002241 xfs_icsb_unlock(mp);
2242}
2243
Christoph Hellwigc962fb72008-05-20 15:10:52 +10002244void
David Chinner8d280b92006-03-14 13:13:09 +11002245xfs_icsb_destroy_counters(
2246 xfs_mount_t *mp)
2247{
David Chinnere8234a62006-03-14 13:23:52 +11002248 if (mp->m_sb_cnts) {
Chandra Seetharaman5a67e4c2006-06-27 02:54:11 -07002249 unregister_hotcpu_notifier(&mp->m_icsb_notifier);
David Chinner8d280b92006-03-14 13:13:09 +11002250 free_percpu(mp->m_sb_cnts);
David Chinnere8234a62006-03-14 13:23:52 +11002251 }
David Chinner03135cf2007-02-10 18:35:15 +11002252 mutex_destroy(&mp->m_icsb_mutex);
David Chinner8d280b92006-03-14 13:13:09 +11002253}
2254
Christoph Hellwigb8f82a42009-11-14 16:17:22 +00002255STATIC void
David Chinner01e1b692006-03-14 13:29:16 +11002256xfs_icsb_lock_cntr(
2257 xfs_icsb_cnts_t *icsbp)
2258{
2259 while (test_and_set_bit(XFS_ICSB_FLAG_LOCK, &icsbp->icsb_flags)) {
2260 ndelay(1000);
2261 }
2262}
2263
Christoph Hellwigb8f82a42009-11-14 16:17:22 +00002264STATIC void
David Chinner01e1b692006-03-14 13:29:16 +11002265xfs_icsb_unlock_cntr(
2266 xfs_icsb_cnts_t *icsbp)
2267{
2268 clear_bit(XFS_ICSB_FLAG_LOCK, &icsbp->icsb_flags);
2269}
2270
David Chinner8d280b92006-03-14 13:13:09 +11002271
Christoph Hellwigb8f82a42009-11-14 16:17:22 +00002272STATIC void
David Chinner8d280b92006-03-14 13:13:09 +11002273xfs_icsb_lock_all_counters(
2274 xfs_mount_t *mp)
2275{
2276 xfs_icsb_cnts_t *cntp;
2277 int i;
2278
2279 for_each_online_cpu(i) {
2280 cntp = (xfs_icsb_cnts_t *)per_cpu_ptr(mp->m_sb_cnts, i);
David Chinner01e1b692006-03-14 13:29:16 +11002281 xfs_icsb_lock_cntr(cntp);
David Chinner8d280b92006-03-14 13:13:09 +11002282 }
2283}
2284
Christoph Hellwigb8f82a42009-11-14 16:17:22 +00002285STATIC void
David Chinner8d280b92006-03-14 13:13:09 +11002286xfs_icsb_unlock_all_counters(
2287 xfs_mount_t *mp)
2288{
2289 xfs_icsb_cnts_t *cntp;
2290 int i;
2291
2292 for_each_online_cpu(i) {
2293 cntp = (xfs_icsb_cnts_t *)per_cpu_ptr(mp->m_sb_cnts, i);
David Chinner01e1b692006-03-14 13:29:16 +11002294 xfs_icsb_unlock_cntr(cntp);
David Chinner8d280b92006-03-14 13:13:09 +11002295 }
2296}
2297
2298STATIC void
2299xfs_icsb_count(
2300 xfs_mount_t *mp,
2301 xfs_icsb_cnts_t *cnt,
2302 int flags)
2303{
2304 xfs_icsb_cnts_t *cntp;
2305 int i;
2306
2307 memset(cnt, 0, sizeof(xfs_icsb_cnts_t));
2308
2309 if (!(flags & XFS_ICSB_LAZY_COUNT))
2310 xfs_icsb_lock_all_counters(mp);
2311
2312 for_each_online_cpu(i) {
2313 cntp = (xfs_icsb_cnts_t *)per_cpu_ptr(mp->m_sb_cnts, i);
2314 cnt->icsb_icount += cntp->icsb_icount;
2315 cnt->icsb_ifree += cntp->icsb_ifree;
2316 cnt->icsb_fdblocks += cntp->icsb_fdblocks;
2317 }
2318
2319 if (!(flags & XFS_ICSB_LAZY_COUNT))
2320 xfs_icsb_unlock_all_counters(mp);
2321}
2322
2323STATIC int
2324xfs_icsb_counter_disabled(
2325 xfs_mount_t *mp,
2326 xfs_sb_field_t field)
2327{
2328 ASSERT((field >= XFS_SBS_ICOUNT) && (field <= XFS_SBS_FDBLOCKS));
2329 return test_bit(field, &mp->m_icsb_counters);
2330}
2331
David Chinner36fbe6e2008-04-10 12:19:56 +10002332STATIC void
David Chinner8d280b92006-03-14 13:13:09 +11002333xfs_icsb_disable_counter(
2334 xfs_mount_t *mp,
2335 xfs_sb_field_t field)
2336{
2337 xfs_icsb_cnts_t cnt;
2338
2339 ASSERT((field >= XFS_SBS_ICOUNT) && (field <= XFS_SBS_FDBLOCKS));
2340
David Chinner20b64282007-02-10 18:35:09 +11002341 /*
2342 * If we are already disabled, then there is nothing to do
2343 * here. We check before locking all the counters to avoid
2344 * the expensive lock operation when being called in the
2345 * slow path and the counter is already disabled. This is
2346 * safe because the only time we set or clear this state is under
2347 * the m_icsb_mutex.
2348 */
2349 if (xfs_icsb_counter_disabled(mp, field))
David Chinner36fbe6e2008-04-10 12:19:56 +10002350 return;
David Chinner20b64282007-02-10 18:35:09 +11002351
David Chinner8d280b92006-03-14 13:13:09 +11002352 xfs_icsb_lock_all_counters(mp);
2353 if (!test_and_set_bit(field, &mp->m_icsb_counters)) {
2354 /* drain back to superblock */
2355
Christoph Hellwigce461932008-04-22 17:34:50 +10002356 xfs_icsb_count(mp, &cnt, XFS_ICSB_LAZY_COUNT);
David Chinner8d280b92006-03-14 13:13:09 +11002357 switch(field) {
2358 case XFS_SBS_ICOUNT:
2359 mp->m_sb.sb_icount = cnt.icsb_icount;
2360 break;
2361 case XFS_SBS_IFREE:
2362 mp->m_sb.sb_ifree = cnt.icsb_ifree;
2363 break;
2364 case XFS_SBS_FDBLOCKS:
2365 mp->m_sb.sb_fdblocks = cnt.icsb_fdblocks;
2366 break;
2367 default:
2368 BUG();
2369 }
2370 }
2371
2372 xfs_icsb_unlock_all_counters(mp);
David Chinner8d280b92006-03-14 13:13:09 +11002373}
2374
2375STATIC void
2376xfs_icsb_enable_counter(
2377 xfs_mount_t *mp,
2378 xfs_sb_field_t field,
2379 uint64_t count,
2380 uint64_t resid)
2381{
2382 xfs_icsb_cnts_t *cntp;
2383 int i;
2384
2385 ASSERT((field >= XFS_SBS_ICOUNT) && (field <= XFS_SBS_FDBLOCKS));
2386
2387 xfs_icsb_lock_all_counters(mp);
2388 for_each_online_cpu(i) {
2389 cntp = per_cpu_ptr(mp->m_sb_cnts, i);
2390 switch (field) {
2391 case XFS_SBS_ICOUNT:
2392 cntp->icsb_icount = count + resid;
2393 break;
2394 case XFS_SBS_IFREE:
2395 cntp->icsb_ifree = count + resid;
2396 break;
2397 case XFS_SBS_FDBLOCKS:
2398 cntp->icsb_fdblocks = count + resid;
2399 break;
2400 default:
2401 BUG();
2402 break;
2403 }
2404 resid = 0;
2405 }
2406 clear_bit(field, &mp->m_icsb_counters);
2407 xfs_icsb_unlock_all_counters(mp);
2408}
2409
David Chinnerdbcabad2007-02-10 18:36:17 +11002410void
Christoph Hellwigd4d90b52008-04-22 17:34:37 +10002411xfs_icsb_sync_counters_locked(
David Chinner8d280b92006-03-14 13:13:09 +11002412 xfs_mount_t *mp,
2413 int flags)
2414{
2415 xfs_icsb_cnts_t cnt;
David Chinner8d280b92006-03-14 13:13:09 +11002416
David Chinner8d280b92006-03-14 13:13:09 +11002417 xfs_icsb_count(mp, &cnt, flags);
2418
David Chinner8d280b92006-03-14 13:13:09 +11002419 if (!xfs_icsb_counter_disabled(mp, XFS_SBS_ICOUNT))
2420 mp->m_sb.sb_icount = cnt.icsb_icount;
2421 if (!xfs_icsb_counter_disabled(mp, XFS_SBS_IFREE))
2422 mp->m_sb.sb_ifree = cnt.icsb_ifree;
2423 if (!xfs_icsb_counter_disabled(mp, XFS_SBS_FDBLOCKS))
2424 mp->m_sb.sb_fdblocks = cnt.icsb_fdblocks;
David Chinner8d280b92006-03-14 13:13:09 +11002425}
2426
2427/*
2428 * Accurate update of per-cpu counters to incore superblock
2429 */
Christoph Hellwigd4d90b52008-04-22 17:34:37 +10002430void
David Chinner8d280b92006-03-14 13:13:09 +11002431xfs_icsb_sync_counters(
Christoph Hellwigd4d90b52008-04-22 17:34:37 +10002432 xfs_mount_t *mp,
2433 int flags)
David Chinner8d280b92006-03-14 13:13:09 +11002434{
Christoph Hellwigd4d90b52008-04-22 17:34:37 +10002435 spin_lock(&mp->m_sb_lock);
2436 xfs_icsb_sync_counters_locked(mp, flags);
2437 spin_unlock(&mp->m_sb_lock);
David Chinner8d280b92006-03-14 13:13:09 +11002438}
2439
2440/*
2441 * Balance and enable/disable counters as necessary.
2442 *
David Chinner20b64282007-02-10 18:35:09 +11002443 * Thresholds for re-enabling counters are somewhat magic. inode counts are
2444 * chosen to be the same number as single on disk allocation chunk per CPU, and
2445 * free blocks is something far enough zero that we aren't going thrash when we
2446 * get near ENOSPC. We also need to supply a minimum we require per cpu to
2447 * prevent looping endlessly when xfs_alloc_space asks for more than will
2448 * be distributed to a single CPU but each CPU has enough blocks to be
2449 * reenabled.
2450 *
2451 * Note that we can be called when counters are already disabled.
2452 * xfs_icsb_disable_counter() optimises the counter locking in this case to
2453 * prevent locking every per-cpu counter needlessly.
David Chinner8d280b92006-03-14 13:13:09 +11002454 */
David Chinner20b64282007-02-10 18:35:09 +11002455
2456#define XFS_ICSB_INO_CNTR_REENABLE (uint64_t)64
David Chinner4be536d2006-09-07 14:26:50 +10002457#define XFS_ICSB_FDBLK_CNTR_REENABLE(mp) \
David Chinner20b64282007-02-10 18:35:09 +11002458 (uint64_t)(512 + XFS_ALLOC_SET_ASIDE(mp))
David Chinner8d280b92006-03-14 13:13:09 +11002459STATIC void
Christoph Hellwig45af6c62008-04-22 17:34:44 +10002460xfs_icsb_balance_counter_locked(
David Chinner8d280b92006-03-14 13:13:09 +11002461 xfs_mount_t *mp,
2462 xfs_sb_field_t field,
David Chinner20b64282007-02-10 18:35:09 +11002463 int min_per_cpu)
David Chinner8d280b92006-03-14 13:13:09 +11002464{
Nathan Scott6fdf8cc2006-06-28 10:13:52 +10002465 uint64_t count, resid;
David Chinner8d280b92006-03-14 13:13:09 +11002466 int weight = num_online_cpus();
David Chinner20b64282007-02-10 18:35:09 +11002467 uint64_t min = (uint64_t)min_per_cpu;
David Chinner8d280b92006-03-14 13:13:09 +11002468
David Chinner8d280b92006-03-14 13:13:09 +11002469 /* disable counter and sync counter */
2470 xfs_icsb_disable_counter(mp, field);
2471
2472 /* update counters - first CPU gets residual*/
2473 switch (field) {
2474 case XFS_SBS_ICOUNT:
2475 count = mp->m_sb.sb_icount;
2476 resid = do_div(count, weight);
David Chinner20b64282007-02-10 18:35:09 +11002477 if (count < max(min, XFS_ICSB_INO_CNTR_REENABLE))
Christoph Hellwig45af6c62008-04-22 17:34:44 +10002478 return;
David Chinner8d280b92006-03-14 13:13:09 +11002479 break;
2480 case XFS_SBS_IFREE:
2481 count = mp->m_sb.sb_ifree;
2482 resid = do_div(count, weight);
David Chinner20b64282007-02-10 18:35:09 +11002483 if (count < max(min, XFS_ICSB_INO_CNTR_REENABLE))
Christoph Hellwig45af6c62008-04-22 17:34:44 +10002484 return;
David Chinner8d280b92006-03-14 13:13:09 +11002485 break;
2486 case XFS_SBS_FDBLOCKS:
2487 count = mp->m_sb.sb_fdblocks;
2488 resid = do_div(count, weight);
David Chinner20b64282007-02-10 18:35:09 +11002489 if (count < max(min, XFS_ICSB_FDBLK_CNTR_REENABLE(mp)))
Christoph Hellwig45af6c62008-04-22 17:34:44 +10002490 return;
David Chinner8d280b92006-03-14 13:13:09 +11002491 break;
2492 default:
2493 BUG();
Nathan Scott6fdf8cc2006-06-28 10:13:52 +10002494 count = resid = 0; /* quiet, gcc */
David Chinner8d280b92006-03-14 13:13:09 +11002495 break;
2496 }
2497
2498 xfs_icsb_enable_counter(mp, field, count, resid);
Christoph Hellwig45af6c62008-04-22 17:34:44 +10002499}
2500
2501STATIC void
2502xfs_icsb_balance_counter(
2503 xfs_mount_t *mp,
2504 xfs_sb_field_t fields,
2505 int min_per_cpu)
2506{
2507 spin_lock(&mp->m_sb_lock);
2508 xfs_icsb_balance_counter_locked(mp, fields, min_per_cpu);
2509 spin_unlock(&mp->m_sb_lock);
David Chinner8d280b92006-03-14 13:13:09 +11002510}
2511
David Chinnera8272ce2007-11-23 16:28:09 +11002512STATIC int
David Chinner20b64282007-02-10 18:35:09 +11002513xfs_icsb_modify_counters(
David Chinner8d280b92006-03-14 13:13:09 +11002514 xfs_mount_t *mp,
2515 xfs_sb_field_t field,
David Chinner20f4ebf2007-02-10 18:36:10 +11002516 int64_t delta,
David Chinner20b64282007-02-10 18:35:09 +11002517 int rsvd)
David Chinner8d280b92006-03-14 13:13:09 +11002518{
2519 xfs_icsb_cnts_t *icsbp;
2520 long long lcounter; /* long counter for 64 bit fields */
Christoph Lameter7a9e02d2009-10-03 19:48:23 +09002521 int ret = 0;
David Chinner8d280b92006-03-14 13:13:09 +11002522
David Chinner20b64282007-02-10 18:35:09 +11002523 might_sleep();
David Chinner8d280b92006-03-14 13:13:09 +11002524again:
Christoph Lameter7a9e02d2009-10-03 19:48:23 +09002525 preempt_disable();
2526 icsbp = this_cpu_ptr(mp->m_sb_cnts);
David Chinner20b64282007-02-10 18:35:09 +11002527
2528 /*
2529 * if the counter is disabled, go to slow path
2530 */
David Chinner8d280b92006-03-14 13:13:09 +11002531 if (unlikely(xfs_icsb_counter_disabled(mp, field)))
2532 goto slow_path;
David Chinner20b64282007-02-10 18:35:09 +11002533 xfs_icsb_lock_cntr(icsbp);
2534 if (unlikely(xfs_icsb_counter_disabled(mp, field))) {
2535 xfs_icsb_unlock_cntr(icsbp);
2536 goto slow_path;
2537 }
David Chinner8d280b92006-03-14 13:13:09 +11002538
2539 switch (field) {
2540 case XFS_SBS_ICOUNT:
2541 lcounter = icsbp->icsb_icount;
2542 lcounter += delta;
2543 if (unlikely(lcounter < 0))
David Chinner20b64282007-02-10 18:35:09 +11002544 goto balance_counter;
David Chinner8d280b92006-03-14 13:13:09 +11002545 icsbp->icsb_icount = lcounter;
2546 break;
2547
2548 case XFS_SBS_IFREE:
2549 lcounter = icsbp->icsb_ifree;
2550 lcounter += delta;
2551 if (unlikely(lcounter < 0))
David Chinner20b64282007-02-10 18:35:09 +11002552 goto balance_counter;
David Chinner8d280b92006-03-14 13:13:09 +11002553 icsbp->icsb_ifree = lcounter;
2554 break;
2555
2556 case XFS_SBS_FDBLOCKS:
2557 BUG_ON((mp->m_resblks - mp->m_resblks_avail) != 0);
2558
David Chinner4be536d2006-09-07 14:26:50 +10002559 lcounter = icsbp->icsb_fdblocks - XFS_ALLOC_SET_ASIDE(mp);
David Chinner8d280b92006-03-14 13:13:09 +11002560 lcounter += delta;
2561 if (unlikely(lcounter < 0))
David Chinner20b64282007-02-10 18:35:09 +11002562 goto balance_counter;
David Chinner4be536d2006-09-07 14:26:50 +10002563 icsbp->icsb_fdblocks = lcounter + XFS_ALLOC_SET_ASIDE(mp);
David Chinner8d280b92006-03-14 13:13:09 +11002564 break;
2565 default:
2566 BUG();
2567 break;
2568 }
David Chinner01e1b692006-03-14 13:29:16 +11002569 xfs_icsb_unlock_cntr(icsbp);
Christoph Lameter7a9e02d2009-10-03 19:48:23 +09002570 preempt_enable();
David Chinner8d280b92006-03-14 13:13:09 +11002571 return 0;
2572
David Chinner8d280b92006-03-14 13:13:09 +11002573slow_path:
Christoph Lameter7a9e02d2009-10-03 19:48:23 +09002574 preempt_enable();
David Chinner20b64282007-02-10 18:35:09 +11002575
2576 /*
2577 * serialise with a mutex so we don't burn lots of cpu on
2578 * the superblock lock. We still need to hold the superblock
2579 * lock, however, when we modify the global structures.
2580 */
David Chinner03135cf2007-02-10 18:35:15 +11002581 xfs_icsb_lock(mp);
David Chinner20b64282007-02-10 18:35:09 +11002582
2583 /*
2584 * Now running atomically.
2585 *
2586 * If the counter is enabled, someone has beaten us to rebalancing.
2587 * Drop the lock and try again in the fast path....
2588 */
2589 if (!(xfs_icsb_counter_disabled(mp, field))) {
David Chinner03135cf2007-02-10 18:35:15 +11002590 xfs_icsb_unlock(mp);
David Chinner20b64282007-02-10 18:35:09 +11002591 goto again;
2592 }
2593
2594 /*
2595 * The counter is currently disabled. Because we are
2596 * running atomically here, we know a rebalance cannot
2597 * be in progress. Hence we can go straight to operating
2598 * on the global superblock. We do not call xfs_mod_incore_sb()
Eric Sandeen3685c2a2007-10-11 17:42:32 +10002599 * here even though we need to get the m_sb_lock. Doing so
David Chinner20b64282007-02-10 18:35:09 +11002600 * will cause us to re-enter this function and deadlock.
Eric Sandeen3685c2a2007-10-11 17:42:32 +10002601 * Hence we get the m_sb_lock ourselves and then call
David Chinner20b64282007-02-10 18:35:09 +11002602 * xfs_mod_incore_sb_unlocked() as the unlocked path operates
2603 * directly on the global counters.
2604 */
Eric Sandeen3685c2a2007-10-11 17:42:32 +10002605 spin_lock(&mp->m_sb_lock);
David Chinner20b64282007-02-10 18:35:09 +11002606 ret = xfs_mod_incore_sb_unlocked(mp, field, delta, rsvd);
Eric Sandeen3685c2a2007-10-11 17:42:32 +10002607 spin_unlock(&mp->m_sb_lock);
David Chinner20b64282007-02-10 18:35:09 +11002608
2609 /*
2610 * Now that we've modified the global superblock, we
2611 * may be able to re-enable the distributed counters
2612 * (e.g. lots of space just got freed). After that
2613 * we are done.
2614 */
2615 if (ret != ENOSPC)
Christoph Hellwig45af6c62008-04-22 17:34:44 +10002616 xfs_icsb_balance_counter(mp, field, 0);
David Chinner03135cf2007-02-10 18:35:15 +11002617 xfs_icsb_unlock(mp);
David Chinner20b64282007-02-10 18:35:09 +11002618 return ret;
2619
2620balance_counter:
David Chinner01e1b692006-03-14 13:29:16 +11002621 xfs_icsb_unlock_cntr(icsbp);
Christoph Lameter7a9e02d2009-10-03 19:48:23 +09002622 preempt_enable();
David Chinner8d280b92006-03-14 13:13:09 +11002623
David Chinner20b64282007-02-10 18:35:09 +11002624 /*
2625 * We may have multiple threads here if multiple per-cpu
2626 * counters run dry at the same time. This will mean we can
2627 * do more balances than strictly necessary but it is not
2628 * the common slowpath case.
2629 */
David Chinner03135cf2007-02-10 18:35:15 +11002630 xfs_icsb_lock(mp);
David Chinner8d280b92006-03-14 13:13:09 +11002631
David Chinner20b64282007-02-10 18:35:09 +11002632 /*
2633 * running atomically.
2634 *
2635 * This will leave the counter in the correct state for future
2636 * accesses. After the rebalance, we simply try again and our retry
2637 * will either succeed through the fast path or slow path without
2638 * another balance operation being required.
2639 */
Christoph Hellwig45af6c62008-04-22 17:34:44 +10002640 xfs_icsb_balance_counter(mp, field, delta);
David Chinner03135cf2007-02-10 18:35:15 +11002641 xfs_icsb_unlock(mp);
David Chinner20b64282007-02-10 18:35:09 +11002642 goto again;
David Chinner8d280b92006-03-14 13:13:09 +11002643}
2644
David Chinner8d280b92006-03-14 13:13:09 +11002645#endif