xfs_fsops.c 21.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"
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"
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) |
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
				XFS_FSOP_GEOM_FLAGS_LOGV2 : 0);
		geo->logsunit = mp->m_sb.sb_logsunit;
	}
	return 0;
}

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

	return bp;
}

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

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

L
Linus Torvalds 已提交
202
	tp = xfs_trans_alloc(mp, XFS_TRANS_GROWFS);
203
	tp->t_flags |= XFS_TRANS_RESERVE;
L
Linus Torvalds 已提交
204 205 206 207 208 209
	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;
	}

210 211 212 213 214
	/*
	 * 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 已提交
215 216 217
	nfree = 0;
	for (agno = nagcount - 1; agno >= oagcount; agno--, new -= agsize) {
		/*
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 225 226 227
		if (!bp) {
			error = ENOMEM;
			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);
250 251 252
		error = xfs_bwrite(bp);
		xfs_buf_relse(bp);
		if (error)
L
Linus Torvalds 已提交
253
			goto error0;
254

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

		agfl = XFS_BUF_TO_AGFL(bp);
		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 已提交
276 277 278
		/*
		 * AG inode header block
		 */
279 280
		bp = xfs_growfs_get_hdr_buf(mp,
				XFS_AG_DADDR(mp, agno, XFS_AGI_DADDR(mp)),
281 282
				XFS_FSS_TO_BB(mp, 1), 0,
				&xfs_agi_buf_ops);
283 284 285 286
		if (!bp) {
			error = ENOMEM;
			goto error0;
		}
287

L
Linus Torvalds 已提交
288
		agi = XFS_BUF_TO_AGI(bp);
289 290 291 292
		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 已提交
293
		agi->agi_count = 0;
294 295
		agi->agi_root = cpu_to_be32(XFS_IBT_BLOCK(mp));
		agi->agi_level = cpu_to_be32(1);
L
Linus Torvalds 已提交
296
		agi->agi_freecount = 0;
297 298
		agi->agi_newino = cpu_to_be32(NULLAGINO);
		agi->agi_dirino = cpu_to_be32(NULLAGINO);
L
Linus Torvalds 已提交
299
		for (bucket = 0; bucket < XFS_AGI_UNLINKED_BUCKETS; bucket++)
300
			agi->agi_unlinked[bucket] = cpu_to_be32(NULLAGINO);
301 302 303
		error = xfs_bwrite(bp);
		xfs_buf_relse(bp);
		if (error)
L
Linus Torvalds 已提交
304
			goto error0;
305

L
Linus Torvalds 已提交
306 307 308
		/*
		 * BNO btree root block
		 */
309 310
		bp = xfs_growfs_get_hdr_buf(mp,
				XFS_AGB_TO_DADDR(mp, agno, XFS_BNO_BLOCK(mp)),
311 312
				BTOBB(mp->m_sb.sb_blocksize), 0,
				&xfs_allocbt_buf_ops);
313

314 315 316 317
		if (!bp) {
			error = ENOMEM;
			goto error0;
		}
318

319
		xfs_btree_init_block(mp, bp, XFS_ABTB_MAGIC, 0, 1, 0);
320
		arec = XFS_ALLOC_REC_ADDR(mp, XFS_BUF_TO_BLOCK(bp), 1);
321 322 323
		arec->ar_startblock = cpu_to_be32(XFS_PREALLOC_BLOCKS(mp));
		arec->ar_blockcount = cpu_to_be32(
			agsize - be32_to_cpu(arec->ar_startblock));
324

325 326 327
		error = xfs_bwrite(bp);
		xfs_buf_relse(bp);
		if (error)
L
Linus Torvalds 已提交
328
			goto error0;
329

L
Linus Torvalds 已提交
330 331 332
		/*
		 * CNT btree root block
		 */
333 334
		bp = xfs_growfs_get_hdr_buf(mp,
				XFS_AGB_TO_DADDR(mp, agno, XFS_CNT_BLOCK(mp)),
335 336
				BTOBB(mp->m_sb.sb_blocksize), 0,
				&xfs_allocbt_buf_ops);
337 338 339 340
		if (!bp) {
			error = ENOMEM;
			goto error0;
		}
341

342
		xfs_btree_init_block(mp, bp, XFS_ABTC_MAGIC, 0, 1, 0);
343
		arec = XFS_ALLOC_REC_ADDR(mp, XFS_BUF_TO_BLOCK(bp), 1);
344 345 346 347
		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);
348

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

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

366 367
		xfs_btree_init_block(mp, bp, XFS_IBT_MAGIC, 0, 0, 0);

368 369 370
		error = xfs_bwrite(bp);
		xfs_buf_relse(bp);
		if (error)
L
Linus Torvalds 已提交
371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386
			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);
387
		be32_add_cpu(&agi->agi_length, new);
L
Linus Torvalds 已提交
388
		ASSERT(nagcount == oagcount ||
389
		       be32_to_cpu(agi->agi_length) == mp->m_sb.sb_agblocks);
L
Linus Torvalds 已提交
390 391 392 393 394 395 396 397 398 399
		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);
400
		be32_add_cpu(&agf->agf_length, new);
401 402
		ASSERT(be32_to_cpu(agf->agf_length) ==
		       be32_to_cpu(agi->agi_length));
403

404
		xfs_alloc_log_agf(tp, bp, XFS_AGF_LENGTH);
L
Linus Torvalds 已提交
405 406 407 408
		/*
		 * Free the new space.
		 */
		error = xfs_free_extent(tp, XFS_AGB_TO_FSB(mp, agno,
409
			be32_to_cpu(agf->agf_length) - new), new);
L
Linus Torvalds 已提交
410 411 412 413
		if (error) {
			goto error0;
		}
	}
414 415 416 417 418 419

	/*
	 * 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 已提交
420 421 422 423 424 425 426 427 428
	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);
429
	error = xfs_trans_commit(tp, 0);
430
	if (error)
L
Linus Torvalds 已提交
431
		return error;
432

L
Linus Torvalds 已提交
433 434 435 436 437 438 439 440 441
	/* 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;
442
	xfs_set_low_space_thresholds(mp);
443 444

	/* update secondary superblocks. */
L
Linus Torvalds 已提交
445
	for (agno = 1; agno < nagcount; agno++) {
446 447 448 449 450 451 452 453
		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 已提交
454
				  XFS_AGB_TO_DADDR(mp, agno, XFS_SB_BLOCK(mp)),
455
				  XFS_FSS_TO_BB(mp, 1), 0, &bp,
456
				  &xfs_sb_buf_ops);
457 458 459 460
		} 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);
461
			if (bp) {
462
				bp->b_ops = &xfs_sb_buf_ops;
463
				xfs_buf_zero(bp, 0, BBTOB(bp->b_length));
464
			} else
465 466 467
				error = ENOMEM;
		}

L
Linus Torvalds 已提交
468
		if (error) {
469 470
			xfs_warn(mp,
		"error %d reading secondary superblock for ag %d",
L
Linus Torvalds 已提交
471 472 473
				error, agno);
			break;
		}
474
		xfs_sb_to_disk(XFS_BUF_TO_SBP(bp), &mp->m_sb, XFS_SB_ALL_BITS);
475

L
Linus Torvalds 已提交
476 477 478 479 480
		/*
		 * If we get an error writing out the alternate superblocks,
		 * just issue a warning and continue.  The real work is
		 * already done and committed.
		 */
481 482 483
		error = xfs_bwrite(bp);
		xfs_buf_relse(bp);
		if (error) {
484
			xfs_warn(mp,
L
Linus Torvalds 已提交
485 486 487 488 489
		"write error %d updating secondary superblock for ag %d",
				error, agno);
			break; /* no point in continuing */
		}
	}
490
	return error;
L
Linus Torvalds 已提交
491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531

 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;
532 533 534

	if (!capable(CAP_SYS_ADMIN))
		return XFS_ERROR(EPERM);
535
	if (!mutex_trylock(&mp->m_growlock))
L
Linus Torvalds 已提交
536 537
		return XFS_ERROR(EWOULDBLOCK);
	error = xfs_growfs_data_private(mp, in);
538
	mutex_unlock(&mp->m_growlock);
L
Linus Torvalds 已提交
539 540 541 542 543 544 545 546 547
	return error;
}

int
xfs_growfs_log(
	xfs_mount_t		*mp,
	xfs_growfs_log_t	*in)
{
	int error;
548 549 550

	if (!capable(CAP_SYS_ADMIN))
		return XFS_ERROR(EPERM);
551
	if (!mutex_trylock(&mp->m_growlock))
L
Linus Torvalds 已提交
552 553
		return XFS_ERROR(EWOULDBLOCK);
	error = xfs_growfs_log_private(mp, in);
554
	mutex_unlock(&mp->m_growlock);
L
Linus Torvalds 已提交
555 556 557 558 559 560 561 562 563 564 565 566
	return error;
}

/*
 * exported through ioctl XFS_IOC_FSCOUNTS
 */

int
xfs_fs_counts(
	xfs_mount_t		*mp,
	xfs_fsop_counts_t	*cnt)
{
567
	xfs_icsb_sync_counters(mp, XFS_ICSB_LAZY_COUNT);
E
Eric Sandeen 已提交
568
	spin_lock(&mp->m_sb_lock);
569
	cnt->freedata = mp->m_sb.sb_fdblocks - XFS_ALLOC_SET_ASIDE(mp);
L
Linus Torvalds 已提交
570 571 572
	cnt->freertx = mp->m_sb.sb_frextents;
	cnt->freeino = mp->m_sb.sb_ifree;
	cnt->allocino = mp->m_sb.sb_icount;
E
Eric Sandeen 已提交
573
	spin_unlock(&mp->m_sb_lock);
L
Linus Torvalds 已提交
574 575 576 577 578 579 580 581
	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
582
 * is kept in m_resblks_avail.
L
Linus Torvalds 已提交
583 584 585 586 587 588 589 590 591 592 593 594 595 596 597
 *
 * 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)
{
598
	__int64_t		lcounter, delta, fdblks_delta;
L
Linus Torvalds 已提交
599 600 601 602
	__uint64_t		request;

	/* If inval is null, report current values and return */
	if (inval == (__uint64_t *)NULL) {
603 604
		if (!outval)
			return EINVAL;
L
Linus Torvalds 已提交
605 606
		outval->resblks = mp->m_resblks;
		outval->resblks_avail = mp->m_resblks_avail;
607
		return 0;
L
Linus Torvalds 已提交
608 609 610
	}

	request = *inval;
611 612 613 614 615 616

	/*
	 * 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 已提交
617
	 * We do this under the m_sb_lock so that if we are near
618 619 620 621 622 623 624 625 626 627
	 * 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 已提交
628
	spin_lock(&mp->m_sb_lock);
629
	xfs_icsb_sync_counters_locked(mp, 0);
L
Linus Torvalds 已提交
630 631 632 633 634

	/*
	 * If our previous reservation was larger than the current value,
	 * then move any unused blocks back to the free pool.
	 */
635
	fdblks_delta = 0;
L
Linus Torvalds 已提交
636 637 638
	if (mp->m_resblks > request) {
		lcounter = mp->m_resblks_avail - request;
		if (lcounter  > 0) {		/* release unused blocks */
639
			fdblks_delta = lcounter;
L
Linus Torvalds 已提交
640 641 642 643
			mp->m_resblks_avail -= lcounter;
		}
		mp->m_resblks = request;
	} else {
644 645 646
		__int64_t	free;

		free =  mp->m_sb.sb_fdblocks - XFS_ALLOC_SET_ASIDE(mp);
647 648 649
		if (!free)
			goto out; /* ENOSPC and fdblks_delta = 0 */

L
Linus Torvalds 已提交
650
		delta = request - mp->m_resblks;
651
		lcounter = free - delta;
L
Linus Torvalds 已提交
652 653
		if (lcounter < 0) {
			/* We can't satisfy the request, just get what we can */
654 655
			mp->m_resblks += free;
			mp->m_resblks_avail += free;
656
			fdblks_delta = -free;
L
Linus Torvalds 已提交
657
		} else {
658
			fdblks_delta = -delta;
L
Linus Torvalds 已提交
659 660 661 662
			mp->m_resblks = request;
			mp->m_resblks_avail += delta;
		}
	}
663
out:
664 665 666 667
	if (outval) {
		outval->resblks = mp->m_resblks;
		outval->resblks_avail = mp->m_resblks_avail;
	}
E
Eric Sandeen 已提交
668
	spin_unlock(&mp->m_sb_lock);
669 670 671 672

	if (fdblks_delta) {
		/*
		 * If we are putting blocks back here, m_resblks_avail is
M
Malcolm Parsons 已提交
673
		 * already at its max so this will put it in the free pool.
674 675 676 677 678 679 680 681 682 683 684
		 *
		 * 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;
685 686
		error = xfs_icsb_modify_counters(mp, XFS_SBS_FDBLOCKS,
						 fdblks_delta, 0);
687 688 689
		if (error == ENOSPC)
			goto retry;
	}
690
	return 0;
L
Linus Torvalds 已提交
691 692
}

693 694 695 696 697 698 699
/*
 * 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
700 701 702
 * 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.
703
 */
704
int
705
xfs_fs_log_dummy(
706
	xfs_mount_t	*mp)
707
{
708
	xfs_trans_t	*tp;
709
	int		error;
710

711
	tp = _xfs_trans_alloc(mp, XFS_TRANS_DUMMY1, KM_SLEEP);
712 713
	error = xfs_trans_reserve(tp, 0, XFS_SB_LOG_RES(mp), 0, 0,
				  XFS_DEFAULT_LOG_COUNT);
714
	if (error) {
715
		xfs_trans_cancel(tp, 0);
716
		return error;
717 718
	}

719 720
	/* log the UUID because it is an unchanging field */
	xfs_mod_sb(tp, XFS_SB_UUID);
721
	xfs_trans_set_sync(tp);
722
	return xfs_trans_commit(tp, 0);
723 724
}

L
Linus Torvalds 已提交
725 726 727 728 729 730 731
int
xfs_fs_goingdown(
	xfs_mount_t	*mp,
	__uint32_t	inflags)
{
	switch (inflags) {
	case XFS_FSOP_GOING_FLAGS_DEFAULT: {
732
		struct super_block *sb = freeze_bdev(mp->m_super->s_bdev);
L
Linus Torvalds 已提交
733

734
		if (sb && !IS_ERR(sb)) {
735
			xfs_force_shutdown(mp, SHUTDOWN_FORCE_UMOUNT);
L
Linus Torvalds 已提交
736 737
			thaw_bdev(sb->s_bdev, sb);
		}
738

L
Linus Torvalds 已提交
739 740 741
		break;
	}
	case XFS_FSOP_GOING_FLAGS_LOGFLUSH:
742
		xfs_force_shutdown(mp, SHUTDOWN_FORCE_UMOUNT);
L
Linus Torvalds 已提交
743 744
		break;
	case XFS_FSOP_GOING_FLAGS_NOLOGFLUSH:
745 746
		xfs_force_shutdown(mp,
				SHUTDOWN_FORCE_UMOUNT | SHUTDOWN_LOG_IO_ERROR);
L
Linus Torvalds 已提交
747 748 749 750 751 752 753
		break;
	default:
		return XFS_ERROR(EINVAL);
	}

	return 0;
}
754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 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

/*
 * 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)");
	}
}
新手
引导
客服 返回
顶部