blob: e79b56b4bca6634daaf0b4b1cc47fa689ff5048d [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
1408#if defined(DEBUG) && defined(XFS_LOUD_RECOVERY)
1409 if (XFS_IS_QUOTA_ON(mp))
1410 xfs_fs_cmn_err(CE_NOTE, mp, "Disk quotas turned on");
1411 else
1412 xfs_fs_cmn_err(CE_NOTE, mp, "Disk quotas not turned on");
1413#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001414
David Chinner84e1e992007-06-18 16:50:27 +10001415 /*
1416 * Now we are mounted, reserve a small amount of unused space for
1417 * privileged transactions. This is needed so that transaction
1418 * space required for critical operations can dip into this pool
1419 * when at ENOSPC. This is needed for operations like create with
1420 * attr, unwritten extent conversion at ENOSPC, etc. Data allocations
1421 * are not allowed to use this reserved space.
Dave Chinner8babd8a2010-03-04 01:46:25 +00001422 *
1423 * This may drive us straight to ENOSPC on mount, but that implies
1424 * we were already there on the last unmount. Warn if this occurs.
David Chinner84e1e992007-06-18 16:50:27 +10001425 */
Eric Sandeend5db0f92010-02-05 22:59:53 +00001426 if (!(mp->m_flags & XFS_MOUNT_RDONLY)) {
1427 resblks = xfs_default_resblks(mp);
1428 error = xfs_reserve_blocks(mp, &resblks, NULL);
1429 if (error)
1430 cmn_err(CE_WARN, "XFS: Unable to allocate reserve "
1431 "blocks. Continuing without a reserve pool.");
1432 }
David Chinner84e1e992007-06-18 16:50:27 +10001433
Linus Torvalds1da177e2005-04-16 15:20:36 -07001434 return 0;
1435
Christoph Hellwigb93b6e42009-02-04 09:33:58 +01001436 out_rtunmount:
1437 xfs_rtunmount_inodes(mp);
Christoph Hellwigf9057e32009-02-04 09:31:52 +01001438 out_rele_rip:
Christoph Hellwig43355092008-03-27 18:01:08 +11001439 IRELE(rip);
Christoph Hellwigf9057e32009-02-04 09:31:52 +01001440 out_log_dealloc:
Christoph Hellwig21b699c2009-03-16 08:19:29 +01001441 xfs_log_unmount(mp);
Christoph Hellwigf9057e32009-02-04 09:31:52 +01001442 out_free_perag:
Christoph Hellwigff4f0382008-08-13 16:50:47 +10001443 xfs_free_perag(mp);
Christoph Hellwigf9057e32009-02-04 09:31:52 +01001444 out_remove_uuid:
Christoph Hellwig27174202009-03-30 10:21:31 +02001445 xfs_uuid_unmount(mp);
Christoph Hellwigf9057e32009-02-04 09:31:52 +01001446 out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001447 return error;
1448}
1449
1450/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001451 * This flushes out the inodes,dquots and the superblock, unmounts the
1452 * log and makes sure that incore structures are freed.
1453 */
Christoph Hellwig41b5c2e2008-08-13 16:49:57 +10001454void
1455xfs_unmountfs(
1456 struct xfs_mount *mp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001457{
Christoph Hellwig41b5c2e2008-08-13 16:49:57 +10001458 __uint64_t resblks;
1459 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001460
Christoph Hellwig7d095252009-06-08 15:33:32 +02001461 xfs_qm_unmount_quotas(mp);
Christoph Hellwigb93b6e42009-02-04 09:33:58 +01001462 xfs_rtunmount_inodes(mp);
Christoph Hellwig77508ec2008-08-13 16:49:04 +10001463 IRELE(mp->m_rootip);
1464
David Chinner641c56f2007-06-18 16:50:17 +10001465 /*
1466 * We can potentially deadlock here if we have an inode cluster
Malcolm Parsons9da096f2009-03-29 09:55:42 +02001467 * that has been freed has its buffer still pinned in memory because
David Chinner641c56f2007-06-18 16:50:17 +10001468 * the transaction is still sitting in a iclog. The stale inodes
1469 * on that buffer will have their flush locks held until the
1470 * transaction hits the disk and the callbacks run. the inode
1471 * flush takes the flush lock unconditionally and with nothing to
1472 * push out the iclog we will never get that unlocked. hence we
1473 * need to force the log first.
1474 */
Christoph Hellwiga14a3482010-01-19 09:56:46 +00001475 xfs_log_force(mp, XFS_LOG_SYNC);
Dave Chinnerc8543632010-02-06 12:39:36 +11001476
1477 /*
1478 * Do a delwri reclaim pass first so that as many dirty inodes are
1479 * queued up for IO as possible. Then flush the buffers before making
1480 * a synchronous path to catch all the remaining inodes are reclaimed.
1481 * This makes the reclaim process as quick as possible by avoiding
1482 * synchronous writeout and blocking on inodes already in the delwri
1483 * state as much as possible.
1484 */
1485 xfs_reclaim_inodes(mp, 0);
1486 XFS_bflush(mp->m_ddev_targp);
1487 xfs_reclaim_inodes(mp, SYNC_WAIT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001488
Christoph Hellwig7d095252009-06-08 15:33:32 +02001489 xfs_qm_unmount(mp);
Lachlan McIlroya357a122008-10-30 16:53:25 +11001490
Linus Torvalds1da177e2005-04-16 15:20:36 -07001491 /*
1492 * Flush out the log synchronously so that we know for sure
1493 * that nothing is pinned. This is important because bflush()
1494 * will skip pinned buffers.
1495 */
Christoph Hellwiga14a3482010-01-19 09:56:46 +00001496 xfs_log_force(mp, XFS_LOG_SYNC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001497
1498 xfs_binval(mp->m_ddev_targp);
1499 if (mp->m_rtdev_targp) {
1500 xfs_binval(mp->m_rtdev_targp);
1501 }
1502
David Chinner84e1e992007-06-18 16:50:27 +10001503 /*
1504 * Unreserve any blocks we have so that when we unmount we don't account
1505 * the reserved free space as used. This is really only necessary for
1506 * lazy superblock counting because it trusts the incore superblock
Malcolm Parsons9da096f2009-03-29 09:55:42 +02001507 * counters to be absolutely correct on clean unmount.
David Chinner84e1e992007-06-18 16:50:27 +10001508 *
1509 * We don't bother correcting this elsewhere for lazy superblock
1510 * counting because on mount of an unclean filesystem we reconstruct the
1511 * correct counter value and this is irrelevant.
1512 *
1513 * For non-lazy counter filesystems, this doesn't matter at all because
1514 * we only every apply deltas to the superblock and hence the incore
1515 * value does not matter....
1516 */
1517 resblks = 0;
David Chinner714082b2008-04-10 12:20:03 +10001518 error = xfs_reserve_blocks(mp, &resblks, NULL);
1519 if (error)
1520 cmn_err(CE_WARN, "XFS: Unable to free reserved block pool. "
1521 "Freespace may not be correct on next mount.");
1522
David Chinnere5720ee2008-04-10 12:21:18 +10001523 error = xfs_log_sbcount(mp, 1);
1524 if (error)
1525 cmn_err(CE_WARN, "XFS: Unable to update superblock counters. "
1526 "Freespace may not be correct on next mount.");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001527 xfs_unmountfs_writesb(mp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001528 xfs_unmountfs_wait(mp); /* wait for async bufs */
Christoph Hellwig21b699c2009-03-16 08:19:29 +01001529 xfs_log_unmount_write(mp);
1530 xfs_log_unmount(mp);
Christoph Hellwig27174202009-03-30 10:21:31 +02001531 xfs_uuid_unmount(mp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001532
Christoph Hellwig1550d0b2008-08-13 16:17:37 +10001533#if defined(DEBUG)
Christoph Hellwig0ce4cfd2007-08-30 17:20:53 +10001534 xfs_errortag_clearall(mp, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001535#endif
Christoph Hellwigff4f0382008-08-13 16:50:47 +10001536 xfs_free_perag(mp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001537}
1538
Christoph Hellwigba0f32d2005-06-21 15:36:52 +10001539STATIC void
Linus Torvalds1da177e2005-04-16 15:20:36 -07001540xfs_unmountfs_wait(xfs_mount_t *mp)
1541{
1542 if (mp->m_logdev_targp != mp->m_ddev_targp)
1543 xfs_wait_buftarg(mp->m_logdev_targp);
1544 if (mp->m_rtdev_targp)
1545 xfs_wait_buftarg(mp->m_rtdev_targp);
1546 xfs_wait_buftarg(mp->m_ddev_targp);
1547}
1548
1549int
David Chinner92821e22007-05-24 15:26:31 +10001550xfs_fs_writable(xfs_mount_t *mp)
1551{
Christoph Hellwigb267ce92007-08-30 17:21:30 +10001552 return !(xfs_test_for_freeze(mp) || XFS_FORCED_SHUTDOWN(mp) ||
Christoph Hellwigbd186aa2007-08-30 17:21:12 +10001553 (mp->m_flags & XFS_MOUNT_RDONLY));
David Chinner92821e22007-05-24 15:26:31 +10001554}
1555
1556/*
1557 * xfs_log_sbcount
1558 *
1559 * Called either periodically to keep the on disk superblock values
1560 * roughly up to date or from unmount to make sure the values are
1561 * correct on a clean unmount.
1562 *
1563 * Note this code can be called during the process of freezing, so
1564 * we may need to use the transaction allocator which does not not
1565 * block when the transaction subsystem is in its frozen state.
1566 */
1567int
1568xfs_log_sbcount(
1569 xfs_mount_t *mp,
1570 uint sync)
1571{
1572 xfs_trans_t *tp;
1573 int error;
1574
1575 if (!xfs_fs_writable(mp))
1576 return 0;
1577
Christoph Hellwigd4d90b52008-04-22 17:34:37 +10001578 xfs_icsb_sync_counters(mp, 0);
David Chinner92821e22007-05-24 15:26:31 +10001579
1580 /*
1581 * we don't need to do this if we are updating the superblock
1582 * counters on every modification.
1583 */
1584 if (!xfs_sb_version_haslazysbcount(&mp->m_sb))
1585 return 0;
1586
Christoph Hellwig80641dc2009-10-19 04:00:03 +00001587 tp = _xfs_trans_alloc(mp, XFS_TRANS_SB_COUNT, KM_SLEEP);
David Chinner92821e22007-05-24 15:26:31 +10001588 error = xfs_trans_reserve(tp, 0, mp->m_sb.sb_sectsize + 128, 0, 0,
1589 XFS_DEFAULT_LOG_COUNT);
1590 if (error) {
1591 xfs_trans_cancel(tp, 0);
1592 return error;
1593 }
1594
1595 xfs_mod_sb(tp, XFS_SB_IFREE | XFS_SB_ICOUNT | XFS_SB_FDBLOCKS);
1596 if (sync)
1597 xfs_trans_set_sync(tp);
David Chinnere5720ee2008-04-10 12:21:18 +10001598 error = xfs_trans_commit(tp, 0);
1599 return error;
David Chinner92821e22007-05-24 15:26:31 +10001600}
1601
1602int
Linus Torvalds1da177e2005-04-16 15:20:36 -07001603xfs_unmountfs_writesb(xfs_mount_t *mp)
1604{
1605 xfs_buf_t *sbp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001606 int error = 0;
1607
1608 /*
1609 * skip superblock write if fs is read-only, or
1610 * if we are doing a forced umount.
1611 */
Christoph Hellwigbd186aa2007-08-30 17:21:12 +10001612 if (!((mp->m_flags & XFS_MOUNT_RDONLY) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -07001613 XFS_FORCED_SHUTDOWN(mp))) {
David Chinner8d280b92006-03-14 13:13:09 +11001614
David Chinner92821e22007-05-24 15:26:31 +10001615 sbp = xfs_getsb(mp, 0);
David Chinner8d280b92006-03-14 13:13:09 +11001616
Linus Torvalds1da177e2005-04-16 15:20:36 -07001617 XFS_BUF_UNDONE(sbp);
1618 XFS_BUF_UNREAD(sbp);
1619 XFS_BUF_UNDELAYWRITE(sbp);
1620 XFS_BUF_WRITE(sbp);
1621 XFS_BUF_UNASYNC(sbp);
1622 ASSERT(XFS_BUF_TARGET(sbp) == mp->m_ddev_targp);
1623 xfsbdstrat(mp, sbp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001624 error = xfs_iowait(sbp);
1625 if (error)
1626 xfs_ioerror_alert("xfs_unmountfs_writesb",
1627 mp, sbp, XFS_BUF_ADDR(sbp));
David Chinner92821e22007-05-24 15:26:31 +10001628 xfs_buf_relse(sbp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001629 }
Jesper Juhl014c2542006-01-15 02:37:08 +01001630 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001631}
1632
1633/*
1634 * xfs_mod_sb() can be used to copy arbitrary changes to the
1635 * in-core superblock into the superblock buffer to be logged.
1636 * It does not provide the higher level of locking that is
1637 * needed to protect the in-core superblock from concurrent
1638 * access.
1639 */
1640void
1641xfs_mod_sb(xfs_trans_t *tp, __int64_t fields)
1642{
1643 xfs_buf_t *bp;
1644 int first;
1645 int last;
1646 xfs_mount_t *mp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001647 xfs_sb_field_t f;
1648
1649 ASSERT(fields);
1650 if (!fields)
1651 return;
1652 mp = tp->t_mountp;
1653 bp = xfs_trans_getsb(tp, mp, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001654 first = sizeof(xfs_sb_t);
1655 last = 0;
1656
1657 /* translate/copy */
1658
Christoph Hellwig2bdf7cd2007-08-28 13:58:06 +10001659 xfs_sb_to_disk(XFS_BUF_TO_SBP(bp), &mp->m_sb, fields);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001660
1661 /* find modified range */
Dave Chinner587aa0f2010-01-20 12:04:53 +11001662 f = (xfs_sb_field_t)xfs_highbit64((__uint64_t)fields);
1663 ASSERT((1LL << f) & XFS_SB_MOD_BITS);
1664 last = xfs_sb_info[f + 1].offset - 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001665
1666 f = (xfs_sb_field_t)xfs_lowbit64((__uint64_t)fields);
1667 ASSERT((1LL << f) & XFS_SB_MOD_BITS);
1668 first = xfs_sb_info[f].offset;
1669
Linus Torvalds1da177e2005-04-16 15:20:36 -07001670 xfs_trans_log_buf(tp, bp, first, last);
1671}
Yingping Lud210a282006-06-09 14:55:18 +10001672
Yingping Lud210a282006-06-09 14:55:18 +10001673
Linus Torvalds1da177e2005-04-16 15:20:36 -07001674/*
1675 * xfs_mod_incore_sb_unlocked() is a utility routine common used to apply
1676 * a delta to a specified field in the in-core superblock. Simply
1677 * switch on the field indicated and apply the delta to that field.
1678 * Fields are not allowed to dip below zero, so if the delta would
1679 * do this do not apply it and return EINVAL.
1680 *
Eric Sandeen3685c2a2007-10-11 17:42:32 +10001681 * The m_sb_lock must be held when this routine is called.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001682 */
Eric Sandeend96f8f82009-07-02 00:09:33 -05001683STATIC int
David Chinner20f4ebf2007-02-10 18:36:10 +11001684xfs_mod_incore_sb_unlocked(
1685 xfs_mount_t *mp,
1686 xfs_sb_field_t field,
1687 int64_t delta,
1688 int rsvd)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001689{
1690 int scounter; /* short counter for 32 bit fields */
1691 long long lcounter; /* long counter for 64 bit fields */
1692 long long res_used, rem;
1693
1694 /*
1695 * With the in-core superblock spin lock held, switch
1696 * on the indicated field. Apply the delta to the
1697 * proper field. If the fields value would dip below
1698 * 0, then do not apply the delta and return EINVAL.
1699 */
1700 switch (field) {
1701 case XFS_SBS_ICOUNT:
1702 lcounter = (long long)mp->m_sb.sb_icount;
1703 lcounter += delta;
1704 if (lcounter < 0) {
1705 ASSERT(0);
Jesper Juhl014c2542006-01-15 02:37:08 +01001706 return XFS_ERROR(EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001707 }
1708 mp->m_sb.sb_icount = lcounter;
Jesper Juhl014c2542006-01-15 02:37:08 +01001709 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001710 case XFS_SBS_IFREE:
1711 lcounter = (long long)mp->m_sb.sb_ifree;
1712 lcounter += delta;
1713 if (lcounter < 0) {
1714 ASSERT(0);
Jesper Juhl014c2542006-01-15 02:37:08 +01001715 return XFS_ERROR(EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001716 }
1717 mp->m_sb.sb_ifree = lcounter;
Jesper Juhl014c2542006-01-15 02:37:08 +01001718 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001719 case XFS_SBS_FDBLOCKS:
David Chinner4be536d2006-09-07 14:26:50 +10001720 lcounter = (long long)
1721 mp->m_sb.sb_fdblocks - XFS_ALLOC_SET_ASIDE(mp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001722 res_used = (long long)(mp->m_resblks - mp->m_resblks_avail);
1723
1724 if (delta > 0) { /* Putting blocks back */
1725 if (res_used > delta) {
1726 mp->m_resblks_avail += delta;
1727 } else {
1728 rem = delta - res_used;
1729 mp->m_resblks_avail = mp->m_resblks;
1730 lcounter += rem;
1731 }
1732 } else { /* Taking blocks away */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001733 lcounter += delta;
Dave Chinner8babd8a2010-03-04 01:46:25 +00001734 if (lcounter >= 0) {
1735 mp->m_sb.sb_fdblocks = lcounter +
1736 XFS_ALLOC_SET_ASIDE(mp);
1737 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001738 }
Dave Chinner8babd8a2010-03-04 01:46:25 +00001739
1740 /*
1741 * We are out of blocks, use any available reserved
1742 * blocks if were allowed to.
1743 */
1744 if (!rsvd)
1745 return XFS_ERROR(ENOSPC);
1746
1747 lcounter = (long long)mp->m_resblks_avail + delta;
1748 if (lcounter >= 0) {
1749 mp->m_resblks_avail = lcounter;
1750 return 0;
1751 }
1752 printk_once(KERN_WARNING
1753 "Filesystem \"%s\": reserve blocks depleted! "
1754 "Consider increasing reserve pool size.",
1755 mp->m_fsname);
1756 return XFS_ERROR(ENOSPC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001757 }
1758
David Chinner4be536d2006-09-07 14:26:50 +10001759 mp->m_sb.sb_fdblocks = lcounter + XFS_ALLOC_SET_ASIDE(mp);
Jesper Juhl014c2542006-01-15 02:37:08 +01001760 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001761 case XFS_SBS_FREXTENTS:
1762 lcounter = (long long)mp->m_sb.sb_frextents;
1763 lcounter += delta;
1764 if (lcounter < 0) {
Jesper Juhl014c2542006-01-15 02:37:08 +01001765 return XFS_ERROR(ENOSPC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001766 }
1767 mp->m_sb.sb_frextents = lcounter;
Jesper Juhl014c2542006-01-15 02:37:08 +01001768 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001769 case XFS_SBS_DBLOCKS:
1770 lcounter = (long long)mp->m_sb.sb_dblocks;
1771 lcounter += delta;
1772 if (lcounter < 0) {
1773 ASSERT(0);
Jesper Juhl014c2542006-01-15 02:37:08 +01001774 return XFS_ERROR(EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001775 }
1776 mp->m_sb.sb_dblocks = lcounter;
Jesper Juhl014c2542006-01-15 02:37:08 +01001777 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001778 case XFS_SBS_AGCOUNT:
1779 scounter = mp->m_sb.sb_agcount;
1780 scounter += delta;
1781 if (scounter < 0) {
1782 ASSERT(0);
Jesper Juhl014c2542006-01-15 02:37:08 +01001783 return XFS_ERROR(EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001784 }
1785 mp->m_sb.sb_agcount = scounter;
Jesper Juhl014c2542006-01-15 02:37:08 +01001786 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001787 case XFS_SBS_IMAX_PCT:
1788 scounter = mp->m_sb.sb_imax_pct;
1789 scounter += delta;
1790 if (scounter < 0) {
1791 ASSERT(0);
Jesper Juhl014c2542006-01-15 02:37:08 +01001792 return XFS_ERROR(EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001793 }
1794 mp->m_sb.sb_imax_pct = scounter;
Jesper Juhl014c2542006-01-15 02:37:08 +01001795 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001796 case XFS_SBS_REXTSIZE:
1797 scounter = mp->m_sb.sb_rextsize;
1798 scounter += delta;
1799 if (scounter < 0) {
1800 ASSERT(0);
Jesper Juhl014c2542006-01-15 02:37:08 +01001801 return XFS_ERROR(EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001802 }
1803 mp->m_sb.sb_rextsize = scounter;
Jesper Juhl014c2542006-01-15 02:37:08 +01001804 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001805 case XFS_SBS_RBMBLOCKS:
1806 scounter = mp->m_sb.sb_rbmblocks;
1807 scounter += delta;
1808 if (scounter < 0) {
1809 ASSERT(0);
Jesper Juhl014c2542006-01-15 02:37:08 +01001810 return XFS_ERROR(EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001811 }
1812 mp->m_sb.sb_rbmblocks = scounter;
Jesper Juhl014c2542006-01-15 02:37:08 +01001813 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001814 case XFS_SBS_RBLOCKS:
1815 lcounter = (long long)mp->m_sb.sb_rblocks;
1816 lcounter += delta;
1817 if (lcounter < 0) {
1818 ASSERT(0);
Jesper Juhl014c2542006-01-15 02:37:08 +01001819 return XFS_ERROR(EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001820 }
1821 mp->m_sb.sb_rblocks = lcounter;
Jesper Juhl014c2542006-01-15 02:37:08 +01001822 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001823 case XFS_SBS_REXTENTS:
1824 lcounter = (long long)mp->m_sb.sb_rextents;
1825 lcounter += delta;
1826 if (lcounter < 0) {
1827 ASSERT(0);
Jesper Juhl014c2542006-01-15 02:37:08 +01001828 return XFS_ERROR(EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001829 }
1830 mp->m_sb.sb_rextents = lcounter;
Jesper Juhl014c2542006-01-15 02:37:08 +01001831 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001832 case XFS_SBS_REXTSLOG:
1833 scounter = mp->m_sb.sb_rextslog;
1834 scounter += delta;
1835 if (scounter < 0) {
1836 ASSERT(0);
Jesper Juhl014c2542006-01-15 02:37:08 +01001837 return XFS_ERROR(EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001838 }
1839 mp->m_sb.sb_rextslog = scounter;
Jesper Juhl014c2542006-01-15 02:37:08 +01001840 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001841 default:
1842 ASSERT(0);
Jesper Juhl014c2542006-01-15 02:37:08 +01001843 return XFS_ERROR(EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001844 }
1845}
1846
1847/*
1848 * xfs_mod_incore_sb() is used to change a field in the in-core
1849 * superblock structure by the specified delta. This modification
Eric Sandeen3685c2a2007-10-11 17:42:32 +10001850 * is protected by the m_sb_lock. Just use the xfs_mod_incore_sb_unlocked()
Linus Torvalds1da177e2005-04-16 15:20:36 -07001851 * routine to do the work.
1852 */
1853int
David Chinner20f4ebf2007-02-10 18:36:10 +11001854xfs_mod_incore_sb(
1855 xfs_mount_t *mp,
1856 xfs_sb_field_t field,
1857 int64_t delta,
1858 int rsvd)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001859{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001860 int status;
1861
David Chinner8d280b92006-03-14 13:13:09 +11001862 /* check for per-cpu counters */
1863 switch (field) {
1864#ifdef HAVE_PERCPU_SB
1865 case XFS_SBS_ICOUNT:
1866 case XFS_SBS_IFREE:
1867 case XFS_SBS_FDBLOCKS:
1868 if (!(mp->m_flags & XFS_MOUNT_NO_PERCPU_SB)) {
1869 status = xfs_icsb_modify_counters(mp, field,
1870 delta, rsvd);
1871 break;
1872 }
1873 /* FALLTHROUGH */
1874#endif
1875 default:
Eric Sandeen3685c2a2007-10-11 17:42:32 +10001876 spin_lock(&mp->m_sb_lock);
David Chinner8d280b92006-03-14 13:13:09 +11001877 status = xfs_mod_incore_sb_unlocked(mp, field, delta, rsvd);
Eric Sandeen3685c2a2007-10-11 17:42:32 +10001878 spin_unlock(&mp->m_sb_lock);
David Chinner8d280b92006-03-14 13:13:09 +11001879 break;
1880 }
1881
Jesper Juhl014c2542006-01-15 02:37:08 +01001882 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001883}
1884
1885/*
1886 * xfs_mod_incore_sb_batch() is used to change more than one field
1887 * in the in-core superblock structure at a time. This modification
1888 * is protected by a lock internal to this module. The fields and
1889 * changes to those fields are specified in the array of xfs_mod_sb
1890 * structures passed in.
1891 *
1892 * Either all of the specified deltas will be applied or none of
1893 * them will. If any modified field dips below 0, then all modifications
1894 * will be backed out and EINVAL will be returned.
1895 */
1896int
1897xfs_mod_incore_sb_batch(xfs_mount_t *mp, xfs_mod_sb_t *msb, uint nmsb, int rsvd)
1898{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001899 int status=0;
1900 xfs_mod_sb_t *msbp;
1901
1902 /*
1903 * Loop through the array of mod structures and apply each
1904 * individually. If any fail, then back out all those
1905 * which have already been applied. Do all of this within
Eric Sandeen3685c2a2007-10-11 17:42:32 +10001906 * the scope of the m_sb_lock so that all of the changes will
Linus Torvalds1da177e2005-04-16 15:20:36 -07001907 * be atomic.
1908 */
Eric Sandeen3685c2a2007-10-11 17:42:32 +10001909 spin_lock(&mp->m_sb_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001910 msbp = &msb[0];
1911 for (msbp = &msbp[0]; msbp < (msb + nmsb); msbp++) {
1912 /*
1913 * Apply the delta at index n. If it fails, break
1914 * from the loop so we'll fall into the undo loop
1915 * below.
1916 */
David Chinner8d280b92006-03-14 13:13:09 +11001917 switch (msbp->msb_field) {
1918#ifdef HAVE_PERCPU_SB
1919 case XFS_SBS_ICOUNT:
1920 case XFS_SBS_IFREE:
1921 case XFS_SBS_FDBLOCKS:
1922 if (!(mp->m_flags & XFS_MOUNT_NO_PERCPU_SB)) {
Eric Sandeen3685c2a2007-10-11 17:42:32 +10001923 spin_unlock(&mp->m_sb_lock);
David Chinner20b64282007-02-10 18:35:09 +11001924 status = xfs_icsb_modify_counters(mp,
David Chinner8d280b92006-03-14 13:13:09 +11001925 msbp->msb_field,
1926 msbp->msb_delta, rsvd);
Eric Sandeen3685c2a2007-10-11 17:42:32 +10001927 spin_lock(&mp->m_sb_lock);
David Chinner8d280b92006-03-14 13:13:09 +11001928 break;
1929 }
1930 /* FALLTHROUGH */
1931#endif
1932 default:
1933 status = xfs_mod_incore_sb_unlocked(mp,
1934 msbp->msb_field,
1935 msbp->msb_delta, rsvd);
1936 break;
1937 }
1938
Linus Torvalds1da177e2005-04-16 15:20:36 -07001939 if (status != 0) {
1940 break;
1941 }
1942 }
1943
1944 /*
1945 * If we didn't complete the loop above, then back out
1946 * any changes made to the superblock. If you add code
1947 * between the loop above and here, make sure that you
1948 * preserve the value of status. Loop back until
1949 * we step below the beginning of the array. Make sure
1950 * we don't touch anything back there.
1951 */
1952 if (status != 0) {
1953 msbp--;
1954 while (msbp >= msb) {
David Chinner8d280b92006-03-14 13:13:09 +11001955 switch (msbp->msb_field) {
1956#ifdef HAVE_PERCPU_SB
1957 case XFS_SBS_ICOUNT:
1958 case XFS_SBS_IFREE:
1959 case XFS_SBS_FDBLOCKS:
1960 if (!(mp->m_flags & XFS_MOUNT_NO_PERCPU_SB)) {
Eric Sandeen3685c2a2007-10-11 17:42:32 +10001961 spin_unlock(&mp->m_sb_lock);
David Chinner20b64282007-02-10 18:35:09 +11001962 status = xfs_icsb_modify_counters(mp,
David Chinner8d280b92006-03-14 13:13:09 +11001963 msbp->msb_field,
1964 -(msbp->msb_delta),
1965 rsvd);
Eric Sandeen3685c2a2007-10-11 17:42:32 +10001966 spin_lock(&mp->m_sb_lock);
David Chinner8d280b92006-03-14 13:13:09 +11001967 break;
1968 }
1969 /* FALLTHROUGH */
1970#endif
1971 default:
1972 status = xfs_mod_incore_sb_unlocked(mp,
1973 msbp->msb_field,
1974 -(msbp->msb_delta),
1975 rsvd);
1976 break;
1977 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001978 ASSERT(status == 0);
1979 msbp--;
1980 }
1981 }
Eric Sandeen3685c2a2007-10-11 17:42:32 +10001982 spin_unlock(&mp->m_sb_lock);
Jesper Juhl014c2542006-01-15 02:37:08 +01001983 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001984}
1985
1986/*
1987 * xfs_getsb() is called to obtain the buffer for the superblock.
1988 * The buffer is returned locked and read in from disk.
1989 * The buffer should be released with a call to xfs_brelse().
1990 *
1991 * If the flags parameter is BUF_TRYLOCK, then we'll only return
1992 * the superblock buffer if it can be locked without sleeping.
1993 * If it can't then we'll return NULL.
1994 */
1995xfs_buf_t *
1996xfs_getsb(
1997 xfs_mount_t *mp,
1998 int flags)
1999{
2000 xfs_buf_t *bp;
2001
2002 ASSERT(mp->m_sb_bp != NULL);
2003 bp = mp->m_sb_bp;
Christoph Hellwig0cadda12010-01-19 09:56:44 +00002004 if (flags & XBF_TRYLOCK) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002005 if (!XFS_BUF_CPSEMA(bp)) {
2006 return NULL;
2007 }
2008 } else {
2009 XFS_BUF_PSEMA(bp, PRIBIO);
2010 }
2011 XFS_BUF_HOLD(bp);
2012 ASSERT(XFS_BUF_ISDONE(bp));
Jesper Juhl014c2542006-01-15 02:37:08 +01002013 return bp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002014}
2015
2016/*
2017 * Used to free the superblock along various error paths.
2018 */
2019void
2020xfs_freesb(
2021 xfs_mount_t *mp)
2022{
2023 xfs_buf_t *bp;
2024
2025 /*
2026 * Use xfs_getsb() so that the buffer will be locked
2027 * when we call xfs_buf_relse().
2028 */
2029 bp = xfs_getsb(mp, 0);
2030 XFS_BUF_UNMANAGE(bp);
2031 xfs_buf_relse(bp);
2032 mp->m_sb_bp = NULL;
2033}
2034
2035/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002036 * Used to log changes to the superblock unit and width fields which could
Eric Sandeene6957ea2008-04-10 12:19:34 +10002037 * be altered by the mount options, as well as any potential sb_features2
2038 * fixup. Only the first superblock is updated.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002039 */
Christoph Hellwig7884bc82009-01-19 02:04:07 +01002040int
David Chinneree1c0902008-03-06 13:45:50 +11002041xfs_mount_log_sb(
Linus Torvalds1da177e2005-04-16 15:20:36 -07002042 xfs_mount_t *mp,
2043 __int64_t fields)
2044{
2045 xfs_trans_t *tp;
David Chinnere5720ee2008-04-10 12:21:18 +10002046 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002047
David Chinneree1c0902008-03-06 13:45:50 +11002048 ASSERT(fields & (XFS_SB_UNIT | XFS_SB_WIDTH | XFS_SB_UUID |
David Chinner4b166de2008-05-20 11:30:27 +10002049 XFS_SB_FEATURES2 | XFS_SB_BAD_FEATURES2 |
2050 XFS_SB_VERSIONNUM));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002051
2052 tp = xfs_trans_alloc(mp, XFS_TRANS_SB_UNIT);
David Chinnere5720ee2008-04-10 12:21:18 +10002053 error = xfs_trans_reserve(tp, 0, mp->m_sb.sb_sectsize + 128, 0, 0,
2054 XFS_DEFAULT_LOG_COUNT);
2055 if (error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002056 xfs_trans_cancel(tp, 0);
David Chinnere5720ee2008-04-10 12:21:18 +10002057 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002058 }
2059 xfs_mod_sb(tp, fields);
David Chinnere5720ee2008-04-10 12:21:18 +10002060 error = xfs_trans_commit(tp, 0);
2061 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002062}
David Chinner8d280b92006-03-14 13:13:09 +11002063
Christoph Hellwigdda35b82010-02-15 09:44:46 +00002064/*
2065 * If the underlying (data/log/rt) device is readonly, there are some
2066 * operations that cannot proceed.
2067 */
2068int
2069xfs_dev_is_read_only(
2070 struct xfs_mount *mp,
2071 char *message)
2072{
2073 if (xfs_readonly_buftarg(mp->m_ddev_targp) ||
2074 xfs_readonly_buftarg(mp->m_logdev_targp) ||
2075 (mp->m_rtdev_targp && xfs_readonly_buftarg(mp->m_rtdev_targp))) {
2076 cmn_err(CE_NOTE,
2077 "XFS: %s required on read-only device.", message);
2078 cmn_err(CE_NOTE,
2079 "XFS: write access unavailable, cannot proceed.");
2080 return EROFS;
2081 }
2082 return 0;
2083}
David Chinner8d280b92006-03-14 13:13:09 +11002084
2085#ifdef HAVE_PERCPU_SB
2086/*
2087 * Per-cpu incore superblock counters
2088 *
2089 * Simple concept, difficult implementation
2090 *
2091 * Basically, replace the incore superblock counters with a distributed per cpu
2092 * counter for contended fields (e.g. free block count).
2093 *
2094 * Difficulties arise in that the incore sb is used for ENOSPC checking, and
2095 * hence needs to be accurately read when we are running low on space. Hence
2096 * there is a method to enable and disable the per-cpu counters based on how
2097 * much "stuff" is available in them.
2098 *
2099 * Basically, a counter is enabled if there is enough free resource to justify
2100 * running a per-cpu fast-path. If the per-cpu counter runs out (i.e. a local
2101 * ENOSPC), then we disable the counters to synchronise all callers and
2102 * re-distribute the available resources.
2103 *
2104 * If, once we redistributed the available resources, we still get a failure,
2105 * we disable the per-cpu counter and go through the slow path.
2106 *
2107 * The slow path is the current xfs_mod_incore_sb() function. This means that
Malcolm Parsons9da096f2009-03-29 09:55:42 +02002108 * when we disable a per-cpu counter, we need to drain its resources back to
David Chinner8d280b92006-03-14 13:13:09 +11002109 * the global superblock. We do this after disabling the counter to prevent
2110 * more threads from queueing up on the counter.
2111 *
2112 * Essentially, this means that we still need a lock in the fast path to enable
2113 * synchronisation between the global counters and the per-cpu counters. This
2114 * is not a problem because the lock will be local to a CPU almost all the time
2115 * and have little contention except when we get to ENOSPC conditions.
2116 *
2117 * Basically, this lock becomes a barrier that enables us to lock out the fast
2118 * path while we do things like enabling and disabling counters and
2119 * synchronising the counters.
2120 *
2121 * Locking rules:
2122 *
Eric Sandeen3685c2a2007-10-11 17:42:32 +10002123 * 1. m_sb_lock before picking up per-cpu locks
David Chinner8d280b92006-03-14 13:13:09 +11002124 * 2. per-cpu locks always picked up via for_each_online_cpu() order
Eric Sandeen3685c2a2007-10-11 17:42:32 +10002125 * 3. accurate counter sync requires m_sb_lock + per cpu locks
David Chinner8d280b92006-03-14 13:13:09 +11002126 * 4. modifying per-cpu counters requires holding per-cpu lock
Eric Sandeen3685c2a2007-10-11 17:42:32 +10002127 * 5. modifying global counters requires holding m_sb_lock
2128 * 6. enabling or disabling a counter requires holding the m_sb_lock
David Chinner8d280b92006-03-14 13:13:09 +11002129 * and _none_ of the per-cpu locks.
2130 *
2131 * Disabled counters are only ever re-enabled by a balance operation
2132 * that results in more free resources per CPU than a given threshold.
2133 * To ensure counters don't remain disabled, they are rebalanced when
2134 * the global resource goes above a higher threshold (i.e. some hysteresis
2135 * is present to prevent thrashing).
David Chinner8d280b92006-03-14 13:13:09 +11002136 */
David Chinnere8234a62006-03-14 13:23:52 +11002137
Chandra Seetharaman5a67e4c2006-06-27 02:54:11 -07002138#ifdef CONFIG_HOTPLUG_CPU
David Chinnere8234a62006-03-14 13:23:52 +11002139/*
2140 * hot-plug CPU notifier support.
2141 *
Chandra Seetharaman5a67e4c2006-06-27 02:54:11 -07002142 * We need a notifier per filesystem as we need to be able to identify
2143 * the filesystem to balance the counters out. This is achieved by
2144 * having a notifier block embedded in the xfs_mount_t and doing pointer
2145 * magic to get the mount pointer from the notifier block address.
David Chinnere8234a62006-03-14 13:23:52 +11002146 */
2147STATIC int
2148xfs_icsb_cpu_notify(
2149 struct notifier_block *nfb,
2150 unsigned long action,
2151 void *hcpu)
2152{
2153 xfs_icsb_cnts_t *cntp;
2154 xfs_mount_t *mp;
David Chinnere8234a62006-03-14 13:23:52 +11002155
2156 mp = (xfs_mount_t *)container_of(nfb, xfs_mount_t, m_icsb_notifier);
2157 cntp = (xfs_icsb_cnts_t *)
2158 per_cpu_ptr(mp->m_sb_cnts, (unsigned long)hcpu);
2159 switch (action) {
2160 case CPU_UP_PREPARE:
Rafael J. Wysocki8bb78442007-05-09 02:35:10 -07002161 case CPU_UP_PREPARE_FROZEN:
David Chinnere8234a62006-03-14 13:23:52 +11002162 /* Easy Case - initialize the area and locks, and
2163 * then rebalance when online does everything else for us. */
David Chinner01e1b692006-03-14 13:29:16 +11002164 memset(cntp, 0, sizeof(xfs_icsb_cnts_t));
David Chinnere8234a62006-03-14 13:23:52 +11002165 break;
2166 case CPU_ONLINE:
Rafael J. Wysocki8bb78442007-05-09 02:35:10 -07002167 case CPU_ONLINE_FROZEN:
David Chinner03135cf2007-02-10 18:35:15 +11002168 xfs_icsb_lock(mp);
Christoph Hellwig45af6c62008-04-22 17:34:44 +10002169 xfs_icsb_balance_counter(mp, XFS_SBS_ICOUNT, 0);
2170 xfs_icsb_balance_counter(mp, XFS_SBS_IFREE, 0);
2171 xfs_icsb_balance_counter(mp, XFS_SBS_FDBLOCKS, 0);
David Chinner03135cf2007-02-10 18:35:15 +11002172 xfs_icsb_unlock(mp);
David Chinnere8234a62006-03-14 13:23:52 +11002173 break;
2174 case CPU_DEAD:
Rafael J. Wysocki8bb78442007-05-09 02:35:10 -07002175 case CPU_DEAD_FROZEN:
David Chinnere8234a62006-03-14 13:23:52 +11002176 /* Disable all the counters, then fold the dead cpu's
2177 * count into the total on the global superblock and
2178 * re-enable the counters. */
David Chinner03135cf2007-02-10 18:35:15 +11002179 xfs_icsb_lock(mp);
Eric Sandeen3685c2a2007-10-11 17:42:32 +10002180 spin_lock(&mp->m_sb_lock);
David Chinnere8234a62006-03-14 13:23:52 +11002181 xfs_icsb_disable_counter(mp, XFS_SBS_ICOUNT);
2182 xfs_icsb_disable_counter(mp, XFS_SBS_IFREE);
2183 xfs_icsb_disable_counter(mp, XFS_SBS_FDBLOCKS);
2184
2185 mp->m_sb.sb_icount += cntp->icsb_icount;
2186 mp->m_sb.sb_ifree += cntp->icsb_ifree;
2187 mp->m_sb.sb_fdblocks += cntp->icsb_fdblocks;
2188
David Chinner01e1b692006-03-14 13:29:16 +11002189 memset(cntp, 0, sizeof(xfs_icsb_cnts_t));
David Chinnere8234a62006-03-14 13:23:52 +11002190
Christoph Hellwig45af6c62008-04-22 17:34:44 +10002191 xfs_icsb_balance_counter_locked(mp, XFS_SBS_ICOUNT, 0);
2192 xfs_icsb_balance_counter_locked(mp, XFS_SBS_IFREE, 0);
2193 xfs_icsb_balance_counter_locked(mp, XFS_SBS_FDBLOCKS, 0);
Eric Sandeen3685c2a2007-10-11 17:42:32 +10002194 spin_unlock(&mp->m_sb_lock);
David Chinner03135cf2007-02-10 18:35:15 +11002195 xfs_icsb_unlock(mp);
David Chinnere8234a62006-03-14 13:23:52 +11002196 break;
2197 }
2198
2199 return NOTIFY_OK;
2200}
Chandra Seetharaman5a67e4c2006-06-27 02:54:11 -07002201#endif /* CONFIG_HOTPLUG_CPU */
David Chinnere8234a62006-03-14 13:23:52 +11002202
David Chinner8d280b92006-03-14 13:13:09 +11002203int
2204xfs_icsb_init_counters(
2205 xfs_mount_t *mp)
2206{
2207 xfs_icsb_cnts_t *cntp;
2208 int i;
2209
2210 mp->m_sb_cnts = alloc_percpu(xfs_icsb_cnts_t);
2211 if (mp->m_sb_cnts == NULL)
2212 return -ENOMEM;
2213
Chandra Seetharaman5a67e4c2006-06-27 02:54:11 -07002214#ifdef CONFIG_HOTPLUG_CPU
David Chinnere8234a62006-03-14 13:23:52 +11002215 mp->m_icsb_notifier.notifier_call = xfs_icsb_cpu_notify;
2216 mp->m_icsb_notifier.priority = 0;
Chandra Seetharaman5a67e4c2006-06-27 02:54:11 -07002217 register_hotcpu_notifier(&mp->m_icsb_notifier);
2218#endif /* CONFIG_HOTPLUG_CPU */
David Chinnere8234a62006-03-14 13:23:52 +11002219
David Chinner8d280b92006-03-14 13:13:09 +11002220 for_each_online_cpu(i) {
2221 cntp = (xfs_icsb_cnts_t *)per_cpu_ptr(mp->m_sb_cnts, i);
David Chinner01e1b692006-03-14 13:29:16 +11002222 memset(cntp, 0, sizeof(xfs_icsb_cnts_t));
David Chinner8d280b92006-03-14 13:13:09 +11002223 }
David Chinner20b64282007-02-10 18:35:09 +11002224
2225 mutex_init(&mp->m_icsb_mutex);
2226
David Chinner8d280b92006-03-14 13:13:09 +11002227 /*
2228 * start with all counters disabled so that the
2229 * initial balance kicks us off correctly
2230 */
2231 mp->m_icsb_counters = -1;
2232 return 0;
2233}
2234
Lachlan McIlroy5478eea2007-02-10 18:36:29 +11002235void
2236xfs_icsb_reinit_counters(
2237 xfs_mount_t *mp)
2238{
2239 xfs_icsb_lock(mp);
2240 /*
2241 * start with all counters disabled so that the
2242 * initial balance kicks us off correctly
2243 */
2244 mp->m_icsb_counters = -1;
Christoph Hellwig45af6c62008-04-22 17:34:44 +10002245 xfs_icsb_balance_counter(mp, XFS_SBS_ICOUNT, 0);
2246 xfs_icsb_balance_counter(mp, XFS_SBS_IFREE, 0);
2247 xfs_icsb_balance_counter(mp, XFS_SBS_FDBLOCKS, 0);
Lachlan McIlroy5478eea2007-02-10 18:36:29 +11002248 xfs_icsb_unlock(mp);
2249}
2250
Christoph Hellwigc962fb72008-05-20 15:10:52 +10002251void
David Chinner8d280b92006-03-14 13:13:09 +11002252xfs_icsb_destroy_counters(
2253 xfs_mount_t *mp)
2254{
David Chinnere8234a62006-03-14 13:23:52 +11002255 if (mp->m_sb_cnts) {
Chandra Seetharaman5a67e4c2006-06-27 02:54:11 -07002256 unregister_hotcpu_notifier(&mp->m_icsb_notifier);
David Chinner8d280b92006-03-14 13:13:09 +11002257 free_percpu(mp->m_sb_cnts);
David Chinnere8234a62006-03-14 13:23:52 +11002258 }
David Chinner03135cf2007-02-10 18:35:15 +11002259 mutex_destroy(&mp->m_icsb_mutex);
David Chinner8d280b92006-03-14 13:13:09 +11002260}
2261
Christoph Hellwigb8f82a42009-11-14 16:17:22 +00002262STATIC void
David Chinner01e1b692006-03-14 13:29:16 +11002263xfs_icsb_lock_cntr(
2264 xfs_icsb_cnts_t *icsbp)
2265{
2266 while (test_and_set_bit(XFS_ICSB_FLAG_LOCK, &icsbp->icsb_flags)) {
2267 ndelay(1000);
2268 }
2269}
2270
Christoph Hellwigb8f82a42009-11-14 16:17:22 +00002271STATIC void
David Chinner01e1b692006-03-14 13:29:16 +11002272xfs_icsb_unlock_cntr(
2273 xfs_icsb_cnts_t *icsbp)
2274{
2275 clear_bit(XFS_ICSB_FLAG_LOCK, &icsbp->icsb_flags);
2276}
2277
David Chinner8d280b92006-03-14 13:13:09 +11002278
Christoph Hellwigb8f82a42009-11-14 16:17:22 +00002279STATIC void
David Chinner8d280b92006-03-14 13:13:09 +11002280xfs_icsb_lock_all_counters(
2281 xfs_mount_t *mp)
2282{
2283 xfs_icsb_cnts_t *cntp;
2284 int i;
2285
2286 for_each_online_cpu(i) {
2287 cntp = (xfs_icsb_cnts_t *)per_cpu_ptr(mp->m_sb_cnts, i);
David Chinner01e1b692006-03-14 13:29:16 +11002288 xfs_icsb_lock_cntr(cntp);
David Chinner8d280b92006-03-14 13:13:09 +11002289 }
2290}
2291
Christoph Hellwigb8f82a42009-11-14 16:17:22 +00002292STATIC void
David Chinner8d280b92006-03-14 13:13:09 +11002293xfs_icsb_unlock_all_counters(
2294 xfs_mount_t *mp)
2295{
2296 xfs_icsb_cnts_t *cntp;
2297 int i;
2298
2299 for_each_online_cpu(i) {
2300 cntp = (xfs_icsb_cnts_t *)per_cpu_ptr(mp->m_sb_cnts, i);
David Chinner01e1b692006-03-14 13:29:16 +11002301 xfs_icsb_unlock_cntr(cntp);
David Chinner8d280b92006-03-14 13:13:09 +11002302 }
2303}
2304
2305STATIC void
2306xfs_icsb_count(
2307 xfs_mount_t *mp,
2308 xfs_icsb_cnts_t *cnt,
2309 int flags)
2310{
2311 xfs_icsb_cnts_t *cntp;
2312 int i;
2313
2314 memset(cnt, 0, sizeof(xfs_icsb_cnts_t));
2315
2316 if (!(flags & XFS_ICSB_LAZY_COUNT))
2317 xfs_icsb_lock_all_counters(mp);
2318
2319 for_each_online_cpu(i) {
2320 cntp = (xfs_icsb_cnts_t *)per_cpu_ptr(mp->m_sb_cnts, i);
2321 cnt->icsb_icount += cntp->icsb_icount;
2322 cnt->icsb_ifree += cntp->icsb_ifree;
2323 cnt->icsb_fdblocks += cntp->icsb_fdblocks;
2324 }
2325
2326 if (!(flags & XFS_ICSB_LAZY_COUNT))
2327 xfs_icsb_unlock_all_counters(mp);
2328}
2329
2330STATIC int
2331xfs_icsb_counter_disabled(
2332 xfs_mount_t *mp,
2333 xfs_sb_field_t field)
2334{
2335 ASSERT((field >= XFS_SBS_ICOUNT) && (field <= XFS_SBS_FDBLOCKS));
2336 return test_bit(field, &mp->m_icsb_counters);
2337}
2338
David Chinner36fbe6e2008-04-10 12:19:56 +10002339STATIC void
David Chinner8d280b92006-03-14 13:13:09 +11002340xfs_icsb_disable_counter(
2341 xfs_mount_t *mp,
2342 xfs_sb_field_t field)
2343{
2344 xfs_icsb_cnts_t cnt;
2345
2346 ASSERT((field >= XFS_SBS_ICOUNT) && (field <= XFS_SBS_FDBLOCKS));
2347
David Chinner20b64282007-02-10 18:35:09 +11002348 /*
2349 * If we are already disabled, then there is nothing to do
2350 * here. We check before locking all the counters to avoid
2351 * the expensive lock operation when being called in the
2352 * slow path and the counter is already disabled. This is
2353 * safe because the only time we set or clear this state is under
2354 * the m_icsb_mutex.
2355 */
2356 if (xfs_icsb_counter_disabled(mp, field))
David Chinner36fbe6e2008-04-10 12:19:56 +10002357 return;
David Chinner20b64282007-02-10 18:35:09 +11002358
David Chinner8d280b92006-03-14 13:13:09 +11002359 xfs_icsb_lock_all_counters(mp);
2360 if (!test_and_set_bit(field, &mp->m_icsb_counters)) {
2361 /* drain back to superblock */
2362
Christoph Hellwigce461932008-04-22 17:34:50 +10002363 xfs_icsb_count(mp, &cnt, XFS_ICSB_LAZY_COUNT);
David Chinner8d280b92006-03-14 13:13:09 +11002364 switch(field) {
2365 case XFS_SBS_ICOUNT:
2366 mp->m_sb.sb_icount = cnt.icsb_icount;
2367 break;
2368 case XFS_SBS_IFREE:
2369 mp->m_sb.sb_ifree = cnt.icsb_ifree;
2370 break;
2371 case XFS_SBS_FDBLOCKS:
2372 mp->m_sb.sb_fdblocks = cnt.icsb_fdblocks;
2373 break;
2374 default:
2375 BUG();
2376 }
2377 }
2378
2379 xfs_icsb_unlock_all_counters(mp);
David Chinner8d280b92006-03-14 13:13:09 +11002380}
2381
2382STATIC void
2383xfs_icsb_enable_counter(
2384 xfs_mount_t *mp,
2385 xfs_sb_field_t field,
2386 uint64_t count,
2387 uint64_t resid)
2388{
2389 xfs_icsb_cnts_t *cntp;
2390 int i;
2391
2392 ASSERT((field >= XFS_SBS_ICOUNT) && (field <= XFS_SBS_FDBLOCKS));
2393
2394 xfs_icsb_lock_all_counters(mp);
2395 for_each_online_cpu(i) {
2396 cntp = per_cpu_ptr(mp->m_sb_cnts, i);
2397 switch (field) {
2398 case XFS_SBS_ICOUNT:
2399 cntp->icsb_icount = count + resid;
2400 break;
2401 case XFS_SBS_IFREE:
2402 cntp->icsb_ifree = count + resid;
2403 break;
2404 case XFS_SBS_FDBLOCKS:
2405 cntp->icsb_fdblocks = count + resid;
2406 break;
2407 default:
2408 BUG();
2409 break;
2410 }
2411 resid = 0;
2412 }
2413 clear_bit(field, &mp->m_icsb_counters);
2414 xfs_icsb_unlock_all_counters(mp);
2415}
2416
David Chinnerdbcabad2007-02-10 18:36:17 +11002417void
Christoph Hellwigd4d90b52008-04-22 17:34:37 +10002418xfs_icsb_sync_counters_locked(
David Chinner8d280b92006-03-14 13:13:09 +11002419 xfs_mount_t *mp,
2420 int flags)
2421{
2422 xfs_icsb_cnts_t cnt;
David Chinner8d280b92006-03-14 13:13:09 +11002423
David Chinner8d280b92006-03-14 13:13:09 +11002424 xfs_icsb_count(mp, &cnt, flags);
2425
David Chinner8d280b92006-03-14 13:13:09 +11002426 if (!xfs_icsb_counter_disabled(mp, XFS_SBS_ICOUNT))
2427 mp->m_sb.sb_icount = cnt.icsb_icount;
2428 if (!xfs_icsb_counter_disabled(mp, XFS_SBS_IFREE))
2429 mp->m_sb.sb_ifree = cnt.icsb_ifree;
2430 if (!xfs_icsb_counter_disabled(mp, XFS_SBS_FDBLOCKS))
2431 mp->m_sb.sb_fdblocks = cnt.icsb_fdblocks;
David Chinner8d280b92006-03-14 13:13:09 +11002432}
2433
2434/*
2435 * Accurate update of per-cpu counters to incore superblock
2436 */
Christoph Hellwigd4d90b52008-04-22 17:34:37 +10002437void
David Chinner8d280b92006-03-14 13:13:09 +11002438xfs_icsb_sync_counters(
Christoph Hellwigd4d90b52008-04-22 17:34:37 +10002439 xfs_mount_t *mp,
2440 int flags)
David Chinner8d280b92006-03-14 13:13:09 +11002441{
Christoph Hellwigd4d90b52008-04-22 17:34:37 +10002442 spin_lock(&mp->m_sb_lock);
2443 xfs_icsb_sync_counters_locked(mp, flags);
2444 spin_unlock(&mp->m_sb_lock);
David Chinner8d280b92006-03-14 13:13:09 +11002445}
2446
2447/*
2448 * Balance and enable/disable counters as necessary.
2449 *
David Chinner20b64282007-02-10 18:35:09 +11002450 * Thresholds for re-enabling counters are somewhat magic. inode counts are
2451 * chosen to be the same number as single on disk allocation chunk per CPU, and
2452 * free blocks is something far enough zero that we aren't going thrash when we
2453 * get near ENOSPC. We also need to supply a minimum we require per cpu to
2454 * prevent looping endlessly when xfs_alloc_space asks for more than will
2455 * be distributed to a single CPU but each CPU has enough blocks to be
2456 * reenabled.
2457 *
2458 * Note that we can be called when counters are already disabled.
2459 * xfs_icsb_disable_counter() optimises the counter locking in this case to
2460 * prevent locking every per-cpu counter needlessly.
David Chinner8d280b92006-03-14 13:13:09 +11002461 */
David Chinner20b64282007-02-10 18:35:09 +11002462
2463#define XFS_ICSB_INO_CNTR_REENABLE (uint64_t)64
David Chinner4be536d2006-09-07 14:26:50 +10002464#define XFS_ICSB_FDBLK_CNTR_REENABLE(mp) \
David Chinner20b64282007-02-10 18:35:09 +11002465 (uint64_t)(512 + XFS_ALLOC_SET_ASIDE(mp))
David Chinner8d280b92006-03-14 13:13:09 +11002466STATIC void
Christoph Hellwig45af6c62008-04-22 17:34:44 +10002467xfs_icsb_balance_counter_locked(
David Chinner8d280b92006-03-14 13:13:09 +11002468 xfs_mount_t *mp,
2469 xfs_sb_field_t field,
David Chinner20b64282007-02-10 18:35:09 +11002470 int min_per_cpu)
David Chinner8d280b92006-03-14 13:13:09 +11002471{
Nathan Scott6fdf8cc2006-06-28 10:13:52 +10002472 uint64_t count, resid;
David Chinner8d280b92006-03-14 13:13:09 +11002473 int weight = num_online_cpus();
David Chinner20b64282007-02-10 18:35:09 +11002474 uint64_t min = (uint64_t)min_per_cpu;
David Chinner8d280b92006-03-14 13:13:09 +11002475
David Chinner8d280b92006-03-14 13:13:09 +11002476 /* disable counter and sync counter */
2477 xfs_icsb_disable_counter(mp, field);
2478
2479 /* update counters - first CPU gets residual*/
2480 switch (field) {
2481 case XFS_SBS_ICOUNT:
2482 count = mp->m_sb.sb_icount;
2483 resid = do_div(count, weight);
David Chinner20b64282007-02-10 18:35:09 +11002484 if (count < max(min, XFS_ICSB_INO_CNTR_REENABLE))
Christoph Hellwig45af6c62008-04-22 17:34:44 +10002485 return;
David Chinner8d280b92006-03-14 13:13:09 +11002486 break;
2487 case XFS_SBS_IFREE:
2488 count = mp->m_sb.sb_ifree;
2489 resid = do_div(count, weight);
David Chinner20b64282007-02-10 18:35:09 +11002490 if (count < max(min, XFS_ICSB_INO_CNTR_REENABLE))
Christoph Hellwig45af6c62008-04-22 17:34:44 +10002491 return;
David Chinner8d280b92006-03-14 13:13:09 +11002492 break;
2493 case XFS_SBS_FDBLOCKS:
2494 count = mp->m_sb.sb_fdblocks;
2495 resid = do_div(count, weight);
David Chinner20b64282007-02-10 18:35:09 +11002496 if (count < max(min, XFS_ICSB_FDBLK_CNTR_REENABLE(mp)))
Christoph Hellwig45af6c62008-04-22 17:34:44 +10002497 return;
David Chinner8d280b92006-03-14 13:13:09 +11002498 break;
2499 default:
2500 BUG();
Nathan Scott6fdf8cc2006-06-28 10:13:52 +10002501 count = resid = 0; /* quiet, gcc */
David Chinner8d280b92006-03-14 13:13:09 +11002502 break;
2503 }
2504
2505 xfs_icsb_enable_counter(mp, field, count, resid);
Christoph Hellwig45af6c62008-04-22 17:34:44 +10002506}
2507
2508STATIC void
2509xfs_icsb_balance_counter(
2510 xfs_mount_t *mp,
2511 xfs_sb_field_t fields,
2512 int min_per_cpu)
2513{
2514 spin_lock(&mp->m_sb_lock);
2515 xfs_icsb_balance_counter_locked(mp, fields, min_per_cpu);
2516 spin_unlock(&mp->m_sb_lock);
David Chinner8d280b92006-03-14 13:13:09 +11002517}
2518
David Chinnera8272ce2007-11-23 16:28:09 +11002519STATIC int
David Chinner20b64282007-02-10 18:35:09 +11002520xfs_icsb_modify_counters(
David Chinner8d280b92006-03-14 13:13:09 +11002521 xfs_mount_t *mp,
2522 xfs_sb_field_t field,
David Chinner20f4ebf2007-02-10 18:36:10 +11002523 int64_t delta,
David Chinner20b64282007-02-10 18:35:09 +11002524 int rsvd)
David Chinner8d280b92006-03-14 13:13:09 +11002525{
2526 xfs_icsb_cnts_t *icsbp;
2527 long long lcounter; /* long counter for 64 bit fields */
Christoph Lameter7a9e02d2009-10-03 19:48:23 +09002528 int ret = 0;
David Chinner8d280b92006-03-14 13:13:09 +11002529
David Chinner20b64282007-02-10 18:35:09 +11002530 might_sleep();
David Chinner8d280b92006-03-14 13:13:09 +11002531again:
Christoph Lameter7a9e02d2009-10-03 19:48:23 +09002532 preempt_disable();
2533 icsbp = this_cpu_ptr(mp->m_sb_cnts);
David Chinner20b64282007-02-10 18:35:09 +11002534
2535 /*
2536 * if the counter is disabled, go to slow path
2537 */
David Chinner8d280b92006-03-14 13:13:09 +11002538 if (unlikely(xfs_icsb_counter_disabled(mp, field)))
2539 goto slow_path;
David Chinner20b64282007-02-10 18:35:09 +11002540 xfs_icsb_lock_cntr(icsbp);
2541 if (unlikely(xfs_icsb_counter_disabled(mp, field))) {
2542 xfs_icsb_unlock_cntr(icsbp);
2543 goto slow_path;
2544 }
David Chinner8d280b92006-03-14 13:13:09 +11002545
2546 switch (field) {
2547 case XFS_SBS_ICOUNT:
2548 lcounter = icsbp->icsb_icount;
2549 lcounter += delta;
2550 if (unlikely(lcounter < 0))
David Chinner20b64282007-02-10 18:35:09 +11002551 goto balance_counter;
David Chinner8d280b92006-03-14 13:13:09 +11002552 icsbp->icsb_icount = lcounter;
2553 break;
2554
2555 case XFS_SBS_IFREE:
2556 lcounter = icsbp->icsb_ifree;
2557 lcounter += delta;
2558 if (unlikely(lcounter < 0))
David Chinner20b64282007-02-10 18:35:09 +11002559 goto balance_counter;
David Chinner8d280b92006-03-14 13:13:09 +11002560 icsbp->icsb_ifree = lcounter;
2561 break;
2562
2563 case XFS_SBS_FDBLOCKS:
2564 BUG_ON((mp->m_resblks - mp->m_resblks_avail) != 0);
2565
David Chinner4be536d2006-09-07 14:26:50 +10002566 lcounter = icsbp->icsb_fdblocks - XFS_ALLOC_SET_ASIDE(mp);
David Chinner8d280b92006-03-14 13:13:09 +11002567 lcounter += delta;
2568 if (unlikely(lcounter < 0))
David Chinner20b64282007-02-10 18:35:09 +11002569 goto balance_counter;
David Chinner4be536d2006-09-07 14:26:50 +10002570 icsbp->icsb_fdblocks = lcounter + XFS_ALLOC_SET_ASIDE(mp);
David Chinner8d280b92006-03-14 13:13:09 +11002571 break;
2572 default:
2573 BUG();
2574 break;
2575 }
David Chinner01e1b692006-03-14 13:29:16 +11002576 xfs_icsb_unlock_cntr(icsbp);
Christoph Lameter7a9e02d2009-10-03 19:48:23 +09002577 preempt_enable();
David Chinner8d280b92006-03-14 13:13:09 +11002578 return 0;
2579
David Chinner8d280b92006-03-14 13:13:09 +11002580slow_path:
Christoph Lameter7a9e02d2009-10-03 19:48:23 +09002581 preempt_enable();
David Chinner20b64282007-02-10 18:35:09 +11002582
2583 /*
2584 * serialise with a mutex so we don't burn lots of cpu on
2585 * the superblock lock. We still need to hold the superblock
2586 * lock, however, when we modify the global structures.
2587 */
David Chinner03135cf2007-02-10 18:35:15 +11002588 xfs_icsb_lock(mp);
David Chinner20b64282007-02-10 18:35:09 +11002589
2590 /*
2591 * Now running atomically.
2592 *
2593 * If the counter is enabled, someone has beaten us to rebalancing.
2594 * Drop the lock and try again in the fast path....
2595 */
2596 if (!(xfs_icsb_counter_disabled(mp, field))) {
David Chinner03135cf2007-02-10 18:35:15 +11002597 xfs_icsb_unlock(mp);
David Chinner20b64282007-02-10 18:35:09 +11002598 goto again;
2599 }
2600
2601 /*
2602 * The counter is currently disabled. Because we are
2603 * running atomically here, we know a rebalance cannot
2604 * be in progress. Hence we can go straight to operating
2605 * on the global superblock. We do not call xfs_mod_incore_sb()
Eric Sandeen3685c2a2007-10-11 17:42:32 +10002606 * here even though we need to get the m_sb_lock. Doing so
David Chinner20b64282007-02-10 18:35:09 +11002607 * will cause us to re-enter this function and deadlock.
Eric Sandeen3685c2a2007-10-11 17:42:32 +10002608 * Hence we get the m_sb_lock ourselves and then call
David Chinner20b64282007-02-10 18:35:09 +11002609 * xfs_mod_incore_sb_unlocked() as the unlocked path operates
2610 * directly on the global counters.
2611 */
Eric Sandeen3685c2a2007-10-11 17:42:32 +10002612 spin_lock(&mp->m_sb_lock);
David Chinner20b64282007-02-10 18:35:09 +11002613 ret = xfs_mod_incore_sb_unlocked(mp, field, delta, rsvd);
Eric Sandeen3685c2a2007-10-11 17:42:32 +10002614 spin_unlock(&mp->m_sb_lock);
David Chinner20b64282007-02-10 18:35:09 +11002615
2616 /*
2617 * Now that we've modified the global superblock, we
2618 * may be able to re-enable the distributed counters
2619 * (e.g. lots of space just got freed). After that
2620 * we are done.
2621 */
2622 if (ret != ENOSPC)
Christoph Hellwig45af6c62008-04-22 17:34:44 +10002623 xfs_icsb_balance_counter(mp, field, 0);
David Chinner03135cf2007-02-10 18:35:15 +11002624 xfs_icsb_unlock(mp);
David Chinner20b64282007-02-10 18:35:09 +11002625 return ret;
2626
2627balance_counter:
David Chinner01e1b692006-03-14 13:29:16 +11002628 xfs_icsb_unlock_cntr(icsbp);
Christoph Lameter7a9e02d2009-10-03 19:48:23 +09002629 preempt_enable();
David Chinner8d280b92006-03-14 13:13:09 +11002630
David Chinner20b64282007-02-10 18:35:09 +11002631 /*
2632 * We may have multiple threads here if multiple per-cpu
2633 * counters run dry at the same time. This will mean we can
2634 * do more balances than strictly necessary but it is not
2635 * the common slowpath case.
2636 */
David Chinner03135cf2007-02-10 18:35:15 +11002637 xfs_icsb_lock(mp);
David Chinner8d280b92006-03-14 13:13:09 +11002638
David Chinner20b64282007-02-10 18:35:09 +11002639 /*
2640 * running atomically.
2641 *
2642 * This will leave the counter in the correct state for future
2643 * accesses. After the rebalance, we simply try again and our retry
2644 * will either succeed through the fast path or slow path without
2645 * another balance operation being required.
2646 */
Christoph Hellwig45af6c62008-04-22 17:34:44 +10002647 xfs_icsb_balance_counter(mp, field, delta);
David Chinner03135cf2007-02-10 18:35:15 +11002648 xfs_icsb_unlock(mp);
David Chinner20b64282007-02-10 18:35:09 +11002649 goto again;
David Chinner8d280b92006-03-14 13:13:09 +11002650}
2651
David Chinner8d280b92006-03-14 13:13:09 +11002652#endif