xfs_fsops.c 21.1 KB
Newer Older
L
Linus Torvalds 已提交
1
/*
2 3
 * Copyright (c) 2000-2005 Silicon Graphics, Inc.
 * All Rights Reserved.
L
Linus Torvalds 已提交
4
 *
5 6
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
L
Linus Torvalds 已提交
7 8
 * published by the Free Software Foundation.
 *
9 10 11 12
 * This program is distributed in the hope that it would be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
L
Linus Torvalds 已提交
13
 *
14 15 16
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write the Free Software Foundation,
 * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
L
Linus Torvalds 已提交
17 18
 */
#include "xfs.h"
19
#include "xfs_fs.h"
L
Linus Torvalds 已提交
20 21 22 23
#include "xfs_types.h"
#include "xfs_log.h"
#include "xfs_trans.h"
#include "xfs_sb.h"
24
#include "xfs_ag.h"
L
Linus Torvalds 已提交
25 26
#include "xfs_mount.h"
#include "xfs_bmap_btree.h"
27
#include "xfs_alloc_btree.h"
L
Linus Torvalds 已提交
28
#include "xfs_ialloc_btree.h"
29 30 31
#include "xfs_dinode.h"
#include "xfs_inode.h"
#include "xfs_inode_item.h"
L
Linus Torvalds 已提交
32 33 34 35 36 37 38 39
#include "xfs_btree.h"
#include "xfs_error.h"
#include "xfs_alloc.h"
#include "xfs_ialloc.h"
#include "xfs_fsops.h"
#include "xfs_itable.h"
#include "xfs_trans_space.h"
#include "xfs_rtalloc.h"
40
#include "xfs_filestream.h"
C
Christoph Hellwig 已提交
41
#include "xfs_trace.h"
L
Linus Torvalds 已提交
42 43 44 45 46 47 48 49 50 51 52

/*
 * File system operations
 */

int
xfs_fs_geometry(
	xfs_mount_t		*mp,
	xfs_fsop_geom_t		*geo,
	int			new_version)
{
53 54 55

	memset(geo, 0, sizeof(*geo));

L
Linus Torvalds 已提交
56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76
	geo->blocksize = mp->m_sb.sb_blocksize;
	geo->rtextsize = mp->m_sb.sb_rextsize;
	geo->agblocks = mp->m_sb.sb_agblocks;
	geo->agcount = mp->m_sb.sb_agcount;
	geo->logblocks = mp->m_sb.sb_logblocks;
	geo->sectsize = mp->m_sb.sb_sectsize;
	geo->inodesize = mp->m_sb.sb_inodesize;
	geo->imaxpct = mp->m_sb.sb_imax_pct;
	geo->datablocks = mp->m_sb.sb_dblocks;
	geo->rtblocks = mp->m_sb.sb_rblocks;
	geo->rtextents = mp->m_sb.sb_rextents;
	geo->logstart = mp->m_sb.sb_logstart;
	ASSERT(sizeof(geo->uuid)==sizeof(mp->m_sb.sb_uuid));
	memcpy(geo->uuid, &mp->m_sb.sb_uuid, sizeof(mp->m_sb.sb_uuid));
	if (new_version >= 2) {
		geo->sunit = mp->m_sb.sb_unit;
		geo->swidth = mp->m_sb.sb_width;
	}
	if (new_version >= 3) {
		geo->version = XFS_FSOP_GEOM_VERSION;
		geo->flags =
77
			(xfs_sb_version_hasattr(&mp->m_sb) ?
L
Linus Torvalds 已提交
78
				XFS_FSOP_GEOM_FLAGS_ATTR : 0) |
79
			(xfs_sb_version_hasnlink(&mp->m_sb) ?
L
Linus Torvalds 已提交
80
				XFS_FSOP_GEOM_FLAGS_NLINK : 0) |
81
			(xfs_sb_version_hasquota(&mp->m_sb) ?
L
Linus Torvalds 已提交
82
				XFS_FSOP_GEOM_FLAGS_QUOTA : 0) |
83
			(xfs_sb_version_hasalign(&mp->m_sb) ?
L
Linus Torvalds 已提交
84
				XFS_FSOP_GEOM_FLAGS_IALIGN : 0) |
85
			(xfs_sb_version_hasdalign(&mp->m_sb) ?
L
Linus Torvalds 已提交
86
				XFS_FSOP_GEOM_FLAGS_DALIGN : 0) |
87
			(xfs_sb_version_hasshared(&mp->m_sb) ?
L
Linus Torvalds 已提交
88
				XFS_FSOP_GEOM_FLAGS_SHARED : 0) |
89
			(xfs_sb_version_hasextflgbit(&mp->m_sb) ?
L
Linus Torvalds 已提交
90
				XFS_FSOP_GEOM_FLAGS_EXTFLG : 0) |
91
			(xfs_sb_version_hasdirv2(&mp->m_sb) ?
L
Linus Torvalds 已提交
92
				XFS_FSOP_GEOM_FLAGS_DIRV2 : 0) |
93
			(xfs_sb_version_hassector(&mp->m_sb) ?
94
				XFS_FSOP_GEOM_FLAGS_SECTOR : 0) |
95 96
			(xfs_sb_version_hasasciici(&mp->m_sb) ?
				XFS_FSOP_GEOM_FLAGS_DIRV2CI : 0) |
D
David Chinner 已提交
97 98
			(xfs_sb_version_haslazysbcount(&mp->m_sb) ?
				XFS_FSOP_GEOM_FLAGS_LAZYSB : 0) |
99
			(xfs_sb_version_hasattr2(&mp->m_sb) ?
100 101 102
				XFS_FSOP_GEOM_FLAGS_ATTR2 : 0) |
			(xfs_sb_version_hasprojid32bit(&mp->m_sb) ?
				XFS_FSOP_GEOM_FLAGS_PROJID32 : 0);
103
		geo->logsectsize = xfs_sb_version_hassector(&mp->m_sb) ?
L
Linus Torvalds 已提交
104 105 106 107 108 109
				mp->m_sb.sb_logsectsize : BBSIZE;
		geo->rtsectsize = mp->m_sb.sb_blocksize;
		geo->dirblocksize = mp->m_dirblksize;
	}
	if (new_version >= 4) {
		geo->flags |=
110
			(xfs_sb_version_haslogv2(&mp->m_sb) ?
L
Linus Torvalds 已提交
111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127
				XFS_FSOP_GEOM_FLAGS_LOGV2 : 0);
		geo->logsunit = mp->m_sb.sb_logsunit;
	}
	return 0;
}

static int
xfs_growfs_data_private(
	xfs_mount_t		*mp,		/* mount point for filesystem */
	xfs_growfs_data_t	*in)		/* growfs data input struct */
{
	xfs_agf_t		*agf;
	xfs_agi_t		*agi;
	xfs_agnumber_t		agno;
	xfs_extlen_t		agsize;
	xfs_extlen_t		tmpsize;
	xfs_alloc_rec_t		*arec;
128
	struct xfs_btree_block	*block;
L
Linus Torvalds 已提交
129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145
	xfs_buf_t		*bp;
	int			bucket;
	int			dpct;
	int			error;
	xfs_agnumber_t		nagcount;
	xfs_agnumber_t		nagimax = 0;
	xfs_rfsblock_t		nb, nb_mod;
	xfs_rfsblock_t		new;
	xfs_rfsblock_t		nfree;
	xfs_agnumber_t		oagcount;
	int			pct;
	xfs_trans_t		*tp;

	nb = in->newblocks;
	pct = in->imaxpct;
	if (nb < mp->m_sb.sb_dblocks || pct < 0 || pct > 100)
		return XFS_ERROR(EINVAL);
146 147
	if ((error = xfs_sb_validate_fsb_count(&mp->m_sb, nb)))
		return error;
L
Linus Torvalds 已提交
148
	dpct = pct - mp->m_sb.sb_imax_pct;
149
	bp = xfs_buf_read_uncached(mp->m_ddev_targp,
150
				XFS_FSB_TO_BB(mp, nb) - XFS_FSS_TO_BB(mp, 1),
151
				XFS_FSS_TO_BB(mp, 1), 0);
152 153
	if (!bp)
		return EIO;
L
Linus Torvalds 已提交
154 155 156 157 158 159 160
	xfs_buf_relse(bp);

	new = nb;	/* use new as a temporary here */
	nb_mod = do_div(new, mp->m_sb.sb_agblocks);
	nagcount = new + (nb_mod != 0);
	if (nb_mod && nb_mod < XFS_MIN_AG_BLOCKS) {
		nagcount--;
161
		nb = (xfs_rfsblock_t)nagcount * mp->m_sb.sb_agblocks;
L
Linus Torvalds 已提交
162 163 164 165 166
		if (nb < mp->m_sb.sb_dblocks)
			return XFS_ERROR(EINVAL);
	}
	new = nb - mp->m_sb.sb_dblocks;
	oagcount = mp->m_sb.sb_agcount;
167

168 169 170 171 172
	/* allocate the new per-ag structures */
	if (nagcount > oagcount) {
		error = xfs_initialize_perag(mp, nagcount, &nagimax);
		if (error)
			return error;
L
Linus Torvalds 已提交
173
	}
174

L
Linus Torvalds 已提交
175
	tp = xfs_trans_alloc(mp, XFS_TRANS_GROWFS);
176
	tp->t_flags |= XFS_TRANS_RESERVE;
L
Linus Torvalds 已提交
177 178 179 180 181 182
	if ((error = xfs_trans_reserve(tp, XFS_GROWFS_SPACE_RES(mp),
			XFS_GROWDATA_LOG_RES(mp), 0, 0, 0))) {
		xfs_trans_cancel(tp, 0);
		return error;
	}

183 184 185 186 187
	/*
	 * Write new AG headers to disk. Non-transactional, but written
	 * synchronously so they are completed prior to the growfs transaction
	 * being logged.
	 */
L
Linus Torvalds 已提交
188 189 190 191 192 193
	nfree = 0;
	for (agno = nagcount - 1; agno >= oagcount; agno--, new -= agsize) {
		/*
		 * AG freelist header block
		 */
		bp = xfs_buf_get(mp->m_ddev_targp,
194
				 XFS_AG_DADDR(mp, agno, XFS_AGF_DADDR(mp)),
195
				 XFS_FSS_TO_BB(mp, 1), 0);
196 197 198 199
		if (!bp) {
			error = ENOMEM;
			goto error0;
		}
L
Linus Torvalds 已提交
200 201
		agf = XFS_BUF_TO_AGF(bp);
		memset(agf, 0, mp->m_sb.sb_sectsize);
202 203 204
		agf->agf_magicnum = cpu_to_be32(XFS_AGF_MAGIC);
		agf->agf_versionnum = cpu_to_be32(XFS_AGF_VERSION);
		agf->agf_seqno = cpu_to_be32(agno);
L
Linus Torvalds 已提交
205 206 207 208 209 210
		if (agno == nagcount - 1)
			agsize =
				nb -
				(agno * (xfs_rfsblock_t)mp->m_sb.sb_agblocks);
		else
			agsize = mp->m_sb.sb_agblocks;
211 212 213 214 215
		agf->agf_length = cpu_to_be32(agsize);
		agf->agf_roots[XFS_BTNUM_BNOi] = cpu_to_be32(XFS_BNO_BLOCK(mp));
		agf->agf_roots[XFS_BTNUM_CNTi] = cpu_to_be32(XFS_CNT_BLOCK(mp));
		agf->agf_levels[XFS_BTNUM_BNOi] = cpu_to_be32(1);
		agf->agf_levels[XFS_BTNUM_CNTi] = cpu_to_be32(1);
L
Linus Torvalds 已提交
216
		agf->agf_flfirst = 0;
217
		agf->agf_fllast = cpu_to_be32(XFS_AGFL_SIZE(mp) - 1);
L
Linus Torvalds 已提交
218 219
		agf->agf_flcount = 0;
		tmpsize = agsize - XFS_PREALLOC_BLOCKS(mp);
220 221
		agf->agf_freeblks = cpu_to_be32(tmpsize);
		agf->agf_longest = cpu_to_be32(tmpsize);
222 223 224
		error = xfs_bwrite(bp);
		xfs_buf_relse(bp);
		if (error)
L
Linus Torvalds 已提交
225
			goto error0;
226

L
Linus Torvalds 已提交
227 228 229 230
		/*
		 * AG inode header block
		 */
		bp = xfs_buf_get(mp->m_ddev_targp,
231
				 XFS_AG_DADDR(mp, agno, XFS_AGI_DADDR(mp)),
232
				 XFS_FSS_TO_BB(mp, 1), 0);
233 234 235 236
		if (!bp) {
			error = ENOMEM;
			goto error0;
		}
L
Linus Torvalds 已提交
237 238
		agi = XFS_BUF_TO_AGI(bp);
		memset(agi, 0, mp->m_sb.sb_sectsize);
239 240 241 242
		agi->agi_magicnum = cpu_to_be32(XFS_AGI_MAGIC);
		agi->agi_versionnum = cpu_to_be32(XFS_AGI_VERSION);
		agi->agi_seqno = cpu_to_be32(agno);
		agi->agi_length = cpu_to_be32(agsize);
L
Linus Torvalds 已提交
243
		agi->agi_count = 0;
244 245
		agi->agi_root = cpu_to_be32(XFS_IBT_BLOCK(mp));
		agi->agi_level = cpu_to_be32(1);
L
Linus Torvalds 已提交
246
		agi->agi_freecount = 0;
247 248
		agi->agi_newino = cpu_to_be32(NULLAGINO);
		agi->agi_dirino = cpu_to_be32(NULLAGINO);
L
Linus Torvalds 已提交
249
		for (bucket = 0; bucket < XFS_AGI_UNLINKED_BUCKETS; bucket++)
250
			agi->agi_unlinked[bucket] = cpu_to_be32(NULLAGINO);
251 252 253
		error = xfs_bwrite(bp);
		xfs_buf_relse(bp);
		if (error)
L
Linus Torvalds 已提交
254
			goto error0;
255

L
Linus Torvalds 已提交
256 257 258 259
		/*
		 * BNO btree root block
		 */
		bp = xfs_buf_get(mp->m_ddev_targp,
260
				 XFS_AGB_TO_DADDR(mp, agno, XFS_BNO_BLOCK(mp)),
261
				 BTOBB(mp->m_sb.sb_blocksize), 0);
262 263 264 265
		if (!bp) {
			error = ENOMEM;
			goto error0;
		}
266
		block = XFS_BUF_TO_BLOCK(bp);
L
Linus Torvalds 已提交
267
		memset(block, 0, mp->m_sb.sb_blocksize);
268
		block->bb_magic = cpu_to_be32(XFS_ABTB_MAGIC);
L
Linus Torvalds 已提交
269
		block->bb_level = 0;
270
		block->bb_numrecs = cpu_to_be16(1);
271 272
		block->bb_u.s.bb_leftsib = cpu_to_be32(NULLAGBLOCK);
		block->bb_u.s.bb_rightsib = cpu_to_be32(NULLAGBLOCK);
273
		arec = XFS_ALLOC_REC_ADDR(mp, block, 1);
274 275 276
		arec->ar_startblock = cpu_to_be32(XFS_PREALLOC_BLOCKS(mp));
		arec->ar_blockcount = cpu_to_be32(
			agsize - be32_to_cpu(arec->ar_startblock));
277 278 279
		error = xfs_bwrite(bp);
		xfs_buf_relse(bp);
		if (error)
L
Linus Torvalds 已提交
280
			goto error0;
281

L
Linus Torvalds 已提交
282 283 284 285
		/*
		 * CNT btree root block
		 */
		bp = xfs_buf_get(mp->m_ddev_targp,
286
				 XFS_AGB_TO_DADDR(mp, agno, XFS_CNT_BLOCK(mp)),
287
				 BTOBB(mp->m_sb.sb_blocksize), 0);
288 289 290 291
		if (!bp) {
			error = ENOMEM;
			goto error0;
		}
292
		block = XFS_BUF_TO_BLOCK(bp);
L
Linus Torvalds 已提交
293
		memset(block, 0, mp->m_sb.sb_blocksize);
294
		block->bb_magic = cpu_to_be32(XFS_ABTC_MAGIC);
L
Linus Torvalds 已提交
295
		block->bb_level = 0;
296
		block->bb_numrecs = cpu_to_be16(1);
297 298
		block->bb_u.s.bb_leftsib = cpu_to_be32(NULLAGBLOCK);
		block->bb_u.s.bb_rightsib = cpu_to_be32(NULLAGBLOCK);
299
		arec = XFS_ALLOC_REC_ADDR(mp, block, 1);
300 301 302 303
		arec->ar_startblock = cpu_to_be32(XFS_PREALLOC_BLOCKS(mp));
		arec->ar_blockcount = cpu_to_be32(
			agsize - be32_to_cpu(arec->ar_startblock));
		nfree += be32_to_cpu(arec->ar_blockcount);
304 305 306
		error = xfs_bwrite(bp);
		xfs_buf_relse(bp);
		if (error)
L
Linus Torvalds 已提交
307
			goto error0;
308

L
Linus Torvalds 已提交
309 310 311 312
		/*
		 * INO btree root block
		 */
		bp = xfs_buf_get(mp->m_ddev_targp,
313
				 XFS_AGB_TO_DADDR(mp, agno, XFS_IBT_BLOCK(mp)),
314
				 BTOBB(mp->m_sb.sb_blocksize), 0);
315 316 317 318
		if (!bp) {
			error = ENOMEM;
			goto error0;
		}
319
		block = XFS_BUF_TO_BLOCK(bp);
L
Linus Torvalds 已提交
320
		memset(block, 0, mp->m_sb.sb_blocksize);
321
		block->bb_magic = cpu_to_be32(XFS_IBT_MAGIC);
L
Linus Torvalds 已提交
322 323
		block->bb_level = 0;
		block->bb_numrecs = 0;
324 325
		block->bb_u.s.bb_leftsib = cpu_to_be32(NULLAGBLOCK);
		block->bb_u.s.bb_rightsib = cpu_to_be32(NULLAGBLOCK);
326 327 328
		error = xfs_bwrite(bp);
		xfs_buf_relse(bp);
		if (error)
L
Linus Torvalds 已提交
329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344
			goto error0;
	}
	xfs_trans_agblocks_delta(tp, nfree);
	/*
	 * There are new blocks in the old last a.g.
	 */
	if (new) {
		/*
		 * Change the agi length.
		 */
		error = xfs_ialloc_read_agi(mp, tp, agno, &bp);
		if (error) {
			goto error0;
		}
		ASSERT(bp);
		agi = XFS_BUF_TO_AGI(bp);
345
		be32_add_cpu(&agi->agi_length, new);
L
Linus Torvalds 已提交
346
		ASSERT(nagcount == oagcount ||
347
		       be32_to_cpu(agi->agi_length) == mp->m_sb.sb_agblocks);
L
Linus Torvalds 已提交
348 349 350 351 352 353 354 355 356 357
		xfs_ialloc_log_agi(tp, bp, XFS_AGI_LENGTH);
		/*
		 * Change agf length.
		 */
		error = xfs_alloc_read_agf(mp, tp, agno, 0, &bp);
		if (error) {
			goto error0;
		}
		ASSERT(bp);
		agf = XFS_BUF_TO_AGF(bp);
358
		be32_add_cpu(&agf->agf_length, new);
359 360
		ASSERT(be32_to_cpu(agf->agf_length) ==
		       be32_to_cpu(agi->agi_length));
C
Christoph Hellwig 已提交
361

362
		xfs_alloc_log_agf(tp, bp, XFS_AGF_LENGTH);
L
Linus Torvalds 已提交
363 364 365 366
		/*
		 * Free the new space.
		 */
		error = xfs_free_extent(tp, XFS_AGB_TO_FSB(mp, agno,
367
			be32_to_cpu(agf->agf_length) - new), new);
L
Linus Torvalds 已提交
368 369 370 371
		if (error) {
			goto error0;
		}
	}
372 373 374 375 376 377

	/*
	 * Update changed superblock fields transactionally. These are not
	 * seen by the rest of the world until the transaction commit applies
	 * them atomically to the superblock.
	 */
L
Linus Torvalds 已提交
378 379 380 381 382 383 384 385 386
	if (nagcount > oagcount)
		xfs_trans_mod_sb(tp, XFS_TRANS_SB_AGCOUNT, nagcount - oagcount);
	if (nb > mp->m_sb.sb_dblocks)
		xfs_trans_mod_sb(tp, XFS_TRANS_SB_DBLOCKS,
				 nb - mp->m_sb.sb_dblocks);
	if (nfree)
		xfs_trans_mod_sb(tp, XFS_TRANS_SB_FDBLOCKS, nfree);
	if (dpct)
		xfs_trans_mod_sb(tp, XFS_TRANS_SB_IMAXPCT, dpct);
387
	error = xfs_trans_commit(tp, 0);
388
	if (error)
L
Linus Torvalds 已提交
389
		return error;
390

L
Linus Torvalds 已提交
391 392 393 394 395 396 397 398 399
	/* New allocation groups fully initialized, so update mount struct */
	if (nagimax)
		mp->m_maxagi = nagimax;
	if (mp->m_sb.sb_imax_pct) {
		__uint64_t icount = mp->m_sb.sb_dblocks * mp->m_sb.sb_imax_pct;
		do_div(icount, 100);
		mp->m_maxicount = icount << mp->m_sb.sb_inopblog;
	} else
		mp->m_maxicount = 0;
400
	xfs_set_low_space_thresholds(mp);
401 402

	/* update secondary superblocks. */
L
Linus Torvalds 已提交
403
	for (agno = 1; agno < nagcount; agno++) {
404 405 406 407 408 409 410 411
		error = 0;
		/*
		 * new secondary superblocks need to be zeroed, not read from
		 * disk as the contents of the new area we are growing into is
		 * completely unknown.
		 */
		if (agno < oagcount) {
			error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp,
L
Linus Torvalds 已提交
412 413
				  XFS_AGB_TO_DADDR(mp, agno, XFS_SB_BLOCK(mp)),
				  XFS_FSS_TO_BB(mp, 1), 0, &bp);
414 415 416 417 418 419 420 421 422 423
		} else {
			bp = xfs_trans_get_buf(NULL, mp->m_ddev_targp,
				  XFS_AGB_TO_DADDR(mp, agno, XFS_SB_BLOCK(mp)),
				  XFS_FSS_TO_BB(mp, 1), 0);
			if (bp)
				xfs_buf_zero(bp, 0, BBTOB(bp->b_length));
			else
				error = ENOMEM;
		}

L
Linus Torvalds 已提交
424
		if (error) {
425 426
			xfs_warn(mp,
		"error %d reading secondary superblock for ag %d",
L
Linus Torvalds 已提交
427 428 429
				error, agno);
			break;
		}
430
		xfs_sb_to_disk(XFS_BUF_TO_SBP(bp), &mp->m_sb, XFS_SB_ALL_BITS);
L
Linus Torvalds 已提交
431 432 433 434 435
		/*
		 * If we get an error writing out the alternate superblocks,
		 * just issue a warning and continue.  The real work is
		 * already done and committed.
		 */
436 437 438
		error = xfs_bwrite(bp);
		xfs_buf_relse(bp);
		if (error) {
439
			xfs_warn(mp,
L
Linus Torvalds 已提交
440 441 442 443 444
		"write error %d updating secondary superblock for ag %d",
				error, agno);
			break; /* no point in continuing */
		}
	}
445
	return error;
L
Linus Torvalds 已提交
446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486

 error0:
	xfs_trans_cancel(tp, XFS_TRANS_ABORT);
	return error;
}

static int
xfs_growfs_log_private(
	xfs_mount_t		*mp,	/* mount point for filesystem */
	xfs_growfs_log_t	*in)	/* growfs log input struct */
{
	xfs_extlen_t		nb;

	nb = in->newblocks;
	if (nb < XFS_MIN_LOG_BLOCKS || nb < XFS_B_TO_FSB(mp, XFS_MIN_LOG_BYTES))
		return XFS_ERROR(EINVAL);
	if (nb == mp->m_sb.sb_logblocks &&
	    in->isint == (mp->m_sb.sb_logstart != 0))
		return XFS_ERROR(EINVAL);
	/*
	 * Moving the log is hard, need new interfaces to sync
	 * the log first, hold off all activity while moving it.
	 * Can have shorter or longer log in the same space,
	 * or transform internal to external log or vice versa.
	 */
	return XFS_ERROR(ENOSYS);
}

/*
 * protected versions of growfs function acquire and release locks on the mount
 * point - exported through ioctls: XFS_IOC_FSGROWFSDATA, XFS_IOC_FSGROWFSLOG,
 * XFS_IOC_FSGROWFSRT
 */


int
xfs_growfs_data(
	xfs_mount_t		*mp,
	xfs_growfs_data_t	*in)
{
	int error;
487 488 489

	if (!capable(CAP_SYS_ADMIN))
		return XFS_ERROR(EPERM);
490
	if (!mutex_trylock(&mp->m_growlock))
L
Linus Torvalds 已提交
491 492
		return XFS_ERROR(EWOULDBLOCK);
	error = xfs_growfs_data_private(mp, in);
493
	mutex_unlock(&mp->m_growlock);
L
Linus Torvalds 已提交
494 495 496 497 498 499 500 501 502
	return error;
}

int
xfs_growfs_log(
	xfs_mount_t		*mp,
	xfs_growfs_log_t	*in)
{
	int error;
503 504 505

	if (!capable(CAP_SYS_ADMIN))
		return XFS_ERROR(EPERM);
506
	if (!mutex_trylock(&mp->m_growlock))
L
Linus Torvalds 已提交
507 508
		return XFS_ERROR(EWOULDBLOCK);
	error = xfs_growfs_log_private(mp, in);
509
	mutex_unlock(&mp->m_growlock);
L
Linus Torvalds 已提交
510 511 512 513 514 515 516 517 518 519 520 521
	return error;
}

/*
 * exported through ioctl XFS_IOC_FSCOUNTS
 */

int
xfs_fs_counts(
	xfs_mount_t		*mp,
	xfs_fsop_counts_t	*cnt)
{
522
	xfs_icsb_sync_counters(mp, XFS_ICSB_LAZY_COUNT);
E
Eric Sandeen 已提交
523
	spin_lock(&mp->m_sb_lock);
524
	cnt->freedata = mp->m_sb.sb_fdblocks - XFS_ALLOC_SET_ASIDE(mp);
L
Linus Torvalds 已提交
525 526 527
	cnt->freertx = mp->m_sb.sb_frextents;
	cnt->freeino = mp->m_sb.sb_ifree;
	cnt->allocino = mp->m_sb.sb_icount;
E
Eric Sandeen 已提交
528
	spin_unlock(&mp->m_sb_lock);
L
Linus Torvalds 已提交
529 530 531 532 533 534 535 536
	return 0;
}

/*
 * exported through ioctl XFS_IOC_SET_RESBLKS & XFS_IOC_GET_RESBLKS
 *
 * xfs_reserve_blocks is called to set m_resblks
 * in the in-core mount table. The number of unused reserved blocks
537
 * is kept in m_resblks_avail.
L
Linus Torvalds 已提交
538 539 540 541 542 543 544 545 546 547 548 549 550 551 552
 *
 * Reserve the requested number of blocks if available. Otherwise return
 * as many as possible to satisfy the request. The actual number
 * reserved are returned in outval
 *
 * A null inval pointer indicates that only the current reserved blocks
 * available  should  be returned no settings are changed.
 */

int
xfs_reserve_blocks(
	xfs_mount_t             *mp,
	__uint64_t              *inval,
	xfs_fsop_resblks_t      *outval)
{
553
	__int64_t		lcounter, delta, fdblks_delta;
L
Linus Torvalds 已提交
554 555 556 557
	__uint64_t		request;

	/* If inval is null, report current values and return */
	if (inval == (__uint64_t *)NULL) {
558 559
		if (!outval)
			return EINVAL;
L
Linus Torvalds 已提交
560 561
		outval->resblks = mp->m_resblks;
		outval->resblks_avail = mp->m_resblks_avail;
562
		return 0;
L
Linus Torvalds 已提交
563 564 565
	}

	request = *inval;
566 567 568 569 570 571

	/*
	 * With per-cpu counters, this becomes an interesting
	 * problem. we needto work out if we are freeing or allocation
	 * blocks first, then we can do the modification as necessary.
	 *
E
Eric Sandeen 已提交
572
	 * We do this under the m_sb_lock so that if we are near
573 574 575 576 577 578 579 580 581 582
	 * ENOSPC, we will hold out any changes while we work out
	 * what to do. This means that the amount of free space can
	 * change while we do this, so we need to retry if we end up
	 * trying to reserve more space than is available.
	 *
	 * We also use the xfs_mod_incore_sb() interface so that we
	 * don't have to care about whether per cpu counter are
	 * enabled, disabled or even compiled in....
	 */
retry:
E
Eric Sandeen 已提交
583
	spin_lock(&mp->m_sb_lock);
584
	xfs_icsb_sync_counters_locked(mp, 0);
L
Linus Torvalds 已提交
585 586 587 588 589

	/*
	 * If our previous reservation was larger than the current value,
	 * then move any unused blocks back to the free pool.
	 */
590
	fdblks_delta = 0;
L
Linus Torvalds 已提交
591 592 593
	if (mp->m_resblks > request) {
		lcounter = mp->m_resblks_avail - request;
		if (lcounter  > 0) {		/* release unused blocks */
594
			fdblks_delta = lcounter;
L
Linus Torvalds 已提交
595 596 597 598
			mp->m_resblks_avail -= lcounter;
		}
		mp->m_resblks = request;
	} else {
599 600 601
		__int64_t	free;

		free =  mp->m_sb.sb_fdblocks - XFS_ALLOC_SET_ASIDE(mp);
602 603 604
		if (!free)
			goto out; /* ENOSPC and fdblks_delta = 0 */

L
Linus Torvalds 已提交
605
		delta = request - mp->m_resblks;
606
		lcounter = free - delta;
L
Linus Torvalds 已提交
607 608
		if (lcounter < 0) {
			/* We can't satisfy the request, just get what we can */
609 610
			mp->m_resblks += free;
			mp->m_resblks_avail += free;
611
			fdblks_delta = -free;
L
Linus Torvalds 已提交
612
		} else {
613
			fdblks_delta = -delta;
L
Linus Torvalds 已提交
614 615 616 617
			mp->m_resblks = request;
			mp->m_resblks_avail += delta;
		}
	}
618
out:
619 620 621 622
	if (outval) {
		outval->resblks = mp->m_resblks;
		outval->resblks_avail = mp->m_resblks_avail;
	}
E
Eric Sandeen 已提交
623
	spin_unlock(&mp->m_sb_lock);
624 625 626 627

	if (fdblks_delta) {
		/*
		 * If we are putting blocks back here, m_resblks_avail is
M
Malcolm Parsons 已提交
628
		 * already at its max so this will put it in the free pool.
629 630 631 632 633 634 635 636 637 638 639
		 *
		 * If we need space, we'll either succeed in getting it
		 * from the free block count or we'll get an enospc. If
		 * we get a ENOSPC, it means things changed while we were
		 * calculating fdblks_delta and so we should try again to
		 * see if there is anything left to reserve.
		 *
		 * Don't set the reserved flag here - we don't want to reserve
		 * the extra reserve blocks from the reserve.....
		 */
		int error;
640 641
		error = xfs_icsb_modify_counters(mp, XFS_SBS_FDBLOCKS,
						 fdblks_delta, 0);
642 643 644
		if (error == ENOSPC)
			goto retry;
	}
645
	return 0;
L
Linus Torvalds 已提交
646 647
}

648 649 650 651 652 653 654
/*
 * Dump a transaction into the log that contains no real change. This is needed
 * to be able to make the log dirty or stamp the current tail LSN into the log
 * during the covering operation.
 *
 * We cannot use an inode here for this - that will push dirty state back up
 * into the VFS and then periodic inode flushing will prevent log covering from
655 656 657
 * making progress. Hence we log a field in the superblock instead and use a
 * synchronous transaction to ensure the superblock is immediately unpinned
 * and can be written back.
658
 */
659
int
660
xfs_fs_log_dummy(
661
	xfs_mount_t	*mp)
662
{
663
	xfs_trans_t	*tp;
664
	int		error;
665

666
	tp = _xfs_trans_alloc(mp, XFS_TRANS_DUMMY1, KM_SLEEP);
667 668
	error = xfs_trans_reserve(tp, 0, mp->m_sb.sb_sectsize + 128, 0, 0,
					XFS_DEFAULT_LOG_COUNT);
669
	if (error) {
670
		xfs_trans_cancel(tp, 0);
671
		return error;
672 673
	}

674 675
	/* log the UUID because it is an unchanging field */
	xfs_mod_sb(tp, XFS_SB_UUID);
676
	xfs_trans_set_sync(tp);
677
	return xfs_trans_commit(tp, 0);
678 679
}

L
Linus Torvalds 已提交
680 681 682 683 684 685 686
int
xfs_fs_goingdown(
	xfs_mount_t	*mp,
	__uint32_t	inflags)
{
	switch (inflags) {
	case XFS_FSOP_GOING_FLAGS_DEFAULT: {
C
Christoph Hellwig 已提交
687
		struct super_block *sb = freeze_bdev(mp->m_super->s_bdev);
L
Linus Torvalds 已提交
688

689
		if (sb && !IS_ERR(sb)) {
690
			xfs_force_shutdown(mp, SHUTDOWN_FORCE_UMOUNT);
L
Linus Torvalds 已提交
691 692
			thaw_bdev(sb->s_bdev, sb);
		}
693

L
Linus Torvalds 已提交
694 695 696
		break;
	}
	case XFS_FSOP_GOING_FLAGS_LOGFLUSH:
697
		xfs_force_shutdown(mp, SHUTDOWN_FORCE_UMOUNT);
L
Linus Torvalds 已提交
698 699
		break;
	case XFS_FSOP_GOING_FLAGS_NOLOGFLUSH:
700 701
		xfs_force_shutdown(mp,
				SHUTDOWN_FORCE_UMOUNT | SHUTDOWN_LOG_IO_ERROR);
L
Linus Torvalds 已提交
702 703 704 705 706 707 708
		break;
	default:
		return XFS_ERROR(EINVAL);
	}

	return 0;
}
709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768

/*
 * Force a shutdown of the filesystem instantly while keeping the filesystem
 * consistent. We don't do an unmount here; just shutdown the shop, make sure
 * that absolutely nothing persistent happens to this filesystem after this
 * point.
 */
void
xfs_do_force_shutdown(
	xfs_mount_t	*mp,
	int		flags,
	char		*fname,
	int		lnnum)
{
	int		logerror;

	logerror = flags & SHUTDOWN_LOG_IO_ERROR;

	if (!(flags & SHUTDOWN_FORCE_UMOUNT)) {
		xfs_notice(mp,
	"%s(0x%x) called from line %d of file %s.  Return address = 0x%p",
			__func__, flags, lnnum, fname, __return_address);
	}
	/*
	 * No need to duplicate efforts.
	 */
	if (XFS_FORCED_SHUTDOWN(mp) && !logerror)
		return;

	/*
	 * This flags XFS_MOUNT_FS_SHUTDOWN, makes sure that we don't
	 * queue up anybody new on the log reservations, and wakes up
	 * everybody who's sleeping on log reservations to tell them
	 * the bad news.
	 */
	if (xfs_log_force_umount(mp, logerror))
		return;

	if (flags & SHUTDOWN_CORRUPT_INCORE) {
		xfs_alert_tag(mp, XFS_PTAG_SHUTDOWN_CORRUPT,
    "Corruption of in-memory data detected.  Shutting down filesystem");
		if (XFS_ERRLEVEL_HIGH <= xfs_error_level)
			xfs_stack_trace();
	} else if (!(flags & SHUTDOWN_FORCE_UMOUNT)) {
		if (logerror) {
			xfs_alert_tag(mp, XFS_PTAG_SHUTDOWN_LOGERROR,
		"Log I/O Error Detected.  Shutting down filesystem");
		} else if (flags & SHUTDOWN_DEVICE_REQ) {
			xfs_alert_tag(mp, XFS_PTAG_SHUTDOWN_IOERROR,
		"All device paths lost.  Shutting down filesystem");
		} else if (!(flags & SHUTDOWN_REMOTE_REQ)) {
			xfs_alert_tag(mp, XFS_PTAG_SHUTDOWN_IOERROR,
		"I/O Error Detected. Shutting down filesystem");
		}
	}
	if (!(flags & SHUTDOWN_FORCE_UMOUNT)) {
		xfs_alert(mp,
	"Please umount the filesystem and rectify the problem(s)");
	}
}