xfs_fsops.c 22.4 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
	xfs_trans_set_sync(tp);
492
	error = xfs_trans_commit(tp, 0);
493
	if (error)
L
Linus Torvalds 已提交
494
		return error;
495

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

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

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

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

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

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

	if (!capable(CAP_SYS_ADMIN))
D
Dave Chinner 已提交
601
		return -EPERM;
602
	if (!mutex_trylock(&mp->m_growlock))
D
Dave Chinner 已提交
603
		return -EWOULDBLOCK;
L
Linus Torvalds 已提交
604
	error = xfs_growfs_data_private(mp, in);
605 606 607 608 609 610
	/*
	 * Increment the generation unconditionally, the error could be from
	 * updating the secondary superblocks, in which case the new size
	 * is live already.
	 */
	mp->m_generation++;
611
	mutex_unlock(&mp->m_growlock);
L
Linus Torvalds 已提交
612 613 614 615 616 617 618 619 620
	return error;
}

int
xfs_growfs_log(
	xfs_mount_t		*mp,
	xfs_growfs_log_t	*in)
{
	int error;
621 622

	if (!capable(CAP_SYS_ADMIN))
D
Dave Chinner 已提交
623
		return -EPERM;
624
	if (!mutex_trylock(&mp->m_growlock))
D
Dave Chinner 已提交
625
		return -EWOULDBLOCK;
L
Linus Torvalds 已提交
626
	error = xfs_growfs_log_private(mp, in);
627
	mutex_unlock(&mp->m_growlock);
L
Linus Torvalds 已提交
628 629 630 631 632 633 634 635 636 637 638 639
	return error;
}

/*
 * exported through ioctl XFS_IOC_FSCOUNTS
 */

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

	/* If inval is null, report current values and return */
	if (inval == (__uint64_t *)NULL) {
676
		if (!outval)
D
Dave Chinner 已提交
677
			return -EINVAL;
L
Linus Torvalds 已提交
678 679
		outval->resblks = mp->m_resblks;
		outval->resblks_avail = mp->m_resblks_avail;
680
		return 0;
L
Linus Torvalds 已提交
681 682 683
	}

	request = *inval;
684 685 686 687 688 689

	/*
	 * 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 已提交
690
	 * We do this under the m_sb_lock so that if we are near
691 692 693 694 695 696 697 698 699 700
	 * 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 已提交
701
	spin_lock(&mp->m_sb_lock);
702
	xfs_icsb_sync_counters_locked(mp, 0);
L
Linus Torvalds 已提交
703 704 705 706 707

	/*
	 * If our previous reservation was larger than the current value,
	 * then move any unused blocks back to the free pool.
	 */
708
	fdblks_delta = 0;
L
Linus Torvalds 已提交
709 710 711
	if (mp->m_resblks > request) {
		lcounter = mp->m_resblks_avail - request;
		if (lcounter  > 0) {		/* release unused blocks */
712
			fdblks_delta = lcounter;
L
Linus Torvalds 已提交
713 714 715 716
			mp->m_resblks_avail -= lcounter;
		}
		mp->m_resblks = request;
	} else {
717 718 719
		__int64_t	free;

		free =  mp->m_sb.sb_fdblocks - XFS_ALLOC_SET_ASIDE(mp);
720 721 722
		if (!free)
			goto out; /* ENOSPC and fdblks_delta = 0 */

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

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

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

775
		if (sb && !IS_ERR(sb)) {
776
			xfs_force_shutdown(mp, SHUTDOWN_FORCE_UMOUNT);
L
Linus Torvalds 已提交
777 778
			thaw_bdev(sb->s_bdev, sb);
		}
779

L
Linus Torvalds 已提交
780 781 782
		break;
	}
	case XFS_FSOP_GOING_FLAGS_LOGFLUSH:
783
		xfs_force_shutdown(mp, SHUTDOWN_FORCE_UMOUNT);
L
Linus Torvalds 已提交
784 785
		break;
	case XFS_FSOP_GOING_FLAGS_NOLOGFLUSH:
786 787
		xfs_force_shutdown(mp,
				SHUTDOWN_FORCE_UMOUNT | SHUTDOWN_LOG_IO_ERROR);
L
Linus Torvalds 已提交
788 789
		break;
	default:
D
Dave Chinner 已提交
790
		return -EINVAL;
L
Linus Torvalds 已提交
791 792 793 794
	}

	return 0;
}
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 850 851 852 853 854

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