blob: eb348c168505aa11f0337529450a2aeaa2bdda1e [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"
Linus Torvalds1da177e2005-04-16 15:20:36 -070047
David Chinneree1c0902008-03-06 13:45:50 +110048STATIC void xfs_mount_log_sb(xfs_mount_t *, __int64_t);
Linus Torvalds1da177e2005-04-16 15:20:36 -070049STATIC int xfs_uuid_mount(xfs_mount_t *);
50STATIC void xfs_uuid_unmount(xfs_mount_t *mp);
Christoph Hellwigba0f32d2005-06-21 15:36:52 +100051STATIC void xfs_unmountfs_wait(xfs_mount_t *);
Linus Torvalds1da177e2005-04-16 15:20:36 -070052
David Chinner8d280b92006-03-14 13:13:09 +110053
54#ifdef HAVE_PERCPU_SB
55STATIC void xfs_icsb_destroy_counters(xfs_mount_t *);
David Chinner20f4ebf2007-02-10 18:36:10 +110056STATIC void xfs_icsb_balance_counter(xfs_mount_t *, xfs_sb_field_t,
57 int, int);
David Chinner8d280b92006-03-14 13:13:09 +110058STATIC void xfs_icsb_sync_counters(xfs_mount_t *);
59STATIC int xfs_icsb_modify_counters(xfs_mount_t *, xfs_sb_field_t,
David Chinner20f4ebf2007-02-10 18:36:10 +110060 int64_t, int);
David Chinner36fbe6e2008-04-10 12:19:56 +100061STATIC void xfs_icsb_disable_counter(xfs_mount_t *, xfs_sb_field_t);
David Chinner8d280b92006-03-14 13:13:09 +110062
63#else
64
65#define xfs_icsb_destroy_counters(mp) do { } while (0)
David Chinner20b64282007-02-10 18:35:09 +110066#define xfs_icsb_balance_counter(mp, a, b, c) do { } while (0)
David Chinner8d280b92006-03-14 13:13:09 +110067#define xfs_icsb_sync_counters(mp) do { } while (0)
68#define xfs_icsb_modify_counters(mp, a, b, c) do { } while (0)
David Chinner8d280b92006-03-14 13:13:09 +110069
70#endif
71
Christoph Hellwig1df84c92006-01-11 15:29:52 +110072static const struct {
David Chinner8d280b92006-03-14 13:13:09 +110073 short offset;
74 short type; /* 0 = integer
75 * 1 = binary / string (no translation)
76 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070077} xfs_sb_info[] = {
78 { offsetof(xfs_sb_t, sb_magicnum), 0 },
79 { offsetof(xfs_sb_t, sb_blocksize), 0 },
80 { offsetof(xfs_sb_t, sb_dblocks), 0 },
81 { offsetof(xfs_sb_t, sb_rblocks), 0 },
82 { offsetof(xfs_sb_t, sb_rextents), 0 },
83 { offsetof(xfs_sb_t, sb_uuid), 1 },
84 { offsetof(xfs_sb_t, sb_logstart), 0 },
85 { offsetof(xfs_sb_t, sb_rootino), 0 },
86 { offsetof(xfs_sb_t, sb_rbmino), 0 },
87 { offsetof(xfs_sb_t, sb_rsumino), 0 },
88 { offsetof(xfs_sb_t, sb_rextsize), 0 },
89 { offsetof(xfs_sb_t, sb_agblocks), 0 },
90 { offsetof(xfs_sb_t, sb_agcount), 0 },
91 { offsetof(xfs_sb_t, sb_rbmblocks), 0 },
92 { offsetof(xfs_sb_t, sb_logblocks), 0 },
93 { offsetof(xfs_sb_t, sb_versionnum), 0 },
94 { offsetof(xfs_sb_t, sb_sectsize), 0 },
95 { offsetof(xfs_sb_t, sb_inodesize), 0 },
96 { offsetof(xfs_sb_t, sb_inopblock), 0 },
97 { offsetof(xfs_sb_t, sb_fname[0]), 1 },
98 { offsetof(xfs_sb_t, sb_blocklog), 0 },
99 { offsetof(xfs_sb_t, sb_sectlog), 0 },
100 { offsetof(xfs_sb_t, sb_inodelog), 0 },
101 { offsetof(xfs_sb_t, sb_inopblog), 0 },
102 { offsetof(xfs_sb_t, sb_agblklog), 0 },
103 { offsetof(xfs_sb_t, sb_rextslog), 0 },
104 { offsetof(xfs_sb_t, sb_inprogress), 0 },
105 { offsetof(xfs_sb_t, sb_imax_pct), 0 },
106 { offsetof(xfs_sb_t, sb_icount), 0 },
107 { offsetof(xfs_sb_t, sb_ifree), 0 },
108 { offsetof(xfs_sb_t, sb_fdblocks), 0 },
109 { offsetof(xfs_sb_t, sb_frextents), 0 },
110 { offsetof(xfs_sb_t, sb_uquotino), 0 },
111 { offsetof(xfs_sb_t, sb_gquotino), 0 },
112 { offsetof(xfs_sb_t, sb_qflags), 0 },
113 { offsetof(xfs_sb_t, sb_flags), 0 },
114 { offsetof(xfs_sb_t, sb_shared_vn), 0 },
115 { offsetof(xfs_sb_t, sb_inoalignmt), 0 },
116 { offsetof(xfs_sb_t, sb_unit), 0 },
117 { offsetof(xfs_sb_t, sb_width), 0 },
118 { offsetof(xfs_sb_t, sb_dirblklog), 0 },
119 { offsetof(xfs_sb_t, sb_logsectlog), 0 },
120 { offsetof(xfs_sb_t, sb_logsectsize),0 },
121 { offsetof(xfs_sb_t, sb_logsunit), 0 },
122 { offsetof(xfs_sb_t, sb_features2), 0 },
David Chinneree1c0902008-03-06 13:45:50 +1100123 { offsetof(xfs_sb_t, sb_bad_features2), 0 },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124 { sizeof(xfs_sb_t), 0 }
125};
126
127/*
128 * Return a pointer to an initialized xfs_mount structure.
129 */
130xfs_mount_t *
131xfs_mount_init(void)
132{
133 xfs_mount_t *mp;
134
David Chinner8d280b92006-03-14 13:13:09 +1100135 mp = kmem_zalloc(sizeof(xfs_mount_t), KM_SLEEP);
136
137 if (xfs_icsb_init_counters(mp)) {
138 mp->m_flags |= XFS_MOUNT_NO_PERCPU_SB;
139 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140
Eric Sandeen007c61c2007-10-11 17:43:56 +1000141 spin_lock_init(&mp->m_sb_lock);
Jes Sorensen794ee1b2006-01-09 15:59:21 -0800142 mutex_init(&mp->m_ilock);
Christoph Hellwigcc92e7a2007-08-30 17:21:54 +1000143 mutex_init(&mp->m_growlock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144 atomic_set(&mp->m_active_trans, 0);
145
146 return mp;
147}
148
149/*
150 * Free up the resources associated with a mount structure. Assume that
151 * the structure was initially zeroed, so we can tell which fields got
152 * initialized.
153 */
154void
155xfs_mount_free(
Christoph Hellwig745f6912007-08-30 17:20:39 +1000156 xfs_mount_t *mp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158 if (mp->m_perag) {
159 int agno;
160
161 for (agno = 0; agno < mp->m_maxagi; agno++)
162 if (mp->m_perag[agno].pagb_list)
163 kmem_free(mp->m_perag[agno].pagb_list,
164 sizeof(xfs_perag_busy_t) *
165 XFS_PAGB_NUM_SLOTS);
166 kmem_free(mp->m_perag,
167 sizeof(xfs_perag_t) * mp->m_sb.sb_agcount);
168 }
169
Donald Douwsma287f3da2007-10-11 17:36:05 +1000170 spinlock_destroy(&mp->m_ail_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171 spinlock_destroy(&mp->m_sb_lock);
172 mutex_destroy(&mp->m_ilock);
Christoph Hellwigcc92e7a2007-08-30 17:21:54 +1000173 mutex_destroy(&mp->m_growlock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174 if (mp->m_quotainfo)
175 XFS_QM_DONE(mp);
176
177 if (mp->m_fsname != NULL)
178 kmem_free(mp->m_fsname, mp->m_fsname_len);
Nathan Scottfc1f8c12005-11-02 11:44:33 +1100179 if (mp->m_rtname != NULL)
180 kmem_free(mp->m_rtname, strlen(mp->m_rtname) + 1);
181 if (mp->m_logname != NULL)
182 kmem_free(mp->m_logname, strlen(mp->m_logname) + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183
David Chinner8d280b92006-03-14 13:13:09 +1100184 xfs_icsb_destroy_counters(mp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185}
186
Nathan Scott4cc929e2007-05-14 18:24:02 +1000187/*
188 * Check size of device based on the (data/realtime) block count.
189 * Note: this check is used by the growfs code as well as mount.
190 */
191int
192xfs_sb_validate_fsb_count(
193 xfs_sb_t *sbp,
194 __uint64_t nblocks)
195{
196 ASSERT(PAGE_SHIFT >= sbp->sb_blocklog);
197 ASSERT(sbp->sb_blocklog >= BBSHIFT);
198
199#if XFS_BIG_BLKNOS /* Limited by ULONG_MAX of page cache index */
200 if (nblocks >> (PAGE_CACHE_SHIFT - sbp->sb_blocklog) > ULONG_MAX)
201 return E2BIG;
202#else /* Limited by UINT_MAX of sectors */
203 if (nblocks << (sbp->sb_blocklog - BBSHIFT) > UINT_MAX)
204 return E2BIG;
205#endif
206 return 0;
207}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208
209/*
210 * Check the validity of the SB found.
211 */
212STATIC int
213xfs_mount_validate_sb(
214 xfs_mount_t *mp,
Nathan Scott764d1f82006-03-31 13:04:17 +1000215 xfs_sb_t *sbp,
216 int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217{
218 /*
219 * If the log device and data device have the
220 * same device number, the log is internal.
221 * Consequently, the sb_logstart should be non-zero. If
222 * we have a zero sb_logstart in this case, we may be trying to mount
223 * a volume filesystem in a non-volume manner.
224 */
225 if (sbp->sb_magicnum != XFS_SB_MAGIC) {
Nathan Scott764d1f82006-03-31 13:04:17 +1000226 xfs_fs_mount_cmn_err(flags, "bad magic number");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227 return XFS_ERROR(EWRONGFS);
228 }
229
Eric Sandeen62118702008-03-06 13:44:28 +1100230 if (!xfs_sb_good_version(sbp)) {
Nathan Scott764d1f82006-03-31 13:04:17 +1000231 xfs_fs_mount_cmn_err(flags, "bad version");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 return XFS_ERROR(EWRONGFS);
233 }
234
235 if (unlikely(
236 sbp->sb_logstart == 0 && mp->m_logdev_targp == mp->m_ddev_targp)) {
Nathan Scott764d1f82006-03-31 13:04:17 +1000237 xfs_fs_mount_cmn_err(flags,
238 "filesystem is marked as having an external log; "
239 "specify logdev on the\nmount command line.");
240 return XFS_ERROR(EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241 }
242
243 if (unlikely(
244 sbp->sb_logstart != 0 && mp->m_logdev_targp != mp->m_ddev_targp)) {
Nathan Scott764d1f82006-03-31 13:04:17 +1000245 xfs_fs_mount_cmn_err(flags,
246 "filesystem is marked as having an internal log; "
247 "do not specify logdev on\nthe mount command line.");
248 return XFS_ERROR(EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249 }
250
251 /*
252 * More sanity checking. These were stolen directly from
253 * xfs_repair.
254 */
255 if (unlikely(
256 sbp->sb_agcount <= 0 ||
257 sbp->sb_sectsize < XFS_MIN_SECTORSIZE ||
258 sbp->sb_sectsize > XFS_MAX_SECTORSIZE ||
259 sbp->sb_sectlog < XFS_MIN_SECTORSIZE_LOG ||
260 sbp->sb_sectlog > XFS_MAX_SECTORSIZE_LOG ||
261 sbp->sb_blocksize < XFS_MIN_BLOCKSIZE ||
262 sbp->sb_blocksize > XFS_MAX_BLOCKSIZE ||
263 sbp->sb_blocklog < XFS_MIN_BLOCKSIZE_LOG ||
264 sbp->sb_blocklog > XFS_MAX_BLOCKSIZE_LOG ||
265 sbp->sb_inodesize < XFS_DINODE_MIN_SIZE ||
266 sbp->sb_inodesize > XFS_DINODE_MAX_SIZE ||
Nathan Scott9f989c92006-03-14 13:29:32 +1100267 sbp->sb_inodelog < XFS_DINODE_MIN_LOG ||
268 sbp->sb_inodelog > XFS_DINODE_MAX_LOG ||
269 (sbp->sb_blocklog - sbp->sb_inodelog != sbp->sb_inopblog) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270 (sbp->sb_rextsize * sbp->sb_blocksize > XFS_MAX_RTEXTSIZE) ||
271 (sbp->sb_rextsize * sbp->sb_blocksize < XFS_MIN_RTEXTSIZE) ||
Nathan Scotte50bd162006-04-11 15:10:45 +1000272 (sbp->sb_imax_pct > 100 /* zero sb_imax_pct is valid */))) {
Nathan Scott764d1f82006-03-31 13:04:17 +1000273 xfs_fs_mount_cmn_err(flags, "SB sanity check 1 failed");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274 return XFS_ERROR(EFSCORRUPTED);
275 }
276
277 /*
278 * Sanity check AG count, size fields against data size field
279 */
280 if (unlikely(
281 sbp->sb_dblocks == 0 ||
282 sbp->sb_dblocks >
283 (xfs_drfsbno_t)sbp->sb_agcount * sbp->sb_agblocks ||
284 sbp->sb_dblocks < (xfs_drfsbno_t)(sbp->sb_agcount - 1) *
285 sbp->sb_agblocks + XFS_MIN_AG_BLOCKS)) {
Nathan Scott764d1f82006-03-31 13:04:17 +1000286 xfs_fs_mount_cmn_err(flags, "SB sanity check 2 failed");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287 return XFS_ERROR(EFSCORRUPTED);
288 }
289
Nathan Scott4cc929e2007-05-14 18:24:02 +1000290 if (xfs_sb_validate_fsb_count(sbp, sbp->sb_dblocks) ||
291 xfs_sb_validate_fsb_count(sbp, sbp->sb_rblocks)) {
Nathan Scott764d1f82006-03-31 13:04:17 +1000292 xfs_fs_mount_cmn_err(flags,
293 "file system too large to be mounted on this system.");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294 return XFS_ERROR(E2BIG);
295 }
296
297 if (unlikely(sbp->sb_inprogress)) {
Nathan Scott764d1f82006-03-31 13:04:17 +1000298 xfs_fs_mount_cmn_err(flags, "file system busy");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299 return XFS_ERROR(EFSCORRUPTED);
300 }
301
302 /*
Nathan Scottde206142005-05-05 13:24:13 -0700303 * Version 1 directory format has never worked on Linux.
304 */
Eric Sandeen62118702008-03-06 13:44:28 +1100305 if (unlikely(!xfs_sb_version_hasdirv2(sbp))) {
Nathan Scott764d1f82006-03-31 13:04:17 +1000306 xfs_fs_mount_cmn_err(flags,
307 "file system using version 1 directory format");
Nathan Scottde206142005-05-05 13:24:13 -0700308 return XFS_ERROR(ENOSYS);
309 }
310
311 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312 * Until this is fixed only page-sized or smaller data blocks work.
313 */
314 if (unlikely(sbp->sb_blocksize > PAGE_SIZE)) {
Nathan Scott764d1f82006-03-31 13:04:17 +1000315 xfs_fs_mount_cmn_err(flags,
316 "file system with blocksize %d bytes",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317 sbp->sb_blocksize);
Nathan Scott764d1f82006-03-31 13:04:17 +1000318 xfs_fs_mount_cmn_err(flags,
319 "only pagesize (%ld) or less will currently work.",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 PAGE_SIZE);
321 return XFS_ERROR(ENOSYS);
322 }
323
324 return 0;
325}
326
David Chinnerda353b02007-08-28 14:00:13 +1000327STATIC void
328xfs_initialize_perag_icache(
329 xfs_perag_t *pag)
330{
331 if (!pag->pag_ici_init) {
332 rwlock_init(&pag->pag_ici_lock);
333 INIT_RADIX_TREE(&pag->pag_ici_root, GFP_ATOMIC);
334 pag->pag_ici_init = 1;
335 }
336}
337
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338xfs_agnumber_t
Nathan Scottc11e2c32005-11-02 15:11:45 +1100339xfs_initialize_perag(
Nathan Scottc11e2c32005-11-02 15:11:45 +1100340 xfs_mount_t *mp,
341 xfs_agnumber_t agcount)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342{
343 xfs_agnumber_t index, max_metadata;
344 xfs_perag_t *pag;
345 xfs_agino_t agino;
346 xfs_ino_t ino;
347 xfs_sb_t *sbp = &mp->m_sb;
348 xfs_ino_t max_inum = XFS_MAXINUMBER_32;
349
350 /* Check to see if the filesystem can overflow 32 bit inodes */
351 agino = XFS_OFFBNO_TO_AGINO(mp, sbp->sb_agblocks - 1, 0);
352 ino = XFS_AGINO_TO_INO(mp, agcount - 1, agino);
353
354 /* Clear the mount flag if no inode can overflow 32 bits
355 * on this filesystem, or if specifically requested..
356 */
Christoph Hellwigbd186aa2007-08-30 17:21:12 +1000357 if ((mp->m_flags & XFS_MOUNT_SMALL_INUMS) && ino > max_inum) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 mp->m_flags |= XFS_MOUNT_32BITINODES;
359 } else {
360 mp->m_flags &= ~XFS_MOUNT_32BITINODES;
361 }
362
363 /* If we can overflow then setup the ag headers accordingly */
364 if (mp->m_flags & XFS_MOUNT_32BITINODES) {
365 /* Calculate how much should be reserved for inodes to
366 * meet the max inode percentage.
367 */
368 if (mp->m_maxicount) {
369 __uint64_t icount;
370
371 icount = sbp->sb_dblocks * sbp->sb_imax_pct;
372 do_div(icount, 100);
373 icount += sbp->sb_agblocks - 1;
Eric Sandeena749ee82005-11-02 15:13:42 +1100374 do_div(icount, sbp->sb_agblocks);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375 max_metadata = icount;
376 } else {
377 max_metadata = agcount;
378 }
379 for (index = 0; index < agcount; index++) {
380 ino = XFS_AGINO_TO_INO(mp, index, agino);
381 if (ino > max_inum) {
382 index++;
383 break;
384 }
385
Nathan Scottc41564b2006-03-29 08:55:14 +1000386 /* This ag is preferred for inodes */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 pag = &mp->m_perag[index];
388 pag->pagi_inodeok = 1;
389 if (index < max_metadata)
390 pag->pagf_metadata = 1;
David Chinnerda353b02007-08-28 14:00:13 +1000391 xfs_initialize_perag_icache(pag);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 }
393 } else {
394 /* Setup default behavior for smaller filesystems */
395 for (index = 0; index < agcount; index++) {
396 pag = &mp->m_perag[index];
397 pag->pagi_inodeok = 1;
David Chinnerda353b02007-08-28 14:00:13 +1000398 xfs_initialize_perag_icache(pag);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 }
400 }
401 return index;
402}
403
Christoph Hellwig2bdf7cd2007-08-28 13:58:06 +1000404void
405xfs_sb_from_disk(
406 xfs_sb_t *to,
407 xfs_dsb_t *from)
408{
409 to->sb_magicnum = be32_to_cpu(from->sb_magicnum);
410 to->sb_blocksize = be32_to_cpu(from->sb_blocksize);
411 to->sb_dblocks = be64_to_cpu(from->sb_dblocks);
412 to->sb_rblocks = be64_to_cpu(from->sb_rblocks);
413 to->sb_rextents = be64_to_cpu(from->sb_rextents);
414 memcpy(&to->sb_uuid, &from->sb_uuid, sizeof(to->sb_uuid));
415 to->sb_logstart = be64_to_cpu(from->sb_logstart);
416 to->sb_rootino = be64_to_cpu(from->sb_rootino);
417 to->sb_rbmino = be64_to_cpu(from->sb_rbmino);
418 to->sb_rsumino = be64_to_cpu(from->sb_rsumino);
419 to->sb_rextsize = be32_to_cpu(from->sb_rextsize);
420 to->sb_agblocks = be32_to_cpu(from->sb_agblocks);
421 to->sb_agcount = be32_to_cpu(from->sb_agcount);
422 to->sb_rbmblocks = be32_to_cpu(from->sb_rbmblocks);
423 to->sb_logblocks = be32_to_cpu(from->sb_logblocks);
424 to->sb_versionnum = be16_to_cpu(from->sb_versionnum);
425 to->sb_sectsize = be16_to_cpu(from->sb_sectsize);
426 to->sb_inodesize = be16_to_cpu(from->sb_inodesize);
427 to->sb_inopblock = be16_to_cpu(from->sb_inopblock);
428 memcpy(&to->sb_fname, &from->sb_fname, sizeof(to->sb_fname));
429 to->sb_blocklog = from->sb_blocklog;
430 to->sb_sectlog = from->sb_sectlog;
431 to->sb_inodelog = from->sb_inodelog;
432 to->sb_inopblog = from->sb_inopblog;
433 to->sb_agblklog = from->sb_agblklog;
434 to->sb_rextslog = from->sb_rextslog;
435 to->sb_inprogress = from->sb_inprogress;
436 to->sb_imax_pct = from->sb_imax_pct;
437 to->sb_icount = be64_to_cpu(from->sb_icount);
438 to->sb_ifree = be64_to_cpu(from->sb_ifree);
439 to->sb_fdblocks = be64_to_cpu(from->sb_fdblocks);
440 to->sb_frextents = be64_to_cpu(from->sb_frextents);
441 to->sb_uquotino = be64_to_cpu(from->sb_uquotino);
442 to->sb_gquotino = be64_to_cpu(from->sb_gquotino);
443 to->sb_qflags = be16_to_cpu(from->sb_qflags);
444 to->sb_flags = from->sb_flags;
445 to->sb_shared_vn = from->sb_shared_vn;
446 to->sb_inoalignmt = be32_to_cpu(from->sb_inoalignmt);
447 to->sb_unit = be32_to_cpu(from->sb_unit);
448 to->sb_width = be32_to_cpu(from->sb_width);
449 to->sb_dirblklog = from->sb_dirblklog;
450 to->sb_logsectlog = from->sb_logsectlog;
451 to->sb_logsectsize = be16_to_cpu(from->sb_logsectsize);
452 to->sb_logsunit = be32_to_cpu(from->sb_logsunit);
453 to->sb_features2 = be32_to_cpu(from->sb_features2);
David Chinneree1c0902008-03-06 13:45:50 +1100454 to->sb_bad_features2 = be32_to_cpu(from->sb_bad_features2);
Christoph Hellwig2bdf7cd2007-08-28 13:58:06 +1000455}
456
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457/*
Christoph Hellwig2bdf7cd2007-08-28 13:58:06 +1000458 * Copy in core superblock to ondisk one.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459 *
Christoph Hellwig2bdf7cd2007-08-28 13:58:06 +1000460 * The fields argument is mask of superblock fields to copy.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461 */
462void
Christoph Hellwig2bdf7cd2007-08-28 13:58:06 +1000463xfs_sb_to_disk(
464 xfs_dsb_t *to,
465 xfs_sb_t *from,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466 __int64_t fields)
467{
Christoph Hellwig2bdf7cd2007-08-28 13:58:06 +1000468 xfs_caddr_t to_ptr = (xfs_caddr_t)to;
469 xfs_caddr_t from_ptr = (xfs_caddr_t)from;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470 xfs_sb_field_t f;
471 int first;
472 int size;
473
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474 ASSERT(fields);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475 if (!fields)
476 return;
477
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478 while (fields) {
479 f = (xfs_sb_field_t)xfs_lowbit64((__uint64_t)fields);
480 first = xfs_sb_info[f].offset;
481 size = xfs_sb_info[f + 1].offset - first;
482
483 ASSERT(xfs_sb_info[f].type == 0 || xfs_sb_info[f].type == 1);
484
485 if (size == 1 || xfs_sb_info[f].type == 1) {
Christoph Hellwig2bdf7cd2007-08-28 13:58:06 +1000486 memcpy(to_ptr + first, from_ptr + first, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487 } else {
488 switch (size) {
489 case 2:
Christoph Hellwig2bdf7cd2007-08-28 13:58:06 +1000490 *(__be16 *)(to_ptr + first) =
491 cpu_to_be16(*(__u16 *)(from_ptr + first));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492 break;
493 case 4:
Christoph Hellwig2bdf7cd2007-08-28 13:58:06 +1000494 *(__be32 *)(to_ptr + first) =
495 cpu_to_be32(*(__u32 *)(from_ptr + first));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496 break;
497 case 8:
Christoph Hellwig2bdf7cd2007-08-28 13:58:06 +1000498 *(__be64 *)(to_ptr + first) =
499 cpu_to_be64(*(__u64 *)(from_ptr + first));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500 break;
501 default:
502 ASSERT(0);
503 }
504 }
505
506 fields &= ~(1LL << f);
507 }
508}
509
510/*
511 * xfs_readsb
512 *
513 * Does the initial read of the superblock.
514 */
515int
Nathan Scott764d1f82006-03-31 13:04:17 +1000516xfs_readsb(xfs_mount_t *mp, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517{
518 unsigned int sector_size;
519 unsigned int extra_flags;
520 xfs_buf_t *bp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 int error;
522
523 ASSERT(mp->m_sb_bp == NULL);
524 ASSERT(mp->m_ddev_targp != NULL);
525
526 /*
527 * Allocate a (locked) buffer to hold the superblock.
528 * This will be kept around at all times to optimize
529 * access to the superblock.
530 */
531 sector_size = xfs_getsize_buftarg(mp->m_ddev_targp);
532 extra_flags = XFS_BUF_LOCK | XFS_BUF_MANAGE | XFS_BUF_MAPPED;
533
534 bp = xfs_buf_read_flags(mp->m_ddev_targp, XFS_SB_DADDR,
535 BTOBB(sector_size), extra_flags);
536 if (!bp || XFS_BUF_ISERROR(bp)) {
Nathan Scott764d1f82006-03-31 13:04:17 +1000537 xfs_fs_mount_cmn_err(flags, "SB read failed");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538 error = bp ? XFS_BUF_GETERROR(bp) : ENOMEM;
539 goto fail;
540 }
541 ASSERT(XFS_BUF_ISBUSY(bp));
542 ASSERT(XFS_BUF_VALUSEMA(bp) <= 0);
543
544 /*
545 * Initialize the mount structure from the superblock.
546 * But first do some basic consistency checking.
547 */
Christoph Hellwig2bdf7cd2007-08-28 13:58:06 +1000548 xfs_sb_from_disk(&mp->m_sb, XFS_BUF_TO_SBP(bp));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549
Nathan Scott764d1f82006-03-31 13:04:17 +1000550 error = xfs_mount_validate_sb(mp, &(mp->m_sb), flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551 if (error) {
Nathan Scott764d1f82006-03-31 13:04:17 +1000552 xfs_fs_mount_cmn_err(flags, "SB validate failed");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553 goto fail;
554 }
555
556 /*
557 * We must be able to do sector-sized and sector-aligned IO.
558 */
559 if (sector_size > mp->m_sb.sb_sectsize) {
Nathan Scott764d1f82006-03-31 13:04:17 +1000560 xfs_fs_mount_cmn_err(flags,
561 "device supports only %u byte sectors (not %u)",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562 sector_size, mp->m_sb.sb_sectsize);
563 error = ENOSYS;
564 goto fail;
565 }
566
567 /*
568 * If device sector size is smaller than the superblock size,
569 * re-read the superblock so the buffer is correctly sized.
570 */
571 if (sector_size < mp->m_sb.sb_sectsize) {
572 XFS_BUF_UNMANAGE(bp);
573 xfs_buf_relse(bp);
574 sector_size = mp->m_sb.sb_sectsize;
575 bp = xfs_buf_read_flags(mp->m_ddev_targp, XFS_SB_DADDR,
576 BTOBB(sector_size), extra_flags);
577 if (!bp || XFS_BUF_ISERROR(bp)) {
Nathan Scott764d1f82006-03-31 13:04:17 +1000578 xfs_fs_mount_cmn_err(flags, "SB re-read failed");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579 error = bp ? XFS_BUF_GETERROR(bp) : ENOMEM;
580 goto fail;
581 }
582 ASSERT(XFS_BUF_ISBUSY(bp));
583 ASSERT(XFS_BUF_VALUSEMA(bp) <= 0);
584 }
585
Lachlan McIlroy5478eea2007-02-10 18:36:29 +1100586 /* Initialize per-cpu counters */
587 xfs_icsb_reinit_counters(mp);
David Chinner8d280b92006-03-14 13:13:09 +1100588
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589 mp->m_sb_bp = bp;
590 xfs_buf_relse(bp);
591 ASSERT(XFS_BUF_VALUSEMA(bp) > 0);
592 return 0;
593
594 fail:
595 if (bp) {
596 XFS_BUF_UNMANAGE(bp);
597 xfs_buf_relse(bp);
598 }
599 return error;
600}
601
602
603/*
604 * xfs_mount_common
605 *
606 * Mount initialization code establishing various mount
607 * fields from the superblock associated with the given
608 * mount structure
609 */
Christoph Hellwigba0f32d2005-06-21 15:36:52 +1000610STATIC void
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611xfs_mount_common(xfs_mount_t *mp, xfs_sb_t *sbp)
612{
613 int i;
614
615 mp->m_agfrotor = mp->m_agirotor = 0;
Eric Sandeen007c61c2007-10-11 17:43:56 +1000616 spin_lock_init(&mp->m_agirotor_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617 mp->m_maxagi = mp->m_sb.sb_agcount;
618 mp->m_blkbit_log = sbp->sb_blocklog + XFS_NBBYLOG;
619 mp->m_blkbb_log = sbp->sb_blocklog - BBSHIFT;
620 mp->m_sectbb_log = sbp->sb_sectlog - BBSHIFT;
621 mp->m_agno_log = xfs_highbit32(sbp->sb_agcount - 1) + 1;
622 mp->m_agino_log = sbp->sb_inopblog + sbp->sb_agblklog;
623 mp->m_litino = sbp->sb_inodesize -
624 ((uint)sizeof(xfs_dinode_core_t) + (uint)sizeof(xfs_agino_t));
625 mp->m_blockmask = sbp->sb_blocksize - 1;
626 mp->m_blockwsize = sbp->sb_blocksize >> XFS_WORDLOG;
627 mp->m_blockwmask = mp->m_blockwsize - 1;
628 INIT_LIST_HEAD(&mp->m_del_inodes);
629
630 /*
631 * Setup for attributes, in case they get created.
632 * This value is for inodes getting attributes for the first time,
633 * the per-inode value is for old attribute values.
634 */
635 ASSERT(sbp->sb_inodesize >= 256 && sbp->sb_inodesize <= 2048);
636 switch (sbp->sb_inodesize) {
637 case 256:
Nathan Scottd8cc8902005-11-02 10:34:53 +1100638 mp->m_attroffset = XFS_LITINO(mp) -
639 XFS_BMDR_SPACE_CALC(MINABTPTRS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640 break;
641 case 512:
642 case 1024:
643 case 2048:
Nathan Scottd8cc8902005-11-02 10:34:53 +1100644 mp->m_attroffset = XFS_BMDR_SPACE_CALC(6 * MINABTPTRS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645 break;
646 default:
647 ASSERT(0);
648 }
649 ASSERT(mp->m_attroffset < XFS_LITINO(mp));
650
651 for (i = 0; i < 2; i++) {
652 mp->m_alloc_mxr[i] = XFS_BTREE_BLOCK_MAXRECS(sbp->sb_blocksize,
653 xfs_alloc, i == 0);
654 mp->m_alloc_mnr[i] = XFS_BTREE_BLOCK_MINRECS(sbp->sb_blocksize,
655 xfs_alloc, i == 0);
656 }
657 for (i = 0; i < 2; i++) {
658 mp->m_bmap_dmxr[i] = XFS_BTREE_BLOCK_MAXRECS(sbp->sb_blocksize,
659 xfs_bmbt, i == 0);
660 mp->m_bmap_dmnr[i] = XFS_BTREE_BLOCK_MINRECS(sbp->sb_blocksize,
661 xfs_bmbt, i == 0);
662 }
663 for (i = 0; i < 2; i++) {
664 mp->m_inobt_mxr[i] = XFS_BTREE_BLOCK_MAXRECS(sbp->sb_blocksize,
665 xfs_inobt, i == 0);
666 mp->m_inobt_mnr[i] = XFS_BTREE_BLOCK_MINRECS(sbp->sb_blocksize,
667 xfs_inobt, i == 0);
668 }
669
670 mp->m_bsize = XFS_FSB_TO_BB(mp, 1);
671 mp->m_ialloc_inos = (int)MAX((__uint16_t)XFS_INODES_PER_CHUNK,
672 sbp->sb_inopblock);
673 mp->m_ialloc_blks = mp->m_ialloc_inos >> sbp->sb_inopblog;
674}
David Chinner92821e22007-05-24 15:26:31 +1000675
676/*
677 * xfs_initialize_perag_data
678 *
679 * Read in each per-ag structure so we can count up the number of
680 * allocated inodes, free inodes and used filesystem blocks as this
681 * information is no longer persistent in the superblock. Once we have
682 * this information, write it into the in-core superblock structure.
683 */
684STATIC int
685xfs_initialize_perag_data(xfs_mount_t *mp, xfs_agnumber_t agcount)
686{
687 xfs_agnumber_t index;
688 xfs_perag_t *pag;
689 xfs_sb_t *sbp = &mp->m_sb;
690 uint64_t ifree = 0;
691 uint64_t ialloc = 0;
692 uint64_t bfree = 0;
693 uint64_t bfreelst = 0;
694 uint64_t btree = 0;
695 int error;
David Chinner92821e22007-05-24 15:26:31 +1000696
697 for (index = 0; index < agcount; index++) {
698 /*
699 * read the agf, then the agi. This gets us
700 * all the inforamtion we need and populates the
701 * per-ag structures for us.
702 */
703 error = xfs_alloc_pagf_init(mp, NULL, index, 0);
704 if (error)
705 return error;
706
707 error = xfs_ialloc_pagi_init(mp, NULL, index);
708 if (error)
709 return error;
710 pag = &mp->m_perag[index];
711 ifree += pag->pagi_freecount;
712 ialloc += pag->pagi_count;
713 bfree += pag->pagf_freeblks;
714 bfreelst += pag->pagf_flcount;
715 btree += pag->pagf_btreeblks;
716 }
717 /*
718 * Overwrite incore superblock counters with just-read data
719 */
Eric Sandeen3685c2a2007-10-11 17:42:32 +1000720 spin_lock(&mp->m_sb_lock);
David Chinner92821e22007-05-24 15:26:31 +1000721 sbp->sb_ifree = ifree;
722 sbp->sb_icount = ialloc;
723 sbp->sb_fdblocks = bfree + bfreelst + btree;
Eric Sandeen3685c2a2007-10-11 17:42:32 +1000724 spin_unlock(&mp->m_sb_lock);
David Chinner92821e22007-05-24 15:26:31 +1000725
726 /* Fixup the per-cpu counters as well. */
727 xfs_icsb_reinit_counters(mp);
728
729 return 0;
730}
731
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732/*
Eric Sandeen0771fb42007-10-12 11:03:40 +1000733 * Update alignment values based on mount options and sb values
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734 */
Eric Sandeen0771fb42007-10-12 11:03:40 +1000735STATIC int
736xfs_update_alignment(xfs_mount_t *mp, int mfsi_flags, __uint64_t *update_flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738 xfs_sb_t *sbp = &(mp->m_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740 if (mp->m_dalign && !(mfsi_flags & XFS_MFSI_SECOND)) {
741 /*
742 * If stripe unit and stripe width are not multiples
743 * of the fs blocksize turn off alignment.
744 */
745 if ((BBTOB(mp->m_dalign) & mp->m_blockmask) ||
746 (BBTOB(mp->m_swidth) & mp->m_blockmask)) {
747 if (mp->m_flags & XFS_MOUNT_RETERR) {
748 cmn_err(CE_WARN,
749 "XFS: alignment check 1 failed");
Eric Sandeen0771fb42007-10-12 11:03:40 +1000750 return XFS_ERROR(EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751 }
752 mp->m_dalign = mp->m_swidth = 0;
753 } else {
754 /*
755 * Convert the stripe unit and width to FSBs.
756 */
757 mp->m_dalign = XFS_BB_TO_FSBT(mp, mp->m_dalign);
758 if (mp->m_dalign && (sbp->sb_agblocks % mp->m_dalign)) {
759 if (mp->m_flags & XFS_MOUNT_RETERR) {
Eric Sandeen0771fb42007-10-12 11:03:40 +1000760 return XFS_ERROR(EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761 }
762 xfs_fs_cmn_err(CE_WARN, mp,
763"stripe alignment turned off: sunit(%d)/swidth(%d) incompatible with agsize(%d)",
764 mp->m_dalign, mp->m_swidth,
765 sbp->sb_agblocks);
766
767 mp->m_dalign = 0;
768 mp->m_swidth = 0;
769 } else if (mp->m_dalign) {
770 mp->m_swidth = XFS_BB_TO_FSBT(mp, mp->m_swidth);
771 } else {
772 if (mp->m_flags & XFS_MOUNT_RETERR) {
773 xfs_fs_cmn_err(CE_WARN, mp,
774"stripe alignment turned off: sunit(%d) less than bsize(%d)",
775 mp->m_dalign,
776 mp->m_blockmask +1);
Eric Sandeen0771fb42007-10-12 11:03:40 +1000777 return XFS_ERROR(EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778 }
779 mp->m_swidth = 0;
780 }
781 }
782
783 /*
784 * Update superblock with new values
785 * and log changes
786 */
Eric Sandeen62118702008-03-06 13:44:28 +1100787 if (xfs_sb_version_hasdalign(sbp)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788 if (sbp->sb_unit != mp->m_dalign) {
789 sbp->sb_unit = mp->m_dalign;
Eric Sandeen0771fb42007-10-12 11:03:40 +1000790 *update_flags |= XFS_SB_UNIT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791 }
792 if (sbp->sb_width != mp->m_swidth) {
793 sbp->sb_width = mp->m_swidth;
Eric Sandeen0771fb42007-10-12 11:03:40 +1000794 *update_flags |= XFS_SB_WIDTH;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795 }
796 }
797 } else if ((mp->m_flags & XFS_MOUNT_NOALIGN) != XFS_MOUNT_NOALIGN &&
Eric Sandeen62118702008-03-06 13:44:28 +1100798 xfs_sb_version_hasdalign(&mp->m_sb)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799 mp->m_dalign = sbp->sb_unit;
800 mp->m_swidth = sbp->sb_width;
801 }
802
Eric Sandeen0771fb42007-10-12 11:03:40 +1000803 return 0;
804}
805
806/*
807 * Set the maximum inode count for this filesystem
808 */
809STATIC void
810xfs_set_maxicount(xfs_mount_t *mp)
811{
812 xfs_sb_t *sbp = &(mp->m_sb);
813 __uint64_t icount;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814
815 if (sbp->sb_imax_pct) {
Eric Sandeen0771fb42007-10-12 11:03:40 +1000816 /*
817 * Make sure the maximum inode count is a multiple
818 * of the units we allocate inodes in.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820 icount = sbp->sb_dblocks * sbp->sb_imax_pct;
821 do_div(icount, 100);
822 do_div(icount, mp->m_ialloc_blks);
823 mp->m_maxicount = (icount * mp->m_ialloc_blks) <<
824 sbp->sb_inopblog;
Eric Sandeen0771fb42007-10-12 11:03:40 +1000825 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700826 mp->m_maxicount = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827 }
Eric Sandeen0771fb42007-10-12 11:03:40 +1000828}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829
Eric Sandeen0771fb42007-10-12 11:03:40 +1000830/*
831 * Set the default minimum read and write sizes unless
832 * already specified in a mount option.
833 * We use smaller I/O sizes when the file system
834 * is being used for NFS service (wsync mount option).
835 */
836STATIC void
837xfs_set_rw_sizes(xfs_mount_t *mp)
838{
839 xfs_sb_t *sbp = &(mp->m_sb);
840 int readio_log, writeio_log;
841
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842 if (!(mp->m_flags & XFS_MOUNT_DFLT_IOSIZE)) {
843 if (mp->m_flags & XFS_MOUNT_WSYNC) {
844 readio_log = XFS_WSYNC_READIO_LOG;
845 writeio_log = XFS_WSYNC_WRITEIO_LOG;
846 } else {
847 readio_log = XFS_READIO_LOG_LARGE;
848 writeio_log = XFS_WRITEIO_LOG_LARGE;
849 }
850 } else {
851 readio_log = mp->m_readio_log;
852 writeio_log = mp->m_writeio_log;
853 }
854
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855 if (sbp->sb_blocklog > readio_log) {
856 mp->m_readio_log = sbp->sb_blocklog;
857 } else {
858 mp->m_readio_log = readio_log;
859 }
860 mp->m_readio_blocks = 1 << (mp->m_readio_log - sbp->sb_blocklog);
861 if (sbp->sb_blocklog > writeio_log) {
862 mp->m_writeio_log = sbp->sb_blocklog;
863 } else {
864 mp->m_writeio_log = writeio_log;
865 }
866 mp->m_writeio_blocks = 1 << (mp->m_writeio_log - sbp->sb_blocklog);
Eric Sandeen0771fb42007-10-12 11:03:40 +1000867}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868
Eric Sandeen0771fb42007-10-12 11:03:40 +1000869/*
870 * Set whether we're using inode alignment.
871 */
872STATIC void
873xfs_set_inoalignment(xfs_mount_t *mp)
874{
Eric Sandeen62118702008-03-06 13:44:28 +1100875 if (xfs_sb_version_hasalign(&mp->m_sb) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876 mp->m_sb.sb_inoalignmt >=
877 XFS_B_TO_FSBT(mp, mp->m_inode_cluster_size))
878 mp->m_inoalign_mask = mp->m_sb.sb_inoalignmt - 1;
879 else
880 mp->m_inoalign_mask = 0;
881 /*
882 * If we are using stripe alignment, check whether
883 * the stripe unit is a multiple of the inode alignment
884 */
885 if (mp->m_dalign && mp->m_inoalign_mask &&
886 !(mp->m_dalign & mp->m_inoalign_mask))
887 mp->m_sinoalign = mp->m_dalign;
888 else
889 mp->m_sinoalign = 0;
Eric Sandeen0771fb42007-10-12 11:03:40 +1000890}
891
892/*
893 * Check that the data (and log if separate) are an ok size.
894 */
895STATIC int
896xfs_check_sizes(xfs_mount_t *mp, int mfsi_flags)
897{
898 xfs_buf_t *bp;
899 xfs_daddr_t d;
900 int error;
901
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902 d = (xfs_daddr_t)XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks);
903 if (XFS_BB_TO_FSB(mp, d) != mp->m_sb.sb_dblocks) {
904 cmn_err(CE_WARN, "XFS: size check 1 failed");
Eric Sandeen0771fb42007-10-12 11:03:40 +1000905 return XFS_ERROR(E2BIG);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906 }
907 error = xfs_read_buf(mp, mp->m_ddev_targp,
908 d - XFS_FSS_TO_BB(mp, 1),
909 XFS_FSS_TO_BB(mp, 1), 0, &bp);
910 if (!error) {
911 xfs_buf_relse(bp);
912 } else {
913 cmn_err(CE_WARN, "XFS: size check 2 failed");
Eric Sandeen0771fb42007-10-12 11:03:40 +1000914 if (error == ENOSPC)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915 error = XFS_ERROR(E2BIG);
Eric Sandeen0771fb42007-10-12 11:03:40 +1000916 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917 }
918
919 if (((mfsi_flags & XFS_MFSI_CLIENT) == 0) &&
920 mp->m_logdev_targp != mp->m_ddev_targp) {
921 d = (xfs_daddr_t)XFS_FSB_TO_BB(mp, mp->m_sb.sb_logblocks);
922 if (XFS_BB_TO_FSB(mp, d) != mp->m_sb.sb_logblocks) {
923 cmn_err(CE_WARN, "XFS: size check 3 failed");
Eric Sandeen0771fb42007-10-12 11:03:40 +1000924 return XFS_ERROR(E2BIG);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700925 }
926 error = xfs_read_buf(mp, mp->m_logdev_targp,
927 d - XFS_FSB_TO_BB(mp, 1),
928 XFS_FSB_TO_BB(mp, 1), 0, &bp);
929 if (!error) {
930 xfs_buf_relse(bp);
931 } else {
932 cmn_err(CE_WARN, "XFS: size check 3 failed");
Eric Sandeen0771fb42007-10-12 11:03:40 +1000933 if (error == ENOSPC)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934 error = XFS_ERROR(E2BIG);
Eric Sandeen0771fb42007-10-12 11:03:40 +1000935 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936 }
937 }
Eric Sandeen0771fb42007-10-12 11:03:40 +1000938 return 0;
939}
940
941/*
942 * xfs_mountfs
943 *
944 * This function does the following on an initial mount of a file system:
945 * - reads the superblock from disk and init the mount struct
946 * - if we're a 32-bit kernel, do a size check on the superblock
947 * so we don't mount terabyte filesystems
948 * - init mount struct realtime fields
949 * - allocate inode hash table for fs
950 * - init directory manager
951 * - perform recovery and init the log manager
952 */
953int
954xfs_mountfs(
955 xfs_mount_t *mp,
956 int mfsi_flags)
957{
958 xfs_sb_t *sbp = &(mp->m_sb);
959 xfs_inode_t *rip;
Eric Sandeen0771fb42007-10-12 11:03:40 +1000960 __uint64_t resblks;
961 __int64_t update_flags = 0LL;
962 uint quotamount, quotaflags;
963 int agno;
964 int uuid_mounted = 0;
965 int error = 0;
966
Eric Sandeen0771fb42007-10-12 11:03:40 +1000967 xfs_mount_common(mp, sbp);
968
969 /*
Eric Sandeene6957ea2008-04-10 12:19:34 +1000970 * Check for a mismatched features2 values. Older kernels
971 * read & wrote into the wrong sb offset for sb_features2
972 * on some platforms due to xfs_sb_t not being 64bit size aligned
973 * when sb_features2 was added, which made older superblock
974 * reading/writing routines swap it as a 64-bit value.
David Chinneree1c0902008-03-06 13:45:50 +1100975 *
Eric Sandeene6957ea2008-04-10 12:19:34 +1000976 * For backwards compatibility, we make both slots equal.
977 *
978 * If we detect a mismatched field, we OR the set bits into the
979 * existing features2 field in case it has already been modified; we
980 * don't want to lose any features. We then update the bad location
981 * with the ORed value so that older kernels will see any features2
982 * flags, and mark the two fields as needing updates once the
983 * transaction subsystem is online.
David Chinneree1c0902008-03-06 13:45:50 +1100984 */
Eric Sandeene6957ea2008-04-10 12:19:34 +1000985 if (xfs_sb_has_mismatched_features2(sbp)) {
David Chinneree1c0902008-03-06 13:45:50 +1100986 cmn_err(CE_WARN,
987 "XFS: correcting sb_features alignment problem");
988 sbp->sb_features2 |= sbp->sb_bad_features2;
Eric Sandeene6957ea2008-04-10 12:19:34 +1000989 sbp->sb_bad_features2 = sbp->sb_features2;
David Chinneree1c0902008-03-06 13:45:50 +1100990 update_flags |= XFS_SB_FEATURES2 | XFS_SB_BAD_FEATURES2;
Eric Sandeene6957ea2008-04-10 12:19:34 +1000991
992 /*
993 * Re-check for ATTR2 in case it was found in bad_features2
994 * slot.
995 */
996 if (xfs_sb_version_hasattr2(&mp->m_sb))
997 mp->m_flags |= XFS_MOUNT_ATTR2;
998
David Chinneree1c0902008-03-06 13:45:50 +1100999 }
1000
1001 /*
Eric Sandeen0771fb42007-10-12 11:03:40 +10001002 * Check if sb_agblocks is aligned at stripe boundary
1003 * If sb_agblocks is NOT aligned turn off m_dalign since
1004 * allocator alignment is within an ag, therefore ag has
1005 * to be aligned at stripe boundary.
1006 */
1007 error = xfs_update_alignment(mp, mfsi_flags, &update_flags);
1008 if (error)
1009 goto error1;
1010
1011 xfs_alloc_compute_maxlevels(mp);
1012 xfs_bmap_compute_maxlevels(mp, XFS_DATA_FORK);
1013 xfs_bmap_compute_maxlevels(mp, XFS_ATTR_FORK);
1014 xfs_ialloc_compute_maxlevels(mp);
1015
1016 xfs_set_maxicount(mp);
1017
1018 mp->m_maxioffset = xfs_max_file_offset(sbp->sb_blocklog);
1019
1020 /*
1021 * XFS uses the uuid from the superblock as the unique
1022 * identifier for fsid. We can not use the uuid from the volume
1023 * since a single partition filesystem is identical to a single
1024 * partition volume/filesystem.
1025 */
1026 if ((mfsi_flags & XFS_MFSI_SECOND) == 0 &&
1027 (mp->m_flags & XFS_MOUNT_NOUUID) == 0) {
1028 if (xfs_uuid_mount(mp)) {
1029 error = XFS_ERROR(EINVAL);
1030 goto error1;
1031 }
1032 uuid_mounted=1;
1033 }
1034
1035 /*
1036 * Set the minimum read and write sizes
1037 */
1038 xfs_set_rw_sizes(mp);
1039
1040 /*
1041 * Set the inode cluster size.
1042 * This may still be overridden by the file system
1043 * block size if it is larger than the chosen cluster size.
1044 */
1045 mp->m_inode_cluster_size = XFS_INODE_BIG_CLUSTER_SIZE;
1046
1047 /*
1048 * Set inode alignment fields
1049 */
1050 xfs_set_inoalignment(mp);
1051
1052 /*
1053 * Check that the data (and log if separate) are an ok size.
1054 */
1055 error = xfs_check_sizes(mp, mfsi_flags);
1056 if (error)
1057 goto error1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001058
1059 /*
1060 * Initialize realtime fields in the mount structure
1061 */
Eric Sandeen0771fb42007-10-12 11:03:40 +10001062 error = xfs_rtmount_init(mp);
1063 if (error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001064 cmn_err(CE_WARN, "XFS: RT mount failed");
1065 goto error1;
1066 }
1067
1068 /*
1069 * For client case we are done now
1070 */
1071 if (mfsi_flags & XFS_MFSI_CLIENT) {
Jesper Juhl014c2542006-01-15 02:37:08 +01001072 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001073 }
1074
1075 /*
1076 * Copies the low order bits of the timestamp and the randomly
1077 * set "sequence" number out of a UUID.
1078 */
1079 uuid_getnodeuniq(&sbp->sb_uuid, mp->m_fixedfsid);
1080
Linus Torvalds1da177e2005-04-16 15:20:36 -07001081 mp->m_dmevmask = 0; /* not persistent; set after each mount */
1082
Nathan Scottf6c2d1f2006-06-20 13:04:51 +10001083 xfs_dir_mount(mp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001084
1085 /*
1086 * Initialize the attribute manager's entries.
1087 */
1088 mp->m_attr_magicpct = (mp->m_sb.sb_blocksize * 37) / 100;
1089
1090 /*
1091 * Initialize the precomputed transaction reservations values.
1092 */
1093 xfs_trans_init(mp);
1094
1095 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096 * Allocate and initialize the per-ag data.
1097 */
1098 init_rwsem(&mp->m_peraglock);
1099 mp->m_perag =
1100 kmem_zalloc(sbp->sb_agcount * sizeof(xfs_perag_t), KM_SLEEP);
1101
Christoph Hellwigb267ce92007-08-30 17:21:30 +10001102 mp->m_maxagi = xfs_initialize_perag(mp, sbp->sb_agcount);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001103
1104 /*
1105 * log's mount-time initialization. Perform 1st part recovery if needed
1106 */
1107 if (likely(sbp->sb_logblocks > 0)) { /* check for volume case */
1108 error = xfs_log_mount(mp, mp->m_logdev_targp,
1109 XFS_FSB_TO_DADDR(mp, sbp->sb_logstart),
1110 XFS_FSB_TO_BB(mp, sbp->sb_logblocks));
1111 if (error) {
1112 cmn_err(CE_WARN, "XFS: log mount failed");
1113 goto error2;
1114 }
1115 } else { /* No log has been defined */
1116 cmn_err(CE_WARN, "XFS: no log defined");
1117 XFS_ERROR_REPORT("xfs_mountfs_int(1)", XFS_ERRLEVEL_LOW, mp);
1118 error = XFS_ERROR(EFSCORRUPTED);
1119 goto error2;
1120 }
1121
1122 /*
David Chinner92821e22007-05-24 15:26:31 +10001123 * Now the log is mounted, we know if it was an unclean shutdown or
1124 * not. If it was, with the first phase of recovery has completed, we
1125 * have consistent AG blocks on disk. We have not recovered EFIs yet,
1126 * but they are recovered transactionally in the second recovery phase
1127 * later.
1128 *
1129 * Hence we can safely re-initialise incore superblock counters from
1130 * the per-ag data. These may not be correct if the filesystem was not
1131 * cleanly unmounted, so we need to wait for recovery to finish before
1132 * doing this.
1133 *
1134 * If the filesystem was cleanly unmounted, then we can trust the
1135 * values in the superblock to be correct and we don't need to do
1136 * anything here.
1137 *
1138 * If we are currently making the filesystem, the initialisation will
1139 * fail as the perag data is in an undefined state.
1140 */
1141
1142 if (xfs_sb_version_haslazysbcount(&mp->m_sb) &&
1143 !XFS_LAST_UNMOUNT_WAS_CLEAN(mp) &&
1144 !mp->m_sb.sb_inprogress) {
1145 error = xfs_initialize_perag_data(mp, sbp->sb_agcount);
1146 if (error) {
1147 goto error2;
1148 }
1149 }
1150 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001151 * Get and sanity-check the root inode.
1152 * Save the pointer to it in the mount structure.
1153 */
1154 error = xfs_iget(mp, NULL, sbp->sb_rootino, 0, XFS_ILOCK_EXCL, &rip, 0);
1155 if (error) {
1156 cmn_err(CE_WARN, "XFS: failed to read root inode");
1157 goto error3;
1158 }
1159
1160 ASSERT(rip != NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161
1162 if (unlikely((rip->i_d.di_mode & S_IFMT) != S_IFDIR)) {
1163 cmn_err(CE_WARN, "XFS: corrupted root inode");
Nathan Scottb6574522006-06-09 15:29:40 +10001164 cmn_err(CE_WARN, "Device %s - root %llu is not a directory",
1165 XFS_BUFTARG_NAME(mp->m_ddev_targp),
1166 (unsigned long long)rip->i_ino);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001167 xfs_iunlock(rip, XFS_ILOCK_EXCL);
1168 XFS_ERROR_REPORT("xfs_mountfs_int(2)", XFS_ERRLEVEL_LOW,
1169 mp);
1170 error = XFS_ERROR(EFSCORRUPTED);
1171 goto error4;
1172 }
1173 mp->m_rootip = rip; /* save it */
1174
1175 xfs_iunlock(rip, XFS_ILOCK_EXCL);
1176
1177 /*
1178 * Initialize realtime inode pointers in the mount structure
1179 */
Eric Sandeen0771fb42007-10-12 11:03:40 +10001180 error = xfs_rtmount_inodes(mp);
1181 if (error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001182 /*
1183 * Free up the root inode.
1184 */
1185 cmn_err(CE_WARN, "XFS: failed to read RT inodes");
1186 goto error4;
1187 }
1188
1189 /*
David Chinneree1c0902008-03-06 13:45:50 +11001190 * If fs is not mounted readonly, then update the superblock changes.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001191 */
Christoph Hellwigbd186aa2007-08-30 17:21:12 +10001192 if (update_flags && !(mp->m_flags & XFS_MOUNT_RDONLY))
David Chinneree1c0902008-03-06 13:45:50 +11001193 xfs_mount_log_sb(mp, update_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001194
1195 /*
1196 * Initialise the XFS quota management subsystem for this mount
1197 */
Eric Sandeen0771fb42007-10-12 11:03:40 +10001198 error = XFS_QM_INIT(mp, &quotamount, &quotaflags);
1199 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200 goto error4;
1201
1202 /*
1203 * Finish recovering the file system. This part needed to be
1204 * delayed until after the root and real-time bitmap inodes
1205 * were consistently read in.
1206 */
1207 error = xfs_log_mount_finish(mp, mfsi_flags);
1208 if (error) {
1209 cmn_err(CE_WARN, "XFS: log mount finish failed");
1210 goto error4;
1211 }
1212
1213 /*
1214 * Complete the quota initialisation, post-log-replay component.
1215 */
Eric Sandeen0771fb42007-10-12 11:03:40 +10001216 error = XFS_QM_MOUNT(mp, quotamount, quotaflags, mfsi_flags);
1217 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001218 goto error4;
1219
David Chinner84e1e992007-06-18 16:50:27 +10001220 /*
1221 * Now we are mounted, reserve a small amount of unused space for
1222 * privileged transactions. This is needed so that transaction
1223 * space required for critical operations can dip into this pool
1224 * when at ENOSPC. This is needed for operations like create with
1225 * attr, unwritten extent conversion at ENOSPC, etc. Data allocations
1226 * are not allowed to use this reserved space.
1227 *
1228 * We default to 5% or 1024 fsbs of space reserved, whichever is smaller.
1229 * This may drive us straight to ENOSPC on mount, but that implies
1230 * we were already there on the last unmount.
1231 */
Christoph Hellwig39726be2007-06-18 17:57:45 +10001232 resblks = mp->m_sb.sb_dblocks;
1233 do_div(resblks, 20);
1234 resblks = min_t(__uint64_t, resblks, 1024);
David Chinner84e1e992007-06-18 16:50:27 +10001235 xfs_reserve_blocks(mp, &resblks, NULL);
1236
Linus Torvalds1da177e2005-04-16 15:20:36 -07001237 return 0;
1238
1239 error4:
1240 /*
1241 * Free up the root inode.
1242 */
Christoph Hellwig43355092008-03-27 18:01:08 +11001243 IRELE(rip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001244 error3:
1245 xfs_log_unmount_dealloc(mp);
1246 error2:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001247 for (agno = 0; agno < sbp->sb_agcount; agno++)
1248 if (mp->m_perag[agno].pagb_list)
1249 kmem_free(mp->m_perag[agno].pagb_list,
1250 sizeof(xfs_perag_busy_t) * XFS_PAGB_NUM_SLOTS);
1251 kmem_free(mp->m_perag, sbp->sb_agcount * sizeof(xfs_perag_t));
1252 mp->m_perag = NULL;
1253 /* FALLTHROUGH */
1254 error1:
1255 if (uuid_mounted)
1256 xfs_uuid_unmount(mp);
1257 xfs_freesb(mp);
1258 return error;
1259}
1260
1261/*
1262 * xfs_unmountfs
1263 *
1264 * This flushes out the inodes,dquots and the superblock, unmounts the
1265 * log and makes sure that incore structures are freed.
1266 */
1267int
1268xfs_unmountfs(xfs_mount_t *mp, struct cred *cr)
1269{
David Chinner84e1e992007-06-18 16:50:27 +10001270 __uint64_t resblks;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001271
David Chinner641c56f2007-06-18 16:50:17 +10001272 /*
1273 * We can potentially deadlock here if we have an inode cluster
1274 * that has been freed has it's buffer still pinned in memory because
1275 * the transaction is still sitting in a iclog. The stale inodes
1276 * on that buffer will have their flush locks held until the
1277 * transaction hits the disk and the callbacks run. the inode
1278 * flush takes the flush lock unconditionally and with nothing to
1279 * push out the iclog we will never get that unlocked. hence we
1280 * need to force the log first.
1281 */
1282 xfs_log_force(mp, (xfs_lsn_t)0, XFS_LOG_FORCE | XFS_LOG_SYNC);
Christoph Hellwigefa80272005-06-21 15:37:17 +10001283 xfs_iflush_all(mp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284
Nathan Scottee2a4f72006-01-11 15:33:36 +11001285 XFS_QM_DQPURGEALL(mp, XFS_QMOPT_QUOTALL | XFS_QMOPT_UMOUNTING);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001286
1287 /*
1288 * Flush out the log synchronously so that we know for sure
1289 * that nothing is pinned. This is important because bflush()
1290 * will skip pinned buffers.
1291 */
1292 xfs_log_force(mp, (xfs_lsn_t)0, XFS_LOG_FORCE | XFS_LOG_SYNC);
1293
1294 xfs_binval(mp->m_ddev_targp);
1295 if (mp->m_rtdev_targp) {
1296 xfs_binval(mp->m_rtdev_targp);
1297 }
1298
David Chinner84e1e992007-06-18 16:50:27 +10001299 /*
1300 * Unreserve any blocks we have so that when we unmount we don't account
1301 * the reserved free space as used. This is really only necessary for
1302 * lazy superblock counting because it trusts the incore superblock
1303 * counters to be aboslutely correct on clean unmount.
1304 *
1305 * We don't bother correcting this elsewhere for lazy superblock
1306 * counting because on mount of an unclean filesystem we reconstruct the
1307 * correct counter value and this is irrelevant.
1308 *
1309 * For non-lazy counter filesystems, this doesn't matter at all because
1310 * we only every apply deltas to the superblock and hence the incore
1311 * value does not matter....
1312 */
1313 resblks = 0;
1314 xfs_reserve_blocks(mp, &resblks, NULL);
1315
David Chinner92821e22007-05-24 15:26:31 +10001316 xfs_log_sbcount(mp, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001317 xfs_unmountfs_writesb(mp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318 xfs_unmountfs_wait(mp); /* wait for async bufs */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001319 xfs_log_unmount(mp); /* Done! No more fs ops. */
1320
1321 xfs_freesb(mp);
1322
1323 /*
1324 * All inodes from this mount point should be freed.
1325 */
1326 ASSERT(mp->m_inodes == NULL);
1327
Linus Torvalds1da177e2005-04-16 15:20:36 -07001328 xfs_unmountfs_close(mp, cr);
1329 if ((mp->m_flags & XFS_MOUNT_NOUUID) == 0)
1330 xfs_uuid_unmount(mp);
1331
1332#if defined(DEBUG) || defined(INDUCE_IO_ERROR)
Christoph Hellwig0ce4cfd2007-08-30 17:20:53 +10001333 xfs_errortag_clearall(mp, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001334#endif
Christoph Hellwig745f6912007-08-30 17:20:39 +10001335 xfs_mount_free(mp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001336 return 0;
1337}
1338
1339void
1340xfs_unmountfs_close(xfs_mount_t *mp, struct cred *cr)
1341{
Jesper Juhl49ee6c92007-08-16 16:25:42 +10001342 if (mp->m_logdev_targp && mp->m_logdev_targp != mp->m_ddev_targp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001343 xfs_free_buftarg(mp->m_logdev_targp, 1);
1344 if (mp->m_rtdev_targp)
1345 xfs_free_buftarg(mp->m_rtdev_targp, 1);
1346 xfs_free_buftarg(mp->m_ddev_targp, 0);
1347}
1348
Christoph Hellwigba0f32d2005-06-21 15:36:52 +10001349STATIC void
Linus Torvalds1da177e2005-04-16 15:20:36 -07001350xfs_unmountfs_wait(xfs_mount_t *mp)
1351{
1352 if (mp->m_logdev_targp != mp->m_ddev_targp)
1353 xfs_wait_buftarg(mp->m_logdev_targp);
1354 if (mp->m_rtdev_targp)
1355 xfs_wait_buftarg(mp->m_rtdev_targp);
1356 xfs_wait_buftarg(mp->m_ddev_targp);
1357}
1358
1359int
David Chinner92821e22007-05-24 15:26:31 +10001360xfs_fs_writable(xfs_mount_t *mp)
1361{
Christoph Hellwigb267ce92007-08-30 17:21:30 +10001362 return !(xfs_test_for_freeze(mp) || XFS_FORCED_SHUTDOWN(mp) ||
Christoph Hellwigbd186aa2007-08-30 17:21:12 +10001363 (mp->m_flags & XFS_MOUNT_RDONLY));
David Chinner92821e22007-05-24 15:26:31 +10001364}
1365
1366/*
1367 * xfs_log_sbcount
1368 *
1369 * Called either periodically to keep the on disk superblock values
1370 * roughly up to date or from unmount to make sure the values are
1371 * correct on a clean unmount.
1372 *
1373 * Note this code can be called during the process of freezing, so
1374 * we may need to use the transaction allocator which does not not
1375 * block when the transaction subsystem is in its frozen state.
1376 */
1377int
1378xfs_log_sbcount(
1379 xfs_mount_t *mp,
1380 uint sync)
1381{
1382 xfs_trans_t *tp;
1383 int error;
1384
1385 if (!xfs_fs_writable(mp))
1386 return 0;
1387
1388 xfs_icsb_sync_counters(mp);
1389
1390 /*
1391 * we don't need to do this if we are updating the superblock
1392 * counters on every modification.
1393 */
1394 if (!xfs_sb_version_haslazysbcount(&mp->m_sb))
1395 return 0;
1396
1397 tp = _xfs_trans_alloc(mp, XFS_TRANS_SB_COUNT);
1398 error = xfs_trans_reserve(tp, 0, mp->m_sb.sb_sectsize + 128, 0, 0,
1399 XFS_DEFAULT_LOG_COUNT);
1400 if (error) {
1401 xfs_trans_cancel(tp, 0);
1402 return error;
1403 }
1404
1405 xfs_mod_sb(tp, XFS_SB_IFREE | XFS_SB_ICOUNT | XFS_SB_FDBLOCKS);
1406 if (sync)
1407 xfs_trans_set_sync(tp);
1408 xfs_trans_commit(tp, 0);
1409
1410 return 0;
1411}
1412
Christoph Hellwig2bdf7cd2007-08-28 13:58:06 +10001413STATIC void
1414xfs_mark_shared_ro(
1415 xfs_mount_t *mp,
1416 xfs_buf_t *bp)
1417{
1418 xfs_dsb_t *sb = XFS_BUF_TO_SBP(bp);
1419 __uint16_t version;
1420
1421 if (!(sb->sb_flags & XFS_SBF_READONLY))
1422 sb->sb_flags |= XFS_SBF_READONLY;
1423
1424 version = be16_to_cpu(sb->sb_versionnum);
1425 if ((version & XFS_SB_VERSION_NUMBITS) != XFS_SB_VERSION_4 ||
1426 !(version & XFS_SB_VERSION_SHAREDBIT))
1427 version |= XFS_SB_VERSION_SHAREDBIT;
1428 sb->sb_versionnum = cpu_to_be16(version);
1429}
1430
David Chinner92821e22007-05-24 15:26:31 +10001431int
Linus Torvalds1da177e2005-04-16 15:20:36 -07001432xfs_unmountfs_writesb(xfs_mount_t *mp)
1433{
1434 xfs_buf_t *sbp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001435 int error = 0;
1436
1437 /*
1438 * skip superblock write if fs is read-only, or
1439 * if we are doing a forced umount.
1440 */
Christoph Hellwigbd186aa2007-08-30 17:21:12 +10001441 if (!((mp->m_flags & XFS_MOUNT_RDONLY) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -07001442 XFS_FORCED_SHUTDOWN(mp))) {
David Chinner8d280b92006-03-14 13:13:09 +11001443
David Chinner92821e22007-05-24 15:26:31 +10001444 sbp = xfs_getsb(mp, 0);
David Chinner8d280b92006-03-14 13:13:09 +11001445
Linus Torvalds1da177e2005-04-16 15:20:36 -07001446 /*
1447 * mark shared-readonly if desired
1448 */
Christoph Hellwig2bdf7cd2007-08-28 13:58:06 +10001449 if (mp->m_mk_sharedro)
1450 xfs_mark_shared_ro(mp, sbp);
David Chinner92821e22007-05-24 15:26:31 +10001451
Linus Torvalds1da177e2005-04-16 15:20:36 -07001452 XFS_BUF_UNDONE(sbp);
1453 XFS_BUF_UNREAD(sbp);
1454 XFS_BUF_UNDELAYWRITE(sbp);
1455 XFS_BUF_WRITE(sbp);
1456 XFS_BUF_UNASYNC(sbp);
1457 ASSERT(XFS_BUF_TARGET(sbp) == mp->m_ddev_targp);
1458 xfsbdstrat(mp, sbp);
1459 /* Nevermind errors we might get here. */
1460 error = xfs_iowait(sbp);
1461 if (error)
1462 xfs_ioerror_alert("xfs_unmountfs_writesb",
1463 mp, sbp, XFS_BUF_ADDR(sbp));
1464 if (error && mp->m_mk_sharedro)
1465 xfs_fs_cmn_err(CE_ALERT, mp, "Superblock write error detected while unmounting. Filesystem may not be marked shared readonly");
David Chinner92821e22007-05-24 15:26:31 +10001466 xfs_buf_relse(sbp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001467 }
Jesper Juhl014c2542006-01-15 02:37:08 +01001468 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001469}
1470
1471/*
1472 * xfs_mod_sb() can be used to copy arbitrary changes to the
1473 * in-core superblock into the superblock buffer to be logged.
1474 * It does not provide the higher level of locking that is
1475 * needed to protect the in-core superblock from concurrent
1476 * access.
1477 */
1478void
1479xfs_mod_sb(xfs_trans_t *tp, __int64_t fields)
1480{
1481 xfs_buf_t *bp;
1482 int first;
1483 int last;
1484 xfs_mount_t *mp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001485 xfs_sb_field_t f;
1486
1487 ASSERT(fields);
1488 if (!fields)
1489 return;
1490 mp = tp->t_mountp;
1491 bp = xfs_trans_getsb(tp, mp, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001492 first = sizeof(xfs_sb_t);
1493 last = 0;
1494
1495 /* translate/copy */
1496
Christoph Hellwig2bdf7cd2007-08-28 13:58:06 +10001497 xfs_sb_to_disk(XFS_BUF_TO_SBP(bp), &mp->m_sb, fields);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001498
1499 /* find modified range */
1500
1501 f = (xfs_sb_field_t)xfs_lowbit64((__uint64_t)fields);
1502 ASSERT((1LL << f) & XFS_SB_MOD_BITS);
1503 first = xfs_sb_info[f].offset;
1504
1505 f = (xfs_sb_field_t)xfs_highbit64((__uint64_t)fields);
1506 ASSERT((1LL << f) & XFS_SB_MOD_BITS);
1507 last = xfs_sb_info[f + 1].offset - 1;
1508
1509 xfs_trans_log_buf(tp, bp, first, last);
1510}
Yingping Lud210a282006-06-09 14:55:18 +10001511
Yingping Lud210a282006-06-09 14:55:18 +10001512
Linus Torvalds1da177e2005-04-16 15:20:36 -07001513/*
1514 * xfs_mod_incore_sb_unlocked() is a utility routine common used to apply
1515 * a delta to a specified field in the in-core superblock. Simply
1516 * switch on the field indicated and apply the delta to that field.
1517 * Fields are not allowed to dip below zero, so if the delta would
1518 * do this do not apply it and return EINVAL.
1519 *
Eric Sandeen3685c2a2007-10-11 17:42:32 +10001520 * The m_sb_lock must be held when this routine is called.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001521 */
David Chinner8d280b92006-03-14 13:13:09 +11001522int
David Chinner20f4ebf2007-02-10 18:36:10 +11001523xfs_mod_incore_sb_unlocked(
1524 xfs_mount_t *mp,
1525 xfs_sb_field_t field,
1526 int64_t delta,
1527 int rsvd)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001528{
1529 int scounter; /* short counter for 32 bit fields */
1530 long long lcounter; /* long counter for 64 bit fields */
1531 long long res_used, rem;
1532
1533 /*
1534 * With the in-core superblock spin lock held, switch
1535 * on the indicated field. Apply the delta to the
1536 * proper field. If the fields value would dip below
1537 * 0, then do not apply the delta and return EINVAL.
1538 */
1539 switch (field) {
1540 case XFS_SBS_ICOUNT:
1541 lcounter = (long long)mp->m_sb.sb_icount;
1542 lcounter += delta;
1543 if (lcounter < 0) {
1544 ASSERT(0);
Jesper Juhl014c2542006-01-15 02:37:08 +01001545 return XFS_ERROR(EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001546 }
1547 mp->m_sb.sb_icount = lcounter;
Jesper Juhl014c2542006-01-15 02:37:08 +01001548 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001549 case XFS_SBS_IFREE:
1550 lcounter = (long long)mp->m_sb.sb_ifree;
1551 lcounter += delta;
1552 if (lcounter < 0) {
1553 ASSERT(0);
Jesper Juhl014c2542006-01-15 02:37:08 +01001554 return XFS_ERROR(EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001555 }
1556 mp->m_sb.sb_ifree = lcounter;
Jesper Juhl014c2542006-01-15 02:37:08 +01001557 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001558 case XFS_SBS_FDBLOCKS:
David Chinner4be536d2006-09-07 14:26:50 +10001559 lcounter = (long long)
1560 mp->m_sb.sb_fdblocks - XFS_ALLOC_SET_ASIDE(mp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001561 res_used = (long long)(mp->m_resblks - mp->m_resblks_avail);
1562
1563 if (delta > 0) { /* Putting blocks back */
1564 if (res_used > delta) {
1565 mp->m_resblks_avail += delta;
1566 } else {
1567 rem = delta - res_used;
1568 mp->m_resblks_avail = mp->m_resblks;
1569 lcounter += rem;
1570 }
1571 } else { /* Taking blocks away */
1572
1573 lcounter += delta;
1574
1575 /*
1576 * If were out of blocks, use any available reserved blocks if
1577 * were allowed to.
1578 */
1579
1580 if (lcounter < 0) {
1581 if (rsvd) {
1582 lcounter = (long long)mp->m_resblks_avail + delta;
1583 if (lcounter < 0) {
Jesper Juhl014c2542006-01-15 02:37:08 +01001584 return XFS_ERROR(ENOSPC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001585 }
1586 mp->m_resblks_avail = lcounter;
Jesper Juhl014c2542006-01-15 02:37:08 +01001587 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001588 } else { /* not reserved */
Jesper Juhl014c2542006-01-15 02:37:08 +01001589 return XFS_ERROR(ENOSPC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001590 }
1591 }
1592 }
1593
David Chinner4be536d2006-09-07 14:26:50 +10001594 mp->m_sb.sb_fdblocks = lcounter + XFS_ALLOC_SET_ASIDE(mp);
Jesper Juhl014c2542006-01-15 02:37:08 +01001595 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001596 case XFS_SBS_FREXTENTS:
1597 lcounter = (long long)mp->m_sb.sb_frextents;
1598 lcounter += delta;
1599 if (lcounter < 0) {
Jesper Juhl014c2542006-01-15 02:37:08 +01001600 return XFS_ERROR(ENOSPC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001601 }
1602 mp->m_sb.sb_frextents = lcounter;
Jesper Juhl014c2542006-01-15 02:37:08 +01001603 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001604 case XFS_SBS_DBLOCKS:
1605 lcounter = (long long)mp->m_sb.sb_dblocks;
1606 lcounter += delta;
1607 if (lcounter < 0) {
1608 ASSERT(0);
Jesper Juhl014c2542006-01-15 02:37:08 +01001609 return XFS_ERROR(EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001610 }
1611 mp->m_sb.sb_dblocks = lcounter;
Jesper Juhl014c2542006-01-15 02:37:08 +01001612 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001613 case XFS_SBS_AGCOUNT:
1614 scounter = mp->m_sb.sb_agcount;
1615 scounter += delta;
1616 if (scounter < 0) {
1617 ASSERT(0);
Jesper Juhl014c2542006-01-15 02:37:08 +01001618 return XFS_ERROR(EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001619 }
1620 mp->m_sb.sb_agcount = scounter;
Jesper Juhl014c2542006-01-15 02:37:08 +01001621 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001622 case XFS_SBS_IMAX_PCT:
1623 scounter = mp->m_sb.sb_imax_pct;
1624 scounter += delta;
1625 if (scounter < 0) {
1626 ASSERT(0);
Jesper Juhl014c2542006-01-15 02:37:08 +01001627 return XFS_ERROR(EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001628 }
1629 mp->m_sb.sb_imax_pct = scounter;
Jesper Juhl014c2542006-01-15 02:37:08 +01001630 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001631 case XFS_SBS_REXTSIZE:
1632 scounter = mp->m_sb.sb_rextsize;
1633 scounter += delta;
1634 if (scounter < 0) {
1635 ASSERT(0);
Jesper Juhl014c2542006-01-15 02:37:08 +01001636 return XFS_ERROR(EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001637 }
1638 mp->m_sb.sb_rextsize = scounter;
Jesper Juhl014c2542006-01-15 02:37:08 +01001639 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001640 case XFS_SBS_RBMBLOCKS:
1641 scounter = mp->m_sb.sb_rbmblocks;
1642 scounter += delta;
1643 if (scounter < 0) {
1644 ASSERT(0);
Jesper Juhl014c2542006-01-15 02:37:08 +01001645 return XFS_ERROR(EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001646 }
1647 mp->m_sb.sb_rbmblocks = scounter;
Jesper Juhl014c2542006-01-15 02:37:08 +01001648 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001649 case XFS_SBS_RBLOCKS:
1650 lcounter = (long long)mp->m_sb.sb_rblocks;
1651 lcounter += delta;
1652 if (lcounter < 0) {
1653 ASSERT(0);
Jesper Juhl014c2542006-01-15 02:37:08 +01001654 return XFS_ERROR(EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001655 }
1656 mp->m_sb.sb_rblocks = lcounter;
Jesper Juhl014c2542006-01-15 02:37:08 +01001657 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001658 case XFS_SBS_REXTENTS:
1659 lcounter = (long long)mp->m_sb.sb_rextents;
1660 lcounter += delta;
1661 if (lcounter < 0) {
1662 ASSERT(0);
Jesper Juhl014c2542006-01-15 02:37:08 +01001663 return XFS_ERROR(EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001664 }
1665 mp->m_sb.sb_rextents = lcounter;
Jesper Juhl014c2542006-01-15 02:37:08 +01001666 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001667 case XFS_SBS_REXTSLOG:
1668 scounter = mp->m_sb.sb_rextslog;
1669 scounter += delta;
1670 if (scounter < 0) {
1671 ASSERT(0);
Jesper Juhl014c2542006-01-15 02:37:08 +01001672 return XFS_ERROR(EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001673 }
1674 mp->m_sb.sb_rextslog = scounter;
Jesper Juhl014c2542006-01-15 02:37:08 +01001675 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001676 default:
1677 ASSERT(0);
Jesper Juhl014c2542006-01-15 02:37:08 +01001678 return XFS_ERROR(EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001679 }
1680}
1681
1682/*
1683 * xfs_mod_incore_sb() is used to change a field in the in-core
1684 * superblock structure by the specified delta. This modification
Eric Sandeen3685c2a2007-10-11 17:42:32 +10001685 * is protected by the m_sb_lock. Just use the xfs_mod_incore_sb_unlocked()
Linus Torvalds1da177e2005-04-16 15:20:36 -07001686 * routine to do the work.
1687 */
1688int
David Chinner20f4ebf2007-02-10 18:36:10 +11001689xfs_mod_incore_sb(
1690 xfs_mount_t *mp,
1691 xfs_sb_field_t field,
1692 int64_t delta,
1693 int rsvd)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001694{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001695 int status;
1696
David Chinner8d280b92006-03-14 13:13:09 +11001697 /* check for per-cpu counters */
1698 switch (field) {
1699#ifdef HAVE_PERCPU_SB
1700 case XFS_SBS_ICOUNT:
1701 case XFS_SBS_IFREE:
1702 case XFS_SBS_FDBLOCKS:
1703 if (!(mp->m_flags & XFS_MOUNT_NO_PERCPU_SB)) {
1704 status = xfs_icsb_modify_counters(mp, field,
1705 delta, rsvd);
1706 break;
1707 }
1708 /* FALLTHROUGH */
1709#endif
1710 default:
Eric Sandeen3685c2a2007-10-11 17:42:32 +10001711 spin_lock(&mp->m_sb_lock);
David Chinner8d280b92006-03-14 13:13:09 +11001712 status = xfs_mod_incore_sb_unlocked(mp, field, delta, rsvd);
Eric Sandeen3685c2a2007-10-11 17:42:32 +10001713 spin_unlock(&mp->m_sb_lock);
David Chinner8d280b92006-03-14 13:13:09 +11001714 break;
1715 }
1716
Jesper Juhl014c2542006-01-15 02:37:08 +01001717 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001718}
1719
1720/*
1721 * xfs_mod_incore_sb_batch() is used to change more than one field
1722 * in the in-core superblock structure at a time. This modification
1723 * is protected by a lock internal to this module. The fields and
1724 * changes to those fields are specified in the array of xfs_mod_sb
1725 * structures passed in.
1726 *
1727 * Either all of the specified deltas will be applied or none of
1728 * them will. If any modified field dips below 0, then all modifications
1729 * will be backed out and EINVAL will be returned.
1730 */
1731int
1732xfs_mod_incore_sb_batch(xfs_mount_t *mp, xfs_mod_sb_t *msb, uint nmsb, int rsvd)
1733{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001734 int status=0;
1735 xfs_mod_sb_t *msbp;
1736
1737 /*
1738 * Loop through the array of mod structures and apply each
1739 * individually. If any fail, then back out all those
1740 * which have already been applied. Do all of this within
Eric Sandeen3685c2a2007-10-11 17:42:32 +10001741 * the scope of the m_sb_lock so that all of the changes will
Linus Torvalds1da177e2005-04-16 15:20:36 -07001742 * be atomic.
1743 */
Eric Sandeen3685c2a2007-10-11 17:42:32 +10001744 spin_lock(&mp->m_sb_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001745 msbp = &msb[0];
1746 for (msbp = &msbp[0]; msbp < (msb + nmsb); msbp++) {
1747 /*
1748 * Apply the delta at index n. If it fails, break
1749 * from the loop so we'll fall into the undo loop
1750 * below.
1751 */
David Chinner8d280b92006-03-14 13:13:09 +11001752 switch (msbp->msb_field) {
1753#ifdef HAVE_PERCPU_SB
1754 case XFS_SBS_ICOUNT:
1755 case XFS_SBS_IFREE:
1756 case XFS_SBS_FDBLOCKS:
1757 if (!(mp->m_flags & XFS_MOUNT_NO_PERCPU_SB)) {
Eric Sandeen3685c2a2007-10-11 17:42:32 +10001758 spin_unlock(&mp->m_sb_lock);
David Chinner20b64282007-02-10 18:35:09 +11001759 status = xfs_icsb_modify_counters(mp,
David Chinner8d280b92006-03-14 13:13:09 +11001760 msbp->msb_field,
1761 msbp->msb_delta, rsvd);
Eric Sandeen3685c2a2007-10-11 17:42:32 +10001762 spin_lock(&mp->m_sb_lock);
David Chinner8d280b92006-03-14 13:13:09 +11001763 break;
1764 }
1765 /* FALLTHROUGH */
1766#endif
1767 default:
1768 status = xfs_mod_incore_sb_unlocked(mp,
1769 msbp->msb_field,
1770 msbp->msb_delta, rsvd);
1771 break;
1772 }
1773
Linus Torvalds1da177e2005-04-16 15:20:36 -07001774 if (status != 0) {
1775 break;
1776 }
1777 }
1778
1779 /*
1780 * If we didn't complete the loop above, then back out
1781 * any changes made to the superblock. If you add code
1782 * between the loop above and here, make sure that you
1783 * preserve the value of status. Loop back until
1784 * we step below the beginning of the array. Make sure
1785 * we don't touch anything back there.
1786 */
1787 if (status != 0) {
1788 msbp--;
1789 while (msbp >= msb) {
David Chinner8d280b92006-03-14 13:13:09 +11001790 switch (msbp->msb_field) {
1791#ifdef HAVE_PERCPU_SB
1792 case XFS_SBS_ICOUNT:
1793 case XFS_SBS_IFREE:
1794 case XFS_SBS_FDBLOCKS:
1795 if (!(mp->m_flags & XFS_MOUNT_NO_PERCPU_SB)) {
Eric Sandeen3685c2a2007-10-11 17:42:32 +10001796 spin_unlock(&mp->m_sb_lock);
David Chinner20b64282007-02-10 18:35:09 +11001797 status = xfs_icsb_modify_counters(mp,
David Chinner8d280b92006-03-14 13:13:09 +11001798 msbp->msb_field,
1799 -(msbp->msb_delta),
1800 rsvd);
Eric Sandeen3685c2a2007-10-11 17:42:32 +10001801 spin_lock(&mp->m_sb_lock);
David Chinner8d280b92006-03-14 13:13:09 +11001802 break;
1803 }
1804 /* FALLTHROUGH */
1805#endif
1806 default:
1807 status = xfs_mod_incore_sb_unlocked(mp,
1808 msbp->msb_field,
1809 -(msbp->msb_delta),
1810 rsvd);
1811 break;
1812 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001813 ASSERT(status == 0);
1814 msbp--;
1815 }
1816 }
Eric Sandeen3685c2a2007-10-11 17:42:32 +10001817 spin_unlock(&mp->m_sb_lock);
Jesper Juhl014c2542006-01-15 02:37:08 +01001818 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001819}
1820
1821/*
1822 * xfs_getsb() is called to obtain the buffer for the superblock.
1823 * The buffer is returned locked and read in from disk.
1824 * The buffer should be released with a call to xfs_brelse().
1825 *
1826 * If the flags parameter is BUF_TRYLOCK, then we'll only return
1827 * the superblock buffer if it can be locked without sleeping.
1828 * If it can't then we'll return NULL.
1829 */
1830xfs_buf_t *
1831xfs_getsb(
1832 xfs_mount_t *mp,
1833 int flags)
1834{
1835 xfs_buf_t *bp;
1836
1837 ASSERT(mp->m_sb_bp != NULL);
1838 bp = mp->m_sb_bp;
1839 if (flags & XFS_BUF_TRYLOCK) {
1840 if (!XFS_BUF_CPSEMA(bp)) {
1841 return NULL;
1842 }
1843 } else {
1844 XFS_BUF_PSEMA(bp, PRIBIO);
1845 }
1846 XFS_BUF_HOLD(bp);
1847 ASSERT(XFS_BUF_ISDONE(bp));
Jesper Juhl014c2542006-01-15 02:37:08 +01001848 return bp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001849}
1850
1851/*
1852 * Used to free the superblock along various error paths.
1853 */
1854void
1855xfs_freesb(
1856 xfs_mount_t *mp)
1857{
1858 xfs_buf_t *bp;
1859
1860 /*
1861 * Use xfs_getsb() so that the buffer will be locked
1862 * when we call xfs_buf_relse().
1863 */
1864 bp = xfs_getsb(mp, 0);
1865 XFS_BUF_UNMANAGE(bp);
1866 xfs_buf_relse(bp);
1867 mp->m_sb_bp = NULL;
1868}
1869
1870/*
1871 * See if the UUID is unique among mounted XFS filesystems.
1872 * Mount fails if UUID is nil or a FS with the same UUID is already mounted.
1873 */
1874STATIC int
1875xfs_uuid_mount(
1876 xfs_mount_t *mp)
1877{
1878 if (uuid_is_nil(&mp->m_sb.sb_uuid)) {
1879 cmn_err(CE_WARN,
1880 "XFS: Filesystem %s has nil UUID - can't mount",
1881 mp->m_fsname);
1882 return -1;
1883 }
1884 if (!uuid_table_insert(&mp->m_sb.sb_uuid)) {
1885 cmn_err(CE_WARN,
1886 "XFS: Filesystem %s has duplicate UUID - can't mount",
1887 mp->m_fsname);
1888 return -1;
1889 }
1890 return 0;
1891}
1892
1893/*
1894 * Remove filesystem from the UUID table.
1895 */
1896STATIC void
1897xfs_uuid_unmount(
1898 xfs_mount_t *mp)
1899{
1900 uuid_table_remove(&mp->m_sb.sb_uuid);
1901}
1902
1903/*
1904 * Used to log changes to the superblock unit and width fields which could
Eric Sandeene6957ea2008-04-10 12:19:34 +10001905 * be altered by the mount options, as well as any potential sb_features2
1906 * fixup. Only the first superblock is updated.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001907 */
1908STATIC void
David Chinneree1c0902008-03-06 13:45:50 +11001909xfs_mount_log_sb(
Linus Torvalds1da177e2005-04-16 15:20:36 -07001910 xfs_mount_t *mp,
1911 __int64_t fields)
1912{
1913 xfs_trans_t *tp;
1914
David Chinneree1c0902008-03-06 13:45:50 +11001915 ASSERT(fields & (XFS_SB_UNIT | XFS_SB_WIDTH | XFS_SB_UUID |
1916 XFS_SB_FEATURES2 | XFS_SB_BAD_FEATURES2));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001917
1918 tp = xfs_trans_alloc(mp, XFS_TRANS_SB_UNIT);
1919 if (xfs_trans_reserve(tp, 0, mp->m_sb.sb_sectsize + 128, 0, 0,
1920 XFS_DEFAULT_LOG_COUNT)) {
1921 xfs_trans_cancel(tp, 0);
1922 return;
1923 }
1924 xfs_mod_sb(tp, fields);
Eric Sandeen1c72bf92007-05-08 13:48:42 +10001925 xfs_trans_commit(tp, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001926}
David Chinner8d280b92006-03-14 13:13:09 +11001927
1928
1929#ifdef HAVE_PERCPU_SB
1930/*
1931 * Per-cpu incore superblock counters
1932 *
1933 * Simple concept, difficult implementation
1934 *
1935 * Basically, replace the incore superblock counters with a distributed per cpu
1936 * counter for contended fields (e.g. free block count).
1937 *
1938 * Difficulties arise in that the incore sb is used for ENOSPC checking, and
1939 * hence needs to be accurately read when we are running low on space. Hence
1940 * there is a method to enable and disable the per-cpu counters based on how
1941 * much "stuff" is available in them.
1942 *
1943 * Basically, a counter is enabled if there is enough free resource to justify
1944 * running a per-cpu fast-path. If the per-cpu counter runs out (i.e. a local
1945 * ENOSPC), then we disable the counters to synchronise all callers and
1946 * re-distribute the available resources.
1947 *
1948 * If, once we redistributed the available resources, we still get a failure,
1949 * we disable the per-cpu counter and go through the slow path.
1950 *
1951 * The slow path is the current xfs_mod_incore_sb() function. This means that
1952 * when we disable a per-cpu counter, we need to drain it's resources back to
1953 * the global superblock. We do this after disabling the counter to prevent
1954 * more threads from queueing up on the counter.
1955 *
1956 * Essentially, this means that we still need a lock in the fast path to enable
1957 * synchronisation between the global counters and the per-cpu counters. This
1958 * is not a problem because the lock will be local to a CPU almost all the time
1959 * and have little contention except when we get to ENOSPC conditions.
1960 *
1961 * Basically, this lock becomes a barrier that enables us to lock out the fast
1962 * path while we do things like enabling and disabling counters and
1963 * synchronising the counters.
1964 *
1965 * Locking rules:
1966 *
Eric Sandeen3685c2a2007-10-11 17:42:32 +10001967 * 1. m_sb_lock before picking up per-cpu locks
David Chinner8d280b92006-03-14 13:13:09 +11001968 * 2. per-cpu locks always picked up via for_each_online_cpu() order
Eric Sandeen3685c2a2007-10-11 17:42:32 +10001969 * 3. accurate counter sync requires m_sb_lock + per cpu locks
David Chinner8d280b92006-03-14 13:13:09 +11001970 * 4. modifying per-cpu counters requires holding per-cpu lock
Eric Sandeen3685c2a2007-10-11 17:42:32 +10001971 * 5. modifying global counters requires holding m_sb_lock
1972 * 6. enabling or disabling a counter requires holding the m_sb_lock
David Chinner8d280b92006-03-14 13:13:09 +11001973 * and _none_ of the per-cpu locks.
1974 *
1975 * Disabled counters are only ever re-enabled by a balance operation
1976 * that results in more free resources per CPU than a given threshold.
1977 * To ensure counters don't remain disabled, they are rebalanced when
1978 * the global resource goes above a higher threshold (i.e. some hysteresis
1979 * is present to prevent thrashing).
David Chinner8d280b92006-03-14 13:13:09 +11001980 */
David Chinnere8234a62006-03-14 13:23:52 +11001981
Chandra Seetharaman5a67e4c2006-06-27 02:54:11 -07001982#ifdef CONFIG_HOTPLUG_CPU
David Chinnere8234a62006-03-14 13:23:52 +11001983/*
1984 * hot-plug CPU notifier support.
1985 *
Chandra Seetharaman5a67e4c2006-06-27 02:54:11 -07001986 * We need a notifier per filesystem as we need to be able to identify
1987 * the filesystem to balance the counters out. This is achieved by
1988 * having a notifier block embedded in the xfs_mount_t and doing pointer
1989 * magic to get the mount pointer from the notifier block address.
David Chinnere8234a62006-03-14 13:23:52 +11001990 */
1991STATIC int
1992xfs_icsb_cpu_notify(
1993 struct notifier_block *nfb,
1994 unsigned long action,
1995 void *hcpu)
1996{
1997 xfs_icsb_cnts_t *cntp;
1998 xfs_mount_t *mp;
David Chinnere8234a62006-03-14 13:23:52 +11001999
2000 mp = (xfs_mount_t *)container_of(nfb, xfs_mount_t, m_icsb_notifier);
2001 cntp = (xfs_icsb_cnts_t *)
2002 per_cpu_ptr(mp->m_sb_cnts, (unsigned long)hcpu);
2003 switch (action) {
2004 case CPU_UP_PREPARE:
Rafael J. Wysocki8bb78442007-05-09 02:35:10 -07002005 case CPU_UP_PREPARE_FROZEN:
David Chinnere8234a62006-03-14 13:23:52 +11002006 /* Easy Case - initialize the area and locks, and
2007 * then rebalance when online does everything else for us. */
David Chinner01e1b692006-03-14 13:29:16 +11002008 memset(cntp, 0, sizeof(xfs_icsb_cnts_t));
David Chinnere8234a62006-03-14 13:23:52 +11002009 break;
2010 case CPU_ONLINE:
Rafael J. Wysocki8bb78442007-05-09 02:35:10 -07002011 case CPU_ONLINE_FROZEN:
David Chinner03135cf2007-02-10 18:35:15 +11002012 xfs_icsb_lock(mp);
David Chinner20b64282007-02-10 18:35:09 +11002013 xfs_icsb_balance_counter(mp, XFS_SBS_ICOUNT, 0, 0);
2014 xfs_icsb_balance_counter(mp, XFS_SBS_IFREE, 0, 0);
2015 xfs_icsb_balance_counter(mp, XFS_SBS_FDBLOCKS, 0, 0);
David Chinner03135cf2007-02-10 18:35:15 +11002016 xfs_icsb_unlock(mp);
David Chinnere8234a62006-03-14 13:23:52 +11002017 break;
2018 case CPU_DEAD:
Rafael J. Wysocki8bb78442007-05-09 02:35:10 -07002019 case CPU_DEAD_FROZEN:
David Chinnere8234a62006-03-14 13:23:52 +11002020 /* Disable all the counters, then fold the dead cpu's
2021 * count into the total on the global superblock and
2022 * re-enable the counters. */
David Chinner03135cf2007-02-10 18:35:15 +11002023 xfs_icsb_lock(mp);
Eric Sandeen3685c2a2007-10-11 17:42:32 +10002024 spin_lock(&mp->m_sb_lock);
David Chinnere8234a62006-03-14 13:23:52 +11002025 xfs_icsb_disable_counter(mp, XFS_SBS_ICOUNT);
2026 xfs_icsb_disable_counter(mp, XFS_SBS_IFREE);
2027 xfs_icsb_disable_counter(mp, XFS_SBS_FDBLOCKS);
2028
2029 mp->m_sb.sb_icount += cntp->icsb_icount;
2030 mp->m_sb.sb_ifree += cntp->icsb_ifree;
2031 mp->m_sb.sb_fdblocks += cntp->icsb_fdblocks;
2032
David Chinner01e1b692006-03-14 13:29:16 +11002033 memset(cntp, 0, sizeof(xfs_icsb_cnts_t));
David Chinnere8234a62006-03-14 13:23:52 +11002034
David Chinner20b64282007-02-10 18:35:09 +11002035 xfs_icsb_balance_counter(mp, XFS_SBS_ICOUNT,
2036 XFS_ICSB_SB_LOCKED, 0);
2037 xfs_icsb_balance_counter(mp, XFS_SBS_IFREE,
2038 XFS_ICSB_SB_LOCKED, 0);
2039 xfs_icsb_balance_counter(mp, XFS_SBS_FDBLOCKS,
2040 XFS_ICSB_SB_LOCKED, 0);
Eric Sandeen3685c2a2007-10-11 17:42:32 +10002041 spin_unlock(&mp->m_sb_lock);
David Chinner03135cf2007-02-10 18:35:15 +11002042 xfs_icsb_unlock(mp);
David Chinnere8234a62006-03-14 13:23:52 +11002043 break;
2044 }
2045
2046 return NOTIFY_OK;
2047}
Chandra Seetharaman5a67e4c2006-06-27 02:54:11 -07002048#endif /* CONFIG_HOTPLUG_CPU */
David Chinnere8234a62006-03-14 13:23:52 +11002049
David Chinner8d280b92006-03-14 13:13:09 +11002050int
2051xfs_icsb_init_counters(
2052 xfs_mount_t *mp)
2053{
2054 xfs_icsb_cnts_t *cntp;
2055 int i;
2056
2057 mp->m_sb_cnts = alloc_percpu(xfs_icsb_cnts_t);
2058 if (mp->m_sb_cnts == NULL)
2059 return -ENOMEM;
2060
Chandra Seetharaman5a67e4c2006-06-27 02:54:11 -07002061#ifdef CONFIG_HOTPLUG_CPU
David Chinnere8234a62006-03-14 13:23:52 +11002062 mp->m_icsb_notifier.notifier_call = xfs_icsb_cpu_notify;
2063 mp->m_icsb_notifier.priority = 0;
Chandra Seetharaman5a67e4c2006-06-27 02:54:11 -07002064 register_hotcpu_notifier(&mp->m_icsb_notifier);
2065#endif /* CONFIG_HOTPLUG_CPU */
David Chinnere8234a62006-03-14 13:23:52 +11002066
David Chinner8d280b92006-03-14 13:13:09 +11002067 for_each_online_cpu(i) {
2068 cntp = (xfs_icsb_cnts_t *)per_cpu_ptr(mp->m_sb_cnts, i);
David Chinner01e1b692006-03-14 13:29:16 +11002069 memset(cntp, 0, sizeof(xfs_icsb_cnts_t));
David Chinner8d280b92006-03-14 13:13:09 +11002070 }
David Chinner20b64282007-02-10 18:35:09 +11002071
2072 mutex_init(&mp->m_icsb_mutex);
2073
David Chinner8d280b92006-03-14 13:13:09 +11002074 /*
2075 * start with all counters disabled so that the
2076 * initial balance kicks us off correctly
2077 */
2078 mp->m_icsb_counters = -1;
2079 return 0;
2080}
2081
Lachlan McIlroy5478eea2007-02-10 18:36:29 +11002082void
2083xfs_icsb_reinit_counters(
2084 xfs_mount_t *mp)
2085{
2086 xfs_icsb_lock(mp);
2087 /*
2088 * start with all counters disabled so that the
2089 * initial balance kicks us off correctly
2090 */
2091 mp->m_icsb_counters = -1;
2092 xfs_icsb_balance_counter(mp, XFS_SBS_ICOUNT, 0, 0);
2093 xfs_icsb_balance_counter(mp, XFS_SBS_IFREE, 0, 0);
2094 xfs_icsb_balance_counter(mp, XFS_SBS_FDBLOCKS, 0, 0);
2095 xfs_icsb_unlock(mp);
2096}
2097
David Chinner8d280b92006-03-14 13:13:09 +11002098STATIC void
2099xfs_icsb_destroy_counters(
2100 xfs_mount_t *mp)
2101{
David Chinnere8234a62006-03-14 13:23:52 +11002102 if (mp->m_sb_cnts) {
Chandra Seetharaman5a67e4c2006-06-27 02:54:11 -07002103 unregister_hotcpu_notifier(&mp->m_icsb_notifier);
David Chinner8d280b92006-03-14 13:13:09 +11002104 free_percpu(mp->m_sb_cnts);
David Chinnere8234a62006-03-14 13:23:52 +11002105 }
David Chinner03135cf2007-02-10 18:35:15 +11002106 mutex_destroy(&mp->m_icsb_mutex);
David Chinner8d280b92006-03-14 13:13:09 +11002107}
2108
David Chinner7989cb82007-02-10 18:34:56 +11002109STATIC_INLINE void
David Chinner01e1b692006-03-14 13:29:16 +11002110xfs_icsb_lock_cntr(
2111 xfs_icsb_cnts_t *icsbp)
2112{
2113 while (test_and_set_bit(XFS_ICSB_FLAG_LOCK, &icsbp->icsb_flags)) {
2114 ndelay(1000);
2115 }
2116}
2117
David Chinner7989cb82007-02-10 18:34:56 +11002118STATIC_INLINE void
David Chinner01e1b692006-03-14 13:29:16 +11002119xfs_icsb_unlock_cntr(
2120 xfs_icsb_cnts_t *icsbp)
2121{
2122 clear_bit(XFS_ICSB_FLAG_LOCK, &icsbp->icsb_flags);
2123}
2124
David Chinner8d280b92006-03-14 13:13:09 +11002125
David Chinner7989cb82007-02-10 18:34:56 +11002126STATIC_INLINE void
David Chinner8d280b92006-03-14 13:13:09 +11002127xfs_icsb_lock_all_counters(
2128 xfs_mount_t *mp)
2129{
2130 xfs_icsb_cnts_t *cntp;
2131 int i;
2132
2133 for_each_online_cpu(i) {
2134 cntp = (xfs_icsb_cnts_t *)per_cpu_ptr(mp->m_sb_cnts, i);
David Chinner01e1b692006-03-14 13:29:16 +11002135 xfs_icsb_lock_cntr(cntp);
David Chinner8d280b92006-03-14 13:13:09 +11002136 }
2137}
2138
David Chinner7989cb82007-02-10 18:34:56 +11002139STATIC_INLINE void
David Chinner8d280b92006-03-14 13:13:09 +11002140xfs_icsb_unlock_all_counters(
2141 xfs_mount_t *mp)
2142{
2143 xfs_icsb_cnts_t *cntp;
2144 int i;
2145
2146 for_each_online_cpu(i) {
2147 cntp = (xfs_icsb_cnts_t *)per_cpu_ptr(mp->m_sb_cnts, i);
David Chinner01e1b692006-03-14 13:29:16 +11002148 xfs_icsb_unlock_cntr(cntp);
David Chinner8d280b92006-03-14 13:13:09 +11002149 }
2150}
2151
2152STATIC void
2153xfs_icsb_count(
2154 xfs_mount_t *mp,
2155 xfs_icsb_cnts_t *cnt,
2156 int flags)
2157{
2158 xfs_icsb_cnts_t *cntp;
2159 int i;
2160
2161 memset(cnt, 0, sizeof(xfs_icsb_cnts_t));
2162
2163 if (!(flags & XFS_ICSB_LAZY_COUNT))
2164 xfs_icsb_lock_all_counters(mp);
2165
2166 for_each_online_cpu(i) {
2167 cntp = (xfs_icsb_cnts_t *)per_cpu_ptr(mp->m_sb_cnts, i);
2168 cnt->icsb_icount += cntp->icsb_icount;
2169 cnt->icsb_ifree += cntp->icsb_ifree;
2170 cnt->icsb_fdblocks += cntp->icsb_fdblocks;
2171 }
2172
2173 if (!(flags & XFS_ICSB_LAZY_COUNT))
2174 xfs_icsb_unlock_all_counters(mp);
2175}
2176
2177STATIC int
2178xfs_icsb_counter_disabled(
2179 xfs_mount_t *mp,
2180 xfs_sb_field_t field)
2181{
2182 ASSERT((field >= XFS_SBS_ICOUNT) && (field <= XFS_SBS_FDBLOCKS));
2183 return test_bit(field, &mp->m_icsb_counters);
2184}
2185
David Chinner36fbe6e2008-04-10 12:19:56 +10002186STATIC void
David Chinner8d280b92006-03-14 13:13:09 +11002187xfs_icsb_disable_counter(
2188 xfs_mount_t *mp,
2189 xfs_sb_field_t field)
2190{
2191 xfs_icsb_cnts_t cnt;
2192
2193 ASSERT((field >= XFS_SBS_ICOUNT) && (field <= XFS_SBS_FDBLOCKS));
2194
David Chinner20b64282007-02-10 18:35:09 +11002195 /*
2196 * If we are already disabled, then there is nothing to do
2197 * here. We check before locking all the counters to avoid
2198 * the expensive lock operation when being called in the
2199 * slow path and the counter is already disabled. This is
2200 * safe because the only time we set or clear this state is under
2201 * the m_icsb_mutex.
2202 */
2203 if (xfs_icsb_counter_disabled(mp, field))
David Chinner36fbe6e2008-04-10 12:19:56 +10002204 return;
David Chinner20b64282007-02-10 18:35:09 +11002205
David Chinner8d280b92006-03-14 13:13:09 +11002206 xfs_icsb_lock_all_counters(mp);
2207 if (!test_and_set_bit(field, &mp->m_icsb_counters)) {
2208 /* drain back to superblock */
2209
2210 xfs_icsb_count(mp, &cnt, XFS_ICSB_SB_LOCKED|XFS_ICSB_LAZY_COUNT);
2211 switch(field) {
2212 case XFS_SBS_ICOUNT:
2213 mp->m_sb.sb_icount = cnt.icsb_icount;
2214 break;
2215 case XFS_SBS_IFREE:
2216 mp->m_sb.sb_ifree = cnt.icsb_ifree;
2217 break;
2218 case XFS_SBS_FDBLOCKS:
2219 mp->m_sb.sb_fdblocks = cnt.icsb_fdblocks;
2220 break;
2221 default:
2222 BUG();
2223 }
2224 }
2225
2226 xfs_icsb_unlock_all_counters(mp);
David Chinner8d280b92006-03-14 13:13:09 +11002227}
2228
2229STATIC void
2230xfs_icsb_enable_counter(
2231 xfs_mount_t *mp,
2232 xfs_sb_field_t field,
2233 uint64_t count,
2234 uint64_t resid)
2235{
2236 xfs_icsb_cnts_t *cntp;
2237 int i;
2238
2239 ASSERT((field >= XFS_SBS_ICOUNT) && (field <= XFS_SBS_FDBLOCKS));
2240
2241 xfs_icsb_lock_all_counters(mp);
2242 for_each_online_cpu(i) {
2243 cntp = per_cpu_ptr(mp->m_sb_cnts, i);
2244 switch (field) {
2245 case XFS_SBS_ICOUNT:
2246 cntp->icsb_icount = count + resid;
2247 break;
2248 case XFS_SBS_IFREE:
2249 cntp->icsb_ifree = count + resid;
2250 break;
2251 case XFS_SBS_FDBLOCKS:
2252 cntp->icsb_fdblocks = count + resid;
2253 break;
2254 default:
2255 BUG();
2256 break;
2257 }
2258 resid = 0;
2259 }
2260 clear_bit(field, &mp->m_icsb_counters);
2261 xfs_icsb_unlock_all_counters(mp);
2262}
2263
David Chinnerdbcabad2007-02-10 18:36:17 +11002264void
2265xfs_icsb_sync_counters_flags(
David Chinner8d280b92006-03-14 13:13:09 +11002266 xfs_mount_t *mp,
2267 int flags)
2268{
2269 xfs_icsb_cnts_t cnt;
David Chinner8d280b92006-03-14 13:13:09 +11002270
2271 /* Pass 1: lock all counters */
2272 if ((flags & XFS_ICSB_SB_LOCKED) == 0)
Eric Sandeen3685c2a2007-10-11 17:42:32 +10002273 spin_lock(&mp->m_sb_lock);
David Chinner8d280b92006-03-14 13:13:09 +11002274
2275 xfs_icsb_count(mp, &cnt, flags);
2276
2277 /* Step 3: update mp->m_sb fields */
2278 if (!xfs_icsb_counter_disabled(mp, XFS_SBS_ICOUNT))
2279 mp->m_sb.sb_icount = cnt.icsb_icount;
2280 if (!xfs_icsb_counter_disabled(mp, XFS_SBS_IFREE))
2281 mp->m_sb.sb_ifree = cnt.icsb_ifree;
2282 if (!xfs_icsb_counter_disabled(mp, XFS_SBS_FDBLOCKS))
2283 mp->m_sb.sb_fdblocks = cnt.icsb_fdblocks;
2284
2285 if ((flags & XFS_ICSB_SB_LOCKED) == 0)
Eric Sandeen3685c2a2007-10-11 17:42:32 +10002286 spin_unlock(&mp->m_sb_lock);
David Chinner8d280b92006-03-14 13:13:09 +11002287}
2288
2289/*
2290 * Accurate update of per-cpu counters to incore superblock
2291 */
2292STATIC void
2293xfs_icsb_sync_counters(
2294 xfs_mount_t *mp)
2295{
David Chinnerdbcabad2007-02-10 18:36:17 +11002296 xfs_icsb_sync_counters_flags(mp, 0);
David Chinner8d280b92006-03-14 13:13:09 +11002297}
2298
2299/*
2300 * Balance and enable/disable counters as necessary.
2301 *
David Chinner20b64282007-02-10 18:35:09 +11002302 * Thresholds for re-enabling counters are somewhat magic. inode counts are
2303 * chosen to be the same number as single on disk allocation chunk per CPU, and
2304 * free blocks is something far enough zero that we aren't going thrash when we
2305 * get near ENOSPC. We also need to supply a minimum we require per cpu to
2306 * prevent looping endlessly when xfs_alloc_space asks for more than will
2307 * be distributed to a single CPU but each CPU has enough blocks to be
2308 * reenabled.
2309 *
2310 * Note that we can be called when counters are already disabled.
2311 * xfs_icsb_disable_counter() optimises the counter locking in this case to
2312 * prevent locking every per-cpu counter needlessly.
David Chinner8d280b92006-03-14 13:13:09 +11002313 */
David Chinner20b64282007-02-10 18:35:09 +11002314
2315#define XFS_ICSB_INO_CNTR_REENABLE (uint64_t)64
David Chinner4be536d2006-09-07 14:26:50 +10002316#define XFS_ICSB_FDBLK_CNTR_REENABLE(mp) \
David Chinner20b64282007-02-10 18:35:09 +11002317 (uint64_t)(512 + XFS_ALLOC_SET_ASIDE(mp))
David Chinner8d280b92006-03-14 13:13:09 +11002318STATIC void
2319xfs_icsb_balance_counter(
2320 xfs_mount_t *mp,
2321 xfs_sb_field_t field,
David Chinner20b64282007-02-10 18:35:09 +11002322 int flags,
2323 int min_per_cpu)
David Chinner8d280b92006-03-14 13:13:09 +11002324{
Nathan Scott6fdf8cc2006-06-28 10:13:52 +10002325 uint64_t count, resid;
David Chinner8d280b92006-03-14 13:13:09 +11002326 int weight = num_online_cpus();
David Chinner20b64282007-02-10 18:35:09 +11002327 uint64_t min = (uint64_t)min_per_cpu;
David Chinner8d280b92006-03-14 13:13:09 +11002328
2329 if (!(flags & XFS_ICSB_SB_LOCKED))
Eric Sandeen3685c2a2007-10-11 17:42:32 +10002330 spin_lock(&mp->m_sb_lock);
David Chinner8d280b92006-03-14 13:13:09 +11002331
2332 /* disable counter and sync counter */
2333 xfs_icsb_disable_counter(mp, field);
2334
2335 /* update counters - first CPU gets residual*/
2336 switch (field) {
2337 case XFS_SBS_ICOUNT:
2338 count = mp->m_sb.sb_icount;
2339 resid = do_div(count, weight);
David Chinner20b64282007-02-10 18:35:09 +11002340 if (count < max(min, XFS_ICSB_INO_CNTR_REENABLE))
David Chinner8d280b92006-03-14 13:13:09 +11002341 goto out;
2342 break;
2343 case XFS_SBS_IFREE:
2344 count = mp->m_sb.sb_ifree;
2345 resid = do_div(count, weight);
David Chinner20b64282007-02-10 18:35:09 +11002346 if (count < max(min, XFS_ICSB_INO_CNTR_REENABLE))
David Chinner8d280b92006-03-14 13:13:09 +11002347 goto out;
2348 break;
2349 case XFS_SBS_FDBLOCKS:
2350 count = mp->m_sb.sb_fdblocks;
2351 resid = do_div(count, weight);
David Chinner20b64282007-02-10 18:35:09 +11002352 if (count < max(min, XFS_ICSB_FDBLK_CNTR_REENABLE(mp)))
David Chinner8d280b92006-03-14 13:13:09 +11002353 goto out;
2354 break;
2355 default:
2356 BUG();
Nathan Scott6fdf8cc2006-06-28 10:13:52 +10002357 count = resid = 0; /* quiet, gcc */
David Chinner8d280b92006-03-14 13:13:09 +11002358 break;
2359 }
2360
2361 xfs_icsb_enable_counter(mp, field, count, resid);
2362out:
2363 if (!(flags & XFS_ICSB_SB_LOCKED))
Eric Sandeen3685c2a2007-10-11 17:42:32 +10002364 spin_unlock(&mp->m_sb_lock);
David Chinner8d280b92006-03-14 13:13:09 +11002365}
2366
David Chinnera8272ce2007-11-23 16:28:09 +11002367STATIC int
David Chinner20b64282007-02-10 18:35:09 +11002368xfs_icsb_modify_counters(
David Chinner8d280b92006-03-14 13:13:09 +11002369 xfs_mount_t *mp,
2370 xfs_sb_field_t field,
David Chinner20f4ebf2007-02-10 18:36:10 +11002371 int64_t delta,
David Chinner20b64282007-02-10 18:35:09 +11002372 int rsvd)
David Chinner8d280b92006-03-14 13:13:09 +11002373{
2374 xfs_icsb_cnts_t *icsbp;
2375 long long lcounter; /* long counter for 64 bit fields */
Eric Sandeen007c61c2007-10-11 17:43:56 +10002376 int cpu, ret = 0;
David Chinner8d280b92006-03-14 13:13:09 +11002377
David Chinner20b64282007-02-10 18:35:09 +11002378 might_sleep();
David Chinner8d280b92006-03-14 13:13:09 +11002379again:
2380 cpu = get_cpu();
David Chinner20b64282007-02-10 18:35:09 +11002381 icsbp = (xfs_icsb_cnts_t *)per_cpu_ptr(mp->m_sb_cnts, cpu);
2382
2383 /*
2384 * if the counter is disabled, go to slow path
2385 */
David Chinner8d280b92006-03-14 13:13:09 +11002386 if (unlikely(xfs_icsb_counter_disabled(mp, field)))
2387 goto slow_path;
David Chinner20b64282007-02-10 18:35:09 +11002388 xfs_icsb_lock_cntr(icsbp);
2389 if (unlikely(xfs_icsb_counter_disabled(mp, field))) {
2390 xfs_icsb_unlock_cntr(icsbp);
2391 goto slow_path;
2392 }
David Chinner8d280b92006-03-14 13:13:09 +11002393
2394 switch (field) {
2395 case XFS_SBS_ICOUNT:
2396 lcounter = icsbp->icsb_icount;
2397 lcounter += delta;
2398 if (unlikely(lcounter < 0))
David Chinner20b64282007-02-10 18:35:09 +11002399 goto balance_counter;
David Chinner8d280b92006-03-14 13:13:09 +11002400 icsbp->icsb_icount = lcounter;
2401 break;
2402
2403 case XFS_SBS_IFREE:
2404 lcounter = icsbp->icsb_ifree;
2405 lcounter += delta;
2406 if (unlikely(lcounter < 0))
David Chinner20b64282007-02-10 18:35:09 +11002407 goto balance_counter;
David Chinner8d280b92006-03-14 13:13:09 +11002408 icsbp->icsb_ifree = lcounter;
2409 break;
2410
2411 case XFS_SBS_FDBLOCKS:
2412 BUG_ON((mp->m_resblks - mp->m_resblks_avail) != 0);
2413
David Chinner4be536d2006-09-07 14:26:50 +10002414 lcounter = icsbp->icsb_fdblocks - XFS_ALLOC_SET_ASIDE(mp);
David Chinner8d280b92006-03-14 13:13:09 +11002415 lcounter += delta;
2416 if (unlikely(lcounter < 0))
David Chinner20b64282007-02-10 18:35:09 +11002417 goto balance_counter;
David Chinner4be536d2006-09-07 14:26:50 +10002418 icsbp->icsb_fdblocks = lcounter + XFS_ALLOC_SET_ASIDE(mp);
David Chinner8d280b92006-03-14 13:13:09 +11002419 break;
2420 default:
2421 BUG();
2422 break;
2423 }
David Chinner01e1b692006-03-14 13:29:16 +11002424 xfs_icsb_unlock_cntr(icsbp);
David Chinner8d280b92006-03-14 13:13:09 +11002425 put_cpu();
David Chinner8d280b92006-03-14 13:13:09 +11002426 return 0;
2427
David Chinner8d280b92006-03-14 13:13:09 +11002428slow_path:
David Chinner20b64282007-02-10 18:35:09 +11002429 put_cpu();
2430
2431 /*
2432 * serialise with a mutex so we don't burn lots of cpu on
2433 * the superblock lock. We still need to hold the superblock
2434 * lock, however, when we modify the global structures.
2435 */
David Chinner03135cf2007-02-10 18:35:15 +11002436 xfs_icsb_lock(mp);
David Chinner20b64282007-02-10 18:35:09 +11002437
2438 /*
2439 * Now running atomically.
2440 *
2441 * If the counter is enabled, someone has beaten us to rebalancing.
2442 * Drop the lock and try again in the fast path....
2443 */
2444 if (!(xfs_icsb_counter_disabled(mp, field))) {
David Chinner03135cf2007-02-10 18:35:15 +11002445 xfs_icsb_unlock(mp);
David Chinner20b64282007-02-10 18:35:09 +11002446 goto again;
2447 }
2448
2449 /*
2450 * The counter is currently disabled. Because we are
2451 * running atomically here, we know a rebalance cannot
2452 * be in progress. Hence we can go straight to operating
2453 * on the global superblock. We do not call xfs_mod_incore_sb()
Eric Sandeen3685c2a2007-10-11 17:42:32 +10002454 * here even though we need to get the m_sb_lock. Doing so
David Chinner20b64282007-02-10 18:35:09 +11002455 * will cause us to re-enter this function and deadlock.
Eric Sandeen3685c2a2007-10-11 17:42:32 +10002456 * Hence we get the m_sb_lock ourselves and then call
David Chinner20b64282007-02-10 18:35:09 +11002457 * xfs_mod_incore_sb_unlocked() as the unlocked path operates
2458 * directly on the global counters.
2459 */
Eric Sandeen3685c2a2007-10-11 17:42:32 +10002460 spin_lock(&mp->m_sb_lock);
David Chinner20b64282007-02-10 18:35:09 +11002461 ret = xfs_mod_incore_sb_unlocked(mp, field, delta, rsvd);
Eric Sandeen3685c2a2007-10-11 17:42:32 +10002462 spin_unlock(&mp->m_sb_lock);
David Chinner20b64282007-02-10 18:35:09 +11002463
2464 /*
2465 * Now that we've modified the global superblock, we
2466 * may be able to re-enable the distributed counters
2467 * (e.g. lots of space just got freed). After that
2468 * we are done.
2469 */
2470 if (ret != ENOSPC)
2471 xfs_icsb_balance_counter(mp, field, 0, 0);
David Chinner03135cf2007-02-10 18:35:15 +11002472 xfs_icsb_unlock(mp);
David Chinner20b64282007-02-10 18:35:09 +11002473 return ret;
2474
2475balance_counter:
David Chinner01e1b692006-03-14 13:29:16 +11002476 xfs_icsb_unlock_cntr(icsbp);
David Chinner8d280b92006-03-14 13:13:09 +11002477 put_cpu();
2478
David Chinner20b64282007-02-10 18:35:09 +11002479 /*
2480 * We may have multiple threads here if multiple per-cpu
2481 * counters run dry at the same time. This will mean we can
2482 * do more balances than strictly necessary but it is not
2483 * the common slowpath case.
2484 */
David Chinner03135cf2007-02-10 18:35:15 +11002485 xfs_icsb_lock(mp);
David Chinner8d280b92006-03-14 13:13:09 +11002486
David Chinner20b64282007-02-10 18:35:09 +11002487 /*
2488 * running atomically.
2489 *
2490 * This will leave the counter in the correct state for future
2491 * accesses. After the rebalance, we simply try again and our retry
2492 * will either succeed through the fast path or slow path without
2493 * another balance operation being required.
2494 */
2495 xfs_icsb_balance_counter(mp, field, 0, delta);
David Chinner03135cf2007-02-10 18:35:15 +11002496 xfs_icsb_unlock(mp);
David Chinner20b64282007-02-10 18:35:09 +11002497 goto again;
David Chinner8d280b92006-03-14 13:13:09 +11002498}
2499
David Chinner8d280b92006-03-14 13:13:09 +11002500#endif