xfs_fsops.c 22.2 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"
20
#include "xfs_shared.h"
21
#include "xfs_format.h"
22
#include "xfs_log_format.h"
23
#include "xfs_trans_resv.h"
L
Linus Torvalds 已提交
24 25
#include "xfs_sb.h"
#include "xfs_mount.h"
26 27
#include "xfs_da_format.h"
#include "xfs_da_btree.h"
28
#include "xfs_inode.h"
29
#include "xfs_trans.h"
30
#include "xfs_inode_item.h"
L
Linus Torvalds 已提交
31
#include "xfs_error.h"
32 33
#include "xfs_btree.h"
#include "xfs_alloc_btree.h"
L
Linus Torvalds 已提交
34 35 36 37 38 39
#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"
C
Christoph Hellwig 已提交
40
#include "xfs_trace.h"
41
#include "xfs_log.h"
42
#include "xfs_filestream.h"
L
Linus Torvalds 已提交
43 44 45 46 47 48 49 50 51 52 53

/*
 * File system operations
 */

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

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

L
Linus Torvalds 已提交
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;
77
		geo->flags = XFS_FSOP_GEOM_FLAGS_NLINK |
78
			     XFS_FSOP_GEOM_FLAGS_DIRV2 |
79
			(xfs_sb_version_hasattr(&mp->m_sb) ?
L
Linus Torvalds 已提交
80
				XFS_FSOP_GEOM_FLAGS_ATTR : 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_hasextflgbit(&mp->m_sb) ?
L
Linus Torvalds 已提交
88
				XFS_FSOP_GEOM_FLAGS_EXTFLG : 0) |
89
			(xfs_sb_version_hassector(&mp->m_sb) ?
90
				XFS_FSOP_GEOM_FLAGS_SECTOR : 0) |
91 92
			(xfs_sb_version_hasasciici(&mp->m_sb) ?
				XFS_FSOP_GEOM_FLAGS_DIRV2CI : 0) |
D
David Chinner 已提交
93 94
			(xfs_sb_version_haslazysbcount(&mp->m_sb) ?
				XFS_FSOP_GEOM_FLAGS_LAZYSB : 0) |
95
			(xfs_sb_version_hasattr2(&mp->m_sb) ?
96 97
				XFS_FSOP_GEOM_FLAGS_ATTR2 : 0) |
			(xfs_sb_version_hasprojid32bit(&mp->m_sb) ?
98 99
				XFS_FSOP_GEOM_FLAGS_PROJID32 : 0) |
			(xfs_sb_version_hascrc(&mp->m_sb) ?
100 101
				XFS_FSOP_GEOM_FLAGS_V5SB : 0) |
			(xfs_sb_version_hasftype(&mp->m_sb) ?
102 103 104
				XFS_FSOP_GEOM_FLAGS_FTYPE : 0) |
			(xfs_sb_version_hasfinobt(&mp->m_sb) ?
				XFS_FSOP_GEOM_FLAGS_FINOBT : 0);
105
		geo->logsectsize = xfs_sb_version_hassector(&mp->m_sb) ?
L
Linus Torvalds 已提交
106 107
				mp->m_sb.sb_logsectsize : BBSIZE;
		geo->rtsectsize = mp->m_sb.sb_blocksize;
108
		geo->dirblocksize = mp->m_dir_geo->blksize;
L
Linus Torvalds 已提交
109 110 111
	}
	if (new_version >= 4) {
		geo->flags |=
112
			(xfs_sb_version_haslogv2(&mp->m_sb) ?
L
Linus Torvalds 已提交
113 114 115 116 117 118
				XFS_FSOP_GEOM_FLAGS_LOGV2 : 0);
		geo->logsunit = mp->m_sb.sb_logsunit;
	}
	return 0;
}

119 120 121 122 123
static struct xfs_buf *
xfs_growfs_get_hdr_buf(
	struct xfs_mount	*mp,
	xfs_daddr_t		blkno,
	size_t			numblks,
124 125
	int			flags,
	const struct xfs_buf_ops *ops)
126 127 128 129 130 131 132 133 134 135
{
	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;
136
	bp->b_ops = ops;
137 138 139 140

	return bp;
}

L
Linus Torvalds 已提交
141 142 143 144 145 146
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;
147
	struct xfs_agfl		*agfl;
L
Linus Torvalds 已提交
148 149 150 151 152 153 154 155
	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;
156
	int			error, saved_error = 0;
L
Linus Torvalds 已提交
157 158 159 160 161 162 163 164 165 166 167 168
	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)
D
Dave Chinner 已提交
169
		return -EINVAL;
170 171
	if ((error = xfs_sb_validate_fsb_count(&mp->m_sb, nb)))
		return error;
L
Linus Torvalds 已提交
172
	dpct = pct - mp->m_sb.sb_imax_pct;
173
	error = xfs_buf_read_uncached(mp->m_ddev_targp,
174
				XFS_FSB_TO_BB(mp, nb) - XFS_FSS_TO_BB(mp, 1),
175 176
				XFS_FSS_TO_BB(mp, 1), 0, &bp, NULL);
	if (error)
177
		return error;
L
Linus Torvalds 已提交
178 179 180 181 182 183 184
	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--;
185
		nb = (xfs_rfsblock_t)nagcount * mp->m_sb.sb_agblocks;
L
Linus Torvalds 已提交
186
		if (nb < mp->m_sb.sb_dblocks)
D
Dave Chinner 已提交
187
			return -EINVAL;
L
Linus Torvalds 已提交
188 189 190
	}
	new = nb - mp->m_sb.sb_dblocks;
	oagcount = mp->m_sb.sb_agcount;
191

192 193 194 195 196
	/* allocate the new per-ag structures */
	if (nagcount > oagcount) {
		error = xfs_initialize_perag(mp, nagcount, &nagimax);
		if (error)
			return error;
L
Linus Torvalds 已提交
197
	}
198

L
Linus Torvalds 已提交
199
	tp = xfs_trans_alloc(mp, XFS_TRANS_GROWFS);
200
	tp->t_flags |= XFS_TRANS_RESERVE;
201 202 203
	error = xfs_trans_reserve(tp, &M_RES(mp)->tr_growdata,
				  XFS_GROWFS_SPACE_RES(mp), 0);
	if (error) {
L
Linus Torvalds 已提交
204 205 206 207
		xfs_trans_cancel(tp, 0);
		return error;
	}

208 209 210 211 212
	/*
	 * 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 已提交
213 214
	nfree = 0;
	for (agno = nagcount - 1; agno >= oagcount; agno--, new -= agsize) {
215 216
		__be32	*agfl_bno;

L
Linus Torvalds 已提交
217
		/*
218
		 * AG freespace header block
L
Linus Torvalds 已提交
219
		 */
220 221
		bp = xfs_growfs_get_hdr_buf(mp,
				XFS_AG_DADDR(mp, agno, XFS_AGF_DADDR(mp)),
222 223
				XFS_FSS_TO_BB(mp, 1), 0,
				&xfs_agf_buf_ops);
224
		if (!bp) {
D
Dave Chinner 已提交
225
			error = -ENOMEM;
226 227
			goto error0;
		}
228

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

253 254 255
		error = xfs_bwrite(bp);
		xfs_buf_relse(bp);
		if (error)
L
Linus Torvalds 已提交
256
			goto error0;
257

258 259 260 261 262
		/*
		 * AG freelist header block
		 */
		bp = xfs_growfs_get_hdr_buf(mp,
				XFS_AG_DADDR(mp, agno, XFS_AGFL_DADDR(mp)),
263 264
				XFS_FSS_TO_BB(mp, 1), 0,
				&xfs_agfl_buf_ops);
265
		if (!bp) {
D
Dave Chinner 已提交
266
			error = -ENOMEM;
267 268 269 270
			goto error0;
		}

		agfl = XFS_BUF_TO_AGFL(bp);
271 272 273 274 275
		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);
		}
276 277

		agfl_bno = XFS_BUF_TO_AGFL_BNO(mp, bp);
278
		for (bucket = 0; bucket < XFS_AGFL_SIZE(mp); bucket++)
279
			agfl_bno[bucket] = cpu_to_be32(NULLAGBLOCK);
280 281 282 283 284 285

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

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

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

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

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

331
		if (!bp) {
D
Dave Chinner 已提交
332
			error = -ENOMEM;
333 334
			goto error0;
		}
335

336 337 338 339 340 341 342
		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);

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

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

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

365 366 367 368 369 370 371
		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);

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

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

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

395 396 397 398 399 400
		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);
401

402 403 404
		error = xfs_bwrite(bp);
		xfs_buf_relse(bp);
		if (error)
L
Linus Torvalds 已提交
405
			goto error0;
B
Brian Foster 已提交
406 407 408 409 410 411 412 413 414 415

		/*
		 * FINO btree root block
		 */
		if (xfs_sb_version_hasfinobt(&mp->m_sb)) {
			bp = xfs_growfs_get_hdr_buf(mp,
				XFS_AGB_TO_DADDR(mp, agno, XFS_FIBT_BLOCK(mp)),
				BTOBB(mp->m_sb.sb_blocksize), 0,
				&xfs_inobt_buf_ops);
			if (!bp) {
D
Dave Chinner 已提交
416
				error = -ENOMEM;
B
Brian Foster 已提交
417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433
				goto error0;
			}

			if (xfs_sb_version_hascrc(&mp->m_sb))
				xfs_btree_init_block(mp, bp, XFS_FIBT_CRC_MAGIC,
						     0, 0, agno,
						     XFS_BTREE_CRC_BLOCKS);
			else
				xfs_btree_init_block(mp, bp, XFS_FIBT_MAGIC, 0,
						     0, agno, 0);

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

L
Linus Torvalds 已提交
434 435 436 437 438 439 440 441 442 443 444 445 446 447 448
	}
	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);
449
		be32_add_cpu(&agi->agi_length, new);
L
Linus Torvalds 已提交
450
		ASSERT(nagcount == oagcount ||
451
		       be32_to_cpu(agi->agi_length) == mp->m_sb.sb_agblocks);
L
Linus Torvalds 已提交
452 453 454 455 456 457 458 459 460 461
		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);
462
		be32_add_cpu(&agf->agf_length, new);
463 464
		ASSERT(be32_to_cpu(agf->agf_length) ==
		       be32_to_cpu(agi->agi_length));
C
Christoph Hellwig 已提交
465

466
		xfs_alloc_log_agf(tp, bp, XFS_AGF_LENGTH);
L
Linus Torvalds 已提交
467 468 469 470
		/*
		 * Free the new space.
		 */
		error = xfs_free_extent(tp, XFS_AGB_TO_FSB(mp, agno,
471
			be32_to_cpu(agf->agf_length) - new), new);
L
Linus Torvalds 已提交
472 473 474 475
		if (error) {
			goto error0;
		}
	}
476 477 478 479 480 481

	/*
	 * 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 已提交
482 483 484 485 486 487 488 489 490
	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);
491
	error = xfs_trans_commit(tp, 0);
492
	if (error)
L
Linus Torvalds 已提交
493
		return error;
494

L
Linus Torvalds 已提交
495 496 497 498 499 500 501 502 503
	/* 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;
504
	xfs_set_low_space_thresholds(mp);
505 506

	/* update secondary superblocks. */
L
Linus Torvalds 已提交
507
	for (agno = 1; agno < nagcount; agno++) {
508 509 510 511 512 513 514 515
		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 已提交
516
				  XFS_AGB_TO_DADDR(mp, agno, XFS_SB_BLOCK(mp)),
517
				  XFS_FSS_TO_BB(mp, 1), 0, &bp,
518
				  &xfs_sb_buf_ops);
519 520 521 522
		} 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);
523
			if (bp) {
524
				bp->b_ops = &xfs_sb_buf_ops;
525
				xfs_buf_zero(bp, 0, BBTOB(bp->b_length));
526
			} else
D
Dave Chinner 已提交
527
				error = -ENOMEM;
528 529
		}

530 531 532 533 534 535 536
		/*
		 * 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 已提交
537
		if (error) {
538 539
			xfs_warn(mp,
		"error %d reading secondary superblock for ag %d",
L
Linus Torvalds 已提交
540
				error, agno);
541 542
			saved_error = error;
			continue;
L
Linus Torvalds 已提交
543
		}
544
		xfs_sb_to_disk(XFS_BUF_TO_SBP(bp), &mp->m_sb);
545

546 547 548
		error = xfs_bwrite(bp);
		xfs_buf_relse(bp);
		if (error) {
549
			xfs_warn(mp,
L
Linus Torvalds 已提交
550 551
		"write error %d updating secondary superblock for ag %d",
				error, agno);
552 553
			saved_error = error;
			continue;
L
Linus Torvalds 已提交
554 555
		}
	}
556
	return saved_error ? saved_error : error;
L
Linus Torvalds 已提交
557 558 559 560 561 562 563 564 565 566 567 568 569 570 571

 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))
D
Dave Chinner 已提交
572
		return -EINVAL;
L
Linus Torvalds 已提交
573 574
	if (nb == mp->m_sb.sb_logblocks &&
	    in->isint == (mp->m_sb.sb_logstart != 0))
D
Dave Chinner 已提交
575
		return -EINVAL;
L
Linus Torvalds 已提交
576 577 578 579 580 581
	/*
	 * 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.
	 */
D
Dave Chinner 已提交
582
	return -ENOSYS;
L
Linus Torvalds 已提交
583 584 585 586 587 588 589 590 591 592 593 594 595 596 597
}

/*
 * 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;
598 599

	if (!capable(CAP_SYS_ADMIN))
D
Dave Chinner 已提交
600
		return -EPERM;
601
	if (!mutex_trylock(&mp->m_growlock))
D
Dave Chinner 已提交
602
		return -EWOULDBLOCK;
L
Linus Torvalds 已提交
603
	error = xfs_growfs_data_private(mp, in);
604
	mutex_unlock(&mp->m_growlock);
L
Linus Torvalds 已提交
605 606 607 608 609 610 611 612 613
	return error;
}

int
xfs_growfs_log(
	xfs_mount_t		*mp,
	xfs_growfs_log_t	*in)
{
	int error;
614 615

	if (!capable(CAP_SYS_ADMIN))
D
Dave Chinner 已提交
616
		return -EPERM;
617
	if (!mutex_trylock(&mp->m_growlock))
D
Dave Chinner 已提交
618
		return -EWOULDBLOCK;
L
Linus Torvalds 已提交
619
	error = xfs_growfs_log_private(mp, in);
620
	mutex_unlock(&mp->m_growlock);
L
Linus Torvalds 已提交
621 622 623 624 625 626 627 628 629 630 631 632
	return error;
}

/*
 * exported through ioctl XFS_IOC_FSCOUNTS
 */

int
xfs_fs_counts(
	xfs_mount_t		*mp,
	xfs_fsop_counts_t	*cnt)
{
633
	xfs_icsb_sync_counters(mp, XFS_ICSB_LAZY_COUNT);
E
Eric Sandeen 已提交
634
	spin_lock(&mp->m_sb_lock);
635
	cnt->freedata = mp->m_sb.sb_fdblocks - XFS_ALLOC_SET_ASIDE(mp);
L
Linus Torvalds 已提交
636 637 638
	cnt->freertx = mp->m_sb.sb_frextents;
	cnt->freeino = mp->m_sb.sb_ifree;
	cnt->allocino = mp->m_sb.sb_icount;
E
Eric Sandeen 已提交
639
	spin_unlock(&mp->m_sb_lock);
L
Linus Torvalds 已提交
640 641 642 643 644 645 646 647
	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
648
 * is kept in m_resblks_avail.
L
Linus Torvalds 已提交
649 650 651 652 653 654 655 656 657 658 659 660 661 662 663
 *
 * 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)
{
664
	__int64_t		lcounter, delta, fdblks_delta;
L
Linus Torvalds 已提交
665 666 667 668
	__uint64_t		request;

	/* If inval is null, report current values and return */
	if (inval == (__uint64_t *)NULL) {
669
		if (!outval)
D
Dave Chinner 已提交
670
			return -EINVAL;
L
Linus Torvalds 已提交
671 672
		outval->resblks = mp->m_resblks;
		outval->resblks_avail = mp->m_resblks_avail;
673
		return 0;
L
Linus Torvalds 已提交
674 675 676
	}

	request = *inval;
677 678 679 680 681 682

	/*
	 * 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 已提交
683
	 * We do this under the m_sb_lock so that if we are near
684 685 686 687 688 689 690 691 692 693
	 * 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 已提交
694
	spin_lock(&mp->m_sb_lock);
695
	xfs_icsb_sync_counters_locked(mp, 0);
L
Linus Torvalds 已提交
696 697 698 699 700

	/*
	 * If our previous reservation was larger than the current value,
	 * then move any unused blocks back to the free pool.
	 */
701
	fdblks_delta = 0;
L
Linus Torvalds 已提交
702 703 704
	if (mp->m_resblks > request) {
		lcounter = mp->m_resblks_avail - request;
		if (lcounter  > 0) {		/* release unused blocks */
705
			fdblks_delta = lcounter;
L
Linus Torvalds 已提交
706 707 708 709
			mp->m_resblks_avail -= lcounter;
		}
		mp->m_resblks = request;
	} else {
710 711 712
		__int64_t	free;

		free =  mp->m_sb.sb_fdblocks - XFS_ALLOC_SET_ASIDE(mp);
713 714 715
		if (!free)
			goto out; /* ENOSPC and fdblks_delta = 0 */

L
Linus Torvalds 已提交
716
		delta = request - mp->m_resblks;
717
		lcounter = free - delta;
L
Linus Torvalds 已提交
718 719
		if (lcounter < 0) {
			/* We can't satisfy the request, just get what we can */
720 721
			mp->m_resblks += free;
			mp->m_resblks_avail += free;
722
			fdblks_delta = -free;
L
Linus Torvalds 已提交
723
		} else {
724
			fdblks_delta = -delta;
L
Linus Torvalds 已提交
725 726 727 728
			mp->m_resblks = request;
			mp->m_resblks_avail += delta;
		}
	}
729
out:
730 731 732 733
	if (outval) {
		outval->resblks = mp->m_resblks;
		outval->resblks_avail = mp->m_resblks_avail;
	}
E
Eric Sandeen 已提交
734
	spin_unlock(&mp->m_sb_lock);
735 736 737 738

	if (fdblks_delta) {
		/*
		 * If we are putting blocks back here, m_resblks_avail is
M
Malcolm Parsons 已提交
739
		 * already at its max so this will put it in the free pool.
740 741 742 743 744 745 746 747 748 749 750
		 *
		 * 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;
751 752
		error = xfs_icsb_modify_counters(mp, XFS_SBS_FDBLOCKS,
						 fdblks_delta, 0);
D
Dave Chinner 已提交
753
		if (error == -ENOSPC)
754 755
			goto retry;
	}
756
	return 0;
L
Linus Torvalds 已提交
757 758 759 760 761 762 763 764 765
}

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

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

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

	return 0;
}
788 789 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

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