xfs_fsops.c 22.5 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
				XFS_FSOP_GEOM_FLAGS_ATTR2 : 0) |
			(xfs_sb_version_hasprojid32bit(&mp->m_sb) ?
102 103
				XFS_FSOP_GEOM_FLAGS_PROJID32 : 0) |
			(xfs_sb_version_hascrc(&mp->m_sb) ?
104 105 106
				XFS_FSOP_GEOM_FLAGS_V5SB : 0) |
			(xfs_sb_version_hasftype(&mp->m_sb) ?
				XFS_FSOP_GEOM_FLAGS_FTYPE : 0);
107
		geo->logsectsize = xfs_sb_version_hassector(&mp->m_sb) ?
L
Linus Torvalds 已提交
108 109 110 111 112 113
				mp->m_sb.sb_logsectsize : BBSIZE;
		geo->rtsectsize = mp->m_sb.sb_blocksize;
		geo->dirblocksize = mp->m_dirblksize;
	}
	if (new_version >= 4) {
		geo->flags |=
114
			(xfs_sb_version_haslogv2(&mp->m_sb) ?
L
Linus Torvalds 已提交
115 116 117 118 119 120
				XFS_FSOP_GEOM_FLAGS_LOGV2 : 0);
		geo->logsunit = mp->m_sb.sb_logsunit;
	}
	return 0;
}

121 122 123 124 125
static struct xfs_buf *
xfs_growfs_get_hdr_buf(
	struct xfs_mount	*mp,
	xfs_daddr_t		blkno,
	size_t			numblks,
126 127
	int			flags,
	const struct xfs_buf_ops *ops)
128 129 130 131 132 133 134 135 136 137
{
	struct xfs_buf		*bp;

	bp = xfs_buf_get_uncached(mp->m_ddev_targp, numblks, flags);
	if (!bp)
		return NULL;

	xfs_buf_zero(bp, 0, BBTOB(bp->b_length));
	bp->b_bn = blkno;
	bp->b_maps[0].bm_bn = blkno;
138
	bp->b_ops = ops;
139 140 141 142

	return bp;
}

L
Linus Torvalds 已提交
143 144 145 146 147 148
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;
149
	struct xfs_agfl		*agfl;
L
Linus Torvalds 已提交
150 151 152 153 154 155 156 157
	xfs_agi_t		*agi;
	xfs_agnumber_t		agno;
	xfs_extlen_t		agsize;
	xfs_extlen_t		tmpsize;
	xfs_alloc_rec_t		*arec;
	xfs_buf_t		*bp;
	int			bucket;
	int			dpct;
158
	int			error, saved_error = 0;
L
Linus Torvalds 已提交
159 160 161 162 163 164 165 166 167 168 169 170 171
	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);
172 173
	if ((error = xfs_sb_validate_fsb_count(&mp->m_sb, nb)))
		return error;
L
Linus Torvalds 已提交
174
	dpct = pct - mp->m_sb.sb_imax_pct;
175
	bp = xfs_buf_read_uncached(mp->m_ddev_targp,
176
				XFS_FSB_TO_BB(mp, nb) - XFS_FSS_TO_BB(mp, 1),
177
				XFS_FSS_TO_BB(mp, 1), 0, NULL);
178 179
	if (!bp)
		return EIO;
180
	if (bp->b_error) {
181
		error = bp->b_error;
182 183 184
		xfs_buf_relse(bp);
		return error;
	}
L
Linus Torvalds 已提交
185 186 187 188 189 190 191
	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--;
192
		nb = (xfs_rfsblock_t)nagcount * mp->m_sb.sb_agblocks;
L
Linus Torvalds 已提交
193 194 195 196 197
		if (nb < mp->m_sb.sb_dblocks)
			return XFS_ERROR(EINVAL);
	}
	new = nb - mp->m_sb.sb_dblocks;
	oagcount = mp->m_sb.sb_agcount;
198

199 200 201 202 203
	/* allocate the new per-ag structures */
	if (nagcount > oagcount) {
		error = xfs_initialize_perag(mp, nagcount, &nagimax);
		if (error)
			return error;
L
Linus Torvalds 已提交
204
	}
205

L
Linus Torvalds 已提交
206
	tp = xfs_trans_alloc(mp, XFS_TRANS_GROWFS);
207
	tp->t_flags |= XFS_TRANS_RESERVE;
208 209 210
	error = xfs_trans_reserve(tp, &M_RES(mp)->tr_growdata,
				  XFS_GROWFS_SPACE_RES(mp), 0);
	if (error) {
L
Linus Torvalds 已提交
211 212 213 214
		xfs_trans_cancel(tp, 0);
		return error;
	}

215 216 217 218 219
	/*
	 * 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 已提交
220 221 222
	nfree = 0;
	for (agno = nagcount - 1; agno >= oagcount; agno--, new -= agsize) {
		/*
223
		 * AG freespace header block
L
Linus Torvalds 已提交
224
		 */
225 226
		bp = xfs_growfs_get_hdr_buf(mp,
				XFS_AG_DADDR(mp, agno, XFS_AGF_DADDR(mp)),
227 228
				XFS_FSS_TO_BB(mp, 1), 0,
				&xfs_agf_buf_ops);
229 230 231 232
		if (!bp) {
			error = ENOMEM;
			goto error0;
		}
233

L
Linus Torvalds 已提交
234
		agf = XFS_BUF_TO_AGF(bp);
235 236 237
		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 已提交
238 239 240 241 242 243
		if (agno == nagcount - 1)
			agsize =
				nb -
				(agno * (xfs_rfsblock_t)mp->m_sb.sb_agblocks);
		else
			agsize = mp->m_sb.sb_agblocks;
244 245 246 247 248
		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 已提交
249
		agf->agf_flfirst = 0;
250
		agf->agf_fllast = cpu_to_be32(XFS_AGFL_SIZE(mp) - 1);
L
Linus Torvalds 已提交
251 252
		agf->agf_flcount = 0;
		tmpsize = agsize - XFS_PREALLOC_BLOCKS(mp);
253 254
		agf->agf_freeblks = cpu_to_be32(tmpsize);
		agf->agf_longest = cpu_to_be32(tmpsize);
D
Dave Chinner 已提交
255 256 257
		if (xfs_sb_version_hascrc(&mp->m_sb))
			uuid_copy(&agf->agf_uuid, &mp->m_sb.sb_uuid);

258 259 260
		error = xfs_bwrite(bp);
		xfs_buf_relse(bp);
		if (error)
L
Linus Torvalds 已提交
261
			goto error0;
262

263 264 265 266 267
		/*
		 * AG freelist header block
		 */
		bp = xfs_growfs_get_hdr_buf(mp,
				XFS_AG_DADDR(mp, agno, XFS_AGFL_DADDR(mp)),
268 269
				XFS_FSS_TO_BB(mp, 1), 0,
				&xfs_agfl_buf_ops);
270 271 272 273 274 275
		if (!bp) {
			error = ENOMEM;
			goto error0;
		}

		agfl = XFS_BUF_TO_AGFL(bp);
276 277 278 279 280
		if (xfs_sb_version_hascrc(&mp->m_sb)) {
			agfl->agfl_magicnum = cpu_to_be32(XFS_AGFL_MAGIC);
			agfl->agfl_seqno = cpu_to_be32(agno);
			uuid_copy(&agfl->agfl_uuid, &mp->m_sb.sb_uuid);
		}
281 282 283 284 285 286 287 288
		for (bucket = 0; bucket < XFS_AGFL_SIZE(mp); bucket++)
			agfl->agfl_bno[bucket] = cpu_to_be32(NULLAGBLOCK);

		error = xfs_bwrite(bp);
		xfs_buf_relse(bp);
		if (error)
			goto error0;

L
Linus Torvalds 已提交
289 290 291
		/*
		 * AG inode header block
		 */
292 293
		bp = xfs_growfs_get_hdr_buf(mp,
				XFS_AG_DADDR(mp, agno, XFS_AGI_DADDR(mp)),
294 295
				XFS_FSS_TO_BB(mp, 1), 0,
				&xfs_agi_buf_ops);
296 297 298 299
		if (!bp) {
			error = ENOMEM;
			goto error0;
		}
300

L
Linus Torvalds 已提交
301
		agi = XFS_BUF_TO_AGI(bp);
302 303 304 305
		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 已提交
306
		agi->agi_count = 0;
307 308
		agi->agi_root = cpu_to_be32(XFS_IBT_BLOCK(mp));
		agi->agi_level = cpu_to_be32(1);
L
Linus Torvalds 已提交
309
		agi->agi_freecount = 0;
310 311
		agi->agi_newino = cpu_to_be32(NULLAGINO);
		agi->agi_dirino = cpu_to_be32(NULLAGINO);
D
Dave Chinner 已提交
312 313
		if (xfs_sb_version_hascrc(&mp->m_sb))
			uuid_copy(&agi->agi_uuid, &mp->m_sb.sb_uuid);
L
Linus Torvalds 已提交
314
		for (bucket = 0; bucket < XFS_AGI_UNLINKED_BUCKETS; bucket++)
315
			agi->agi_unlinked[bucket] = cpu_to_be32(NULLAGINO);
D
Dave Chinner 已提交
316

317 318 319
		error = xfs_bwrite(bp);
		xfs_buf_relse(bp);
		if (error)
L
Linus Torvalds 已提交
320
			goto error0;
321

L
Linus Torvalds 已提交
322 323 324
		/*
		 * BNO btree root block
		 */
325 326
		bp = xfs_growfs_get_hdr_buf(mp,
				XFS_AGB_TO_DADDR(mp, agno, XFS_BNO_BLOCK(mp)),
327 328
				BTOBB(mp->m_sb.sb_blocksize), 0,
				&xfs_allocbt_buf_ops);
329

330 331 332 333
		if (!bp) {
			error = ENOMEM;
			goto error0;
		}
334

335 336 337 338 339 340 341
		if (xfs_sb_version_hascrc(&mp->m_sb))
			xfs_btree_init_block(mp, bp, XFS_ABTB_CRC_MAGIC, 0, 1,
						agno, XFS_BTREE_CRC_BLOCKS);
		else
			xfs_btree_init_block(mp, bp, XFS_ABTB_MAGIC, 0, 1,
						agno, 0);

342
		arec = XFS_ALLOC_REC_ADDR(mp, XFS_BUF_TO_BLOCK(bp), 1);
343 344 345
		arec->ar_startblock = cpu_to_be32(XFS_PREALLOC_BLOCKS(mp));
		arec->ar_blockcount = cpu_to_be32(
			agsize - be32_to_cpu(arec->ar_startblock));
346

347 348 349
		error = xfs_bwrite(bp);
		xfs_buf_relse(bp);
		if (error)
L
Linus Torvalds 已提交
350
			goto error0;
351

L
Linus Torvalds 已提交
352 353 354
		/*
		 * CNT btree root block
		 */
355 356
		bp = xfs_growfs_get_hdr_buf(mp,
				XFS_AGB_TO_DADDR(mp, agno, XFS_CNT_BLOCK(mp)),
357 358
				BTOBB(mp->m_sb.sb_blocksize), 0,
				&xfs_allocbt_buf_ops);
359 360 361 362
		if (!bp) {
			error = ENOMEM;
			goto error0;
		}
363

364 365 366 367 368 369 370
		if (xfs_sb_version_hascrc(&mp->m_sb))
			xfs_btree_init_block(mp, bp, XFS_ABTC_CRC_MAGIC, 0, 1,
						agno, XFS_BTREE_CRC_BLOCKS);
		else
			xfs_btree_init_block(mp, bp, XFS_ABTC_MAGIC, 0, 1,
						agno, 0);

371
		arec = XFS_ALLOC_REC_ADDR(mp, XFS_BUF_TO_BLOCK(bp), 1);
372 373 374 375
		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);
376

377 378 379
		error = xfs_bwrite(bp);
		xfs_buf_relse(bp);
		if (error)
L
Linus Torvalds 已提交
380
			goto error0;
381

L
Linus Torvalds 已提交
382 383 384
		/*
		 * INO btree root block
		 */
385 386
		bp = xfs_growfs_get_hdr_buf(mp,
				XFS_AGB_TO_DADDR(mp, agno, XFS_IBT_BLOCK(mp)),
387 388
				BTOBB(mp->m_sb.sb_blocksize), 0,
				&xfs_inobt_buf_ops);
389 390 391 392
		if (!bp) {
			error = ENOMEM;
			goto error0;
		}
393

394 395 396 397 398 399
		if (xfs_sb_version_hascrc(&mp->m_sb))
			xfs_btree_init_block(mp, bp, XFS_IBT_CRC_MAGIC, 0, 0,
						agno, XFS_BTREE_CRC_BLOCKS);
		else
			xfs_btree_init_block(mp, bp, XFS_IBT_MAGIC, 0, 0,
						agno, 0);
400

401 402 403
		error = xfs_bwrite(bp);
		xfs_buf_relse(bp);
		if (error)
L
Linus Torvalds 已提交
404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419
			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);
420
		be32_add_cpu(&agi->agi_length, new);
L
Linus Torvalds 已提交
421
		ASSERT(nagcount == oagcount ||
422
		       be32_to_cpu(agi->agi_length) == mp->m_sb.sb_agblocks);
L
Linus Torvalds 已提交
423 424 425 426 427 428 429 430 431 432
		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);
433
		be32_add_cpu(&agf->agf_length, new);
434 435
		ASSERT(be32_to_cpu(agf->agf_length) ==
		       be32_to_cpu(agi->agi_length));
C
Christoph Hellwig 已提交
436

437
		xfs_alloc_log_agf(tp, bp, XFS_AGF_LENGTH);
L
Linus Torvalds 已提交
438 439 440 441
		/*
		 * Free the new space.
		 */
		error = xfs_free_extent(tp, XFS_AGB_TO_FSB(mp, agno,
442
			be32_to_cpu(agf->agf_length) - new), new);
L
Linus Torvalds 已提交
443 444 445 446
		if (error) {
			goto error0;
		}
	}
447 448 449 450 451 452

	/*
	 * 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 已提交
453 454 455 456 457 458 459 460 461
	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);
462
	error = xfs_trans_commit(tp, 0);
463
	if (error)
L
Linus Torvalds 已提交
464
		return error;
465

L
Linus Torvalds 已提交
466 467 468 469 470 471 472 473 474
	/* 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;
475
	xfs_set_low_space_thresholds(mp);
476 477

	/* update secondary superblocks. */
L
Linus Torvalds 已提交
478
	for (agno = 1; agno < nagcount; agno++) {
479 480 481 482 483 484 485 486
		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 已提交
487
				  XFS_AGB_TO_DADDR(mp, agno, XFS_SB_BLOCK(mp)),
488
				  XFS_FSS_TO_BB(mp, 1), 0, &bp,
489
				  &xfs_sb_buf_ops);
490 491 492 493
		} 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);
494
			if (bp) {
495
				bp->b_ops = &xfs_sb_buf_ops;
496
				xfs_buf_zero(bp, 0, BBTOB(bp->b_length));
497
			} else
498 499 500
				error = ENOMEM;
		}

501 502 503 504 505 506 507
		/*
		 * If we get an error reading or writing alternate superblocks,
		 * continue.  xfs_repair chooses the "best" superblock based
		 * on most matches; if we break early, we'll leave more
		 * superblocks un-updated than updated, and xfs_repair may
		 * pick them over the properly-updated primary.
		 */
L
Linus Torvalds 已提交
508
		if (error) {
509 510
			xfs_warn(mp,
		"error %d reading secondary superblock for ag %d",
L
Linus Torvalds 已提交
511
				error, agno);
512 513
			saved_error = error;
			continue;
L
Linus Torvalds 已提交
514
		}
515
		xfs_sb_to_disk(XFS_BUF_TO_SBP(bp), &mp->m_sb, XFS_SB_ALL_BITS);
516

517 518 519
		error = xfs_bwrite(bp);
		xfs_buf_relse(bp);
		if (error) {
520
			xfs_warn(mp,
L
Linus Torvalds 已提交
521 522
		"write error %d updating secondary superblock for ag %d",
				error, agno);
523 524
			saved_error = error;
			continue;
L
Linus Torvalds 已提交
525 526
		}
	}
527
	return saved_error ? saved_error : error;
L
Linus Torvalds 已提交
528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568

 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;
569 570 571

	if (!capable(CAP_SYS_ADMIN))
		return XFS_ERROR(EPERM);
572
	if (!mutex_trylock(&mp->m_growlock))
L
Linus Torvalds 已提交
573 574
		return XFS_ERROR(EWOULDBLOCK);
	error = xfs_growfs_data_private(mp, in);
575
	mutex_unlock(&mp->m_growlock);
L
Linus Torvalds 已提交
576 577 578 579 580 581 582 583 584
	return error;
}

int
xfs_growfs_log(
	xfs_mount_t		*mp,
	xfs_growfs_log_t	*in)
{
	int error;
585 586 587

	if (!capable(CAP_SYS_ADMIN))
		return XFS_ERROR(EPERM);
588
	if (!mutex_trylock(&mp->m_growlock))
L
Linus Torvalds 已提交
589 590
		return XFS_ERROR(EWOULDBLOCK);
	error = xfs_growfs_log_private(mp, in);
591
	mutex_unlock(&mp->m_growlock);
L
Linus Torvalds 已提交
592 593 594 595 596 597 598 599 600 601 602 603
	return error;
}

/*
 * exported through ioctl XFS_IOC_FSCOUNTS
 */

int
xfs_fs_counts(
	xfs_mount_t		*mp,
	xfs_fsop_counts_t	*cnt)
{
604
	xfs_icsb_sync_counters(mp, XFS_ICSB_LAZY_COUNT);
E
Eric Sandeen 已提交
605
	spin_lock(&mp->m_sb_lock);
606
	cnt->freedata = mp->m_sb.sb_fdblocks - XFS_ALLOC_SET_ASIDE(mp);
L
Linus Torvalds 已提交
607 608 609
	cnt->freertx = mp->m_sb.sb_frextents;
	cnt->freeino = mp->m_sb.sb_ifree;
	cnt->allocino = mp->m_sb.sb_icount;
E
Eric Sandeen 已提交
610
	spin_unlock(&mp->m_sb_lock);
L
Linus Torvalds 已提交
611 612 613 614 615 616 617 618
	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
619
 * is kept in m_resblks_avail.
L
Linus Torvalds 已提交
620 621 622 623 624 625 626 627 628 629 630 631 632 633 634
 *
 * 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)
{
635
	__int64_t		lcounter, delta, fdblks_delta;
L
Linus Torvalds 已提交
636 637 638 639
	__uint64_t		request;

	/* If inval is null, report current values and return */
	if (inval == (__uint64_t *)NULL) {
640 641
		if (!outval)
			return EINVAL;
L
Linus Torvalds 已提交
642 643
		outval->resblks = mp->m_resblks;
		outval->resblks_avail = mp->m_resblks_avail;
644
		return 0;
L
Linus Torvalds 已提交
645 646 647
	}

	request = *inval;
648 649 650 651 652 653

	/*
	 * 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 已提交
654
	 * We do this under the m_sb_lock so that if we are near
655 656 657 658 659 660 661 662 663 664
	 * 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 已提交
665
	spin_lock(&mp->m_sb_lock);
666
	xfs_icsb_sync_counters_locked(mp, 0);
L
Linus Torvalds 已提交
667 668 669 670 671

	/*
	 * If our previous reservation was larger than the current value,
	 * then move any unused blocks back to the free pool.
	 */
672
	fdblks_delta = 0;
L
Linus Torvalds 已提交
673 674 675
	if (mp->m_resblks > request) {
		lcounter = mp->m_resblks_avail - request;
		if (lcounter  > 0) {		/* release unused blocks */
676
			fdblks_delta = lcounter;
L
Linus Torvalds 已提交
677 678 679 680
			mp->m_resblks_avail -= lcounter;
		}
		mp->m_resblks = request;
	} else {
681 682 683
		__int64_t	free;

		free =  mp->m_sb.sb_fdblocks - XFS_ALLOC_SET_ASIDE(mp);
684 685 686
		if (!free)
			goto out; /* ENOSPC and fdblks_delta = 0 */

L
Linus Torvalds 已提交
687
		delta = request - mp->m_resblks;
688
		lcounter = free - delta;
L
Linus Torvalds 已提交
689 690
		if (lcounter < 0) {
			/* We can't satisfy the request, just get what we can */
691 692
			mp->m_resblks += free;
			mp->m_resblks_avail += free;
693
			fdblks_delta = -free;
L
Linus Torvalds 已提交
694
		} else {
695
			fdblks_delta = -delta;
L
Linus Torvalds 已提交
696 697 698 699
			mp->m_resblks = request;
			mp->m_resblks_avail += delta;
		}
	}
700
out:
701 702 703 704
	if (outval) {
		outval->resblks = mp->m_resblks;
		outval->resblks_avail = mp->m_resblks_avail;
	}
E
Eric Sandeen 已提交
705
	spin_unlock(&mp->m_sb_lock);
706 707 708 709

	if (fdblks_delta) {
		/*
		 * If we are putting blocks back here, m_resblks_avail is
M
Malcolm Parsons 已提交
710
		 * already at its max so this will put it in the free pool.
711 712 713 714 715 716 717 718 719 720 721
		 *
		 * 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;
722 723
		error = xfs_icsb_modify_counters(mp, XFS_SBS_FDBLOCKS,
						 fdblks_delta, 0);
724 725 726
		if (error == ENOSPC)
			goto retry;
	}
727
	return 0;
L
Linus Torvalds 已提交
728 729
}

730 731 732 733 734 735 736
/*
 * 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
737 738 739
 * 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.
740
 */
741
int
742
xfs_fs_log_dummy(
743
	xfs_mount_t	*mp)
744
{
745
	xfs_trans_t	*tp;
746
	int		error;
747

748
	tp = _xfs_trans_alloc(mp, XFS_TRANS_DUMMY1, KM_SLEEP);
749
	error = xfs_trans_reserve(tp, &M_RES(mp)->tr_sb, 0, 0);
750
	if (error) {
751
		xfs_trans_cancel(tp, 0);
752
		return error;
753 754
	}

755 756
	/* log the UUID because it is an unchanging field */
	xfs_mod_sb(tp, XFS_SB_UUID);
757
	xfs_trans_set_sync(tp);
758
	return xfs_trans_commit(tp, 0);
759 760
}

L
Linus Torvalds 已提交
761 762 763 764 765 766 767
int
xfs_fs_goingdown(
	xfs_mount_t	*mp,
	__uint32_t	inflags)
{
	switch (inflags) {
	case XFS_FSOP_GOING_FLAGS_DEFAULT: {
C
Christoph Hellwig 已提交
768
		struct super_block *sb = freeze_bdev(mp->m_super->s_bdev);
L
Linus Torvalds 已提交
769

770
		if (sb && !IS_ERR(sb)) {
771
			xfs_force_shutdown(mp, SHUTDOWN_FORCE_UMOUNT);
L
Linus Torvalds 已提交
772 773
			thaw_bdev(sb->s_bdev, sb);
		}
774

L
Linus Torvalds 已提交
775 776 777
		break;
	}
	case XFS_FSOP_GOING_FLAGS_LOGFLUSH:
778
		xfs_force_shutdown(mp, SHUTDOWN_FORCE_UMOUNT);
L
Linus Torvalds 已提交
779 780
		break;
	case XFS_FSOP_GOING_FLAGS_NOLOGFLUSH:
781 782
		xfs_force_shutdown(mp,
				SHUTDOWN_FORCE_UMOUNT | SHUTDOWN_LOG_IO_ERROR);
L
Linus Torvalds 已提交
783 784 785 786 787 788 789
		break;
	default:
		return XFS_ERROR(EINVAL);
	}

	return 0;
}
790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849

/*
 * 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)");
	}
}