xfs_fsops.c 18.3 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
#include "xfs_types.h"
21
#include "xfs_bit.h"
L
Linus Torvalds 已提交
22 23 24 25
#include "xfs_inum.h"
#include "xfs_log.h"
#include "xfs_trans.h"
#include "xfs_sb.h"
26 27
#include "xfs_ag.h"
#include "xfs_dir2.h"
L
Linus Torvalds 已提交
28 29 30
#include "xfs_dmapi.h"
#include "xfs_mount.h"
#include "xfs_bmap_btree.h"
31
#include "xfs_alloc_btree.h"
L
Linus Torvalds 已提交
32
#include "xfs_ialloc_btree.h"
33 34 35 36 37
#include "xfs_dir2_sf.h"
#include "xfs_attr_sf.h"
#include "xfs_dinode.h"
#include "xfs_inode.h"
#include "xfs_inode_item.h"
L
Linus Torvalds 已提交
38 39 40 41 42 43 44 45
#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"
46
#include "xfs_rw.h"
47
#include "xfs_filestream.h"
L
Linus Torvalds 已提交
48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79

/*
 * File system operations
 */

int
xfs_fs_geometry(
	xfs_mount_t		*mp,
	xfs_fsop_geom_t		*geo,
	int			new_version)
{
	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 =
80
			(xfs_sb_version_hasattr(&mp->m_sb) ?
L
Linus Torvalds 已提交
81
				XFS_FSOP_GEOM_FLAGS_ATTR : 0) |
82
			(xfs_sb_version_hasnlink(&mp->m_sb) ?
L
Linus Torvalds 已提交
83
				XFS_FSOP_GEOM_FLAGS_NLINK : 0) |
84
			(xfs_sb_version_hasquota(&mp->m_sb) ?
L
Linus Torvalds 已提交
85
				XFS_FSOP_GEOM_FLAGS_QUOTA : 0) |
86
			(xfs_sb_version_hasalign(&mp->m_sb) ?
L
Linus Torvalds 已提交
87
				XFS_FSOP_GEOM_FLAGS_IALIGN : 0) |
88
			(xfs_sb_version_hasdalign(&mp->m_sb) ?
L
Linus Torvalds 已提交
89
				XFS_FSOP_GEOM_FLAGS_DALIGN : 0) |
90
			(xfs_sb_version_hasshared(&mp->m_sb) ?
L
Linus Torvalds 已提交
91
				XFS_FSOP_GEOM_FLAGS_SHARED : 0) |
92
			(xfs_sb_version_hasextflgbit(&mp->m_sb) ?
L
Linus Torvalds 已提交
93
				XFS_FSOP_GEOM_FLAGS_EXTFLG : 0) |
94
			(xfs_sb_version_hasdirv2(&mp->m_sb) ?
L
Linus Torvalds 已提交
95
				XFS_FSOP_GEOM_FLAGS_DIRV2 : 0) |
96
			(xfs_sb_version_hassector(&mp->m_sb) ?
97
				XFS_FSOP_GEOM_FLAGS_SECTOR : 0) |
98 99
			(xfs_sb_version_hasasciici(&mp->m_sb) ?
				XFS_FSOP_GEOM_FLAGS_DIRV2CI : 0) |
D
David Chinner 已提交
100 101
			(xfs_sb_version_haslazysbcount(&mp->m_sb) ?
				XFS_FSOP_GEOM_FLAGS_LAZYSB : 0) |
102
			(xfs_sb_version_hasattr2(&mp->m_sb) ?
103
				XFS_FSOP_GEOM_FLAGS_ATTR2 : 0);
104
		geo->logsectsize = xfs_sb_version_hassector(&mp->m_sb) ?
L
Linus Torvalds 已提交
105 106 107 108 109 110
				mp->m_sb.sb_logsectsize : BBSIZE;
		geo->rtsectsize = mp->m_sb.sb_blocksize;
		geo->dirblocksize = mp->m_dirblksize;
	}
	if (new_version >= 4) {
		geo->flags |=
111
			(xfs_sb_version_haslogv2(&mp->m_sb) ?
L
Linus Torvalds 已提交
112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128
				XFS_FSOP_GEOM_FLAGS_LOGV2 : 0);
		geo->logsunit = mp->m_sb.sb_logsunit;
	}
	return 0;
}

static int
xfs_growfs_data_private(
	xfs_mount_t		*mp,		/* mount point for filesystem */
	xfs_growfs_data_t	*in)		/* growfs data input struct */
{
	xfs_agf_t		*agf;
	xfs_agi_t		*agi;
	xfs_agnumber_t		agno;
	xfs_extlen_t		agsize;
	xfs_extlen_t		tmpsize;
	xfs_alloc_rec_t		*arec;
129
	struct xfs_btree_block	*block;
L
Linus Torvalds 已提交
130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146
	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);
147 148
	if ((error = xfs_sb_validate_fsb_count(&mp->m_sb, nb)))
		return error;
L
Linus Torvalds 已提交
149 150 151 152 153 154 155 156 157 158 159 160 161 162
	dpct = pct - mp->m_sb.sb_imax_pct;
	error = xfs_read_buf(mp, mp->m_ddev_targp,
			XFS_FSB_TO_BB(mp, nb) - XFS_FSS_TO_BB(mp, 1),
			XFS_FSS_TO_BB(mp, 1), 0, &bp);
	if (error)
		return error;
	ASSERT(bp);
	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--;
163
		nb = (xfs_rfsblock_t)nagcount * mp->m_sb.sb_agblocks;
L
Linus Torvalds 已提交
164 165 166 167 168 169
		if (nb < mp->m_sb.sb_dblocks)
			return XFS_ERROR(EINVAL);
	}
	new = nb - mp->m_sb.sb_dblocks;
	oagcount = mp->m_sb.sb_agcount;
	if (nagcount > oagcount) {
170 171
		void *new_perag, *old_perag;

172
		xfs_filestream_flush(mp);
173 174 175 176 177 178

		new_perag = kmem_zalloc(sizeof(xfs_perag_t) * nagcount,
					KM_MAYFAIL);
		if (!new_perag)
			return XFS_ERROR(ENOMEM);

L
Linus Torvalds 已提交
179
		down_write(&mp->m_peraglock);
180 181 182 183
		memcpy(new_perag, mp->m_perag, sizeof(xfs_perag_t) * oagcount);
		old_perag = mp->m_perag;
		mp->m_perag = new_perag;

L
Linus Torvalds 已提交
184
		mp->m_flags |= XFS_MOUNT_32BITINODES;
C
Christoph Hellwig 已提交
185
		nagimax = xfs_initialize_perag(mp, nagcount);
L
Linus Torvalds 已提交
186
		up_write(&mp->m_peraglock);
187 188

		kmem_free(old_perag);
L
Linus Torvalds 已提交
189 190
	}
	tp = xfs_trans_alloc(mp, XFS_TRANS_GROWFS);
191
	tp->t_flags |= XFS_TRANS_RESERVE;
L
Linus Torvalds 已提交
192 193 194 195 196 197 198 199 200 201 202 203
	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;
	}

	nfree = 0;
	for (agno = nagcount - 1; agno >= oagcount; agno--, new -= agsize) {
		/*
		 * AG freelist header block
		 */
		bp = xfs_buf_get(mp->m_ddev_targp,
204 205
				 XFS_AG_DADDR(mp, agno, XFS_AGF_DADDR(mp)),
				 XFS_FSS_TO_BB(mp, 1), XBF_LOCK | XBF_MAPPED);
L
Linus Torvalds 已提交
206 207
		agf = XFS_BUF_TO_AGF(bp);
		memset(agf, 0, mp->m_sb.sb_sectsize);
208 209 210
		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 已提交
211 212 213 214 215 216
		if (agno == nagcount - 1)
			agsize =
				nb -
				(agno * (xfs_rfsblock_t)mp->m_sb.sb_agblocks);
		else
			agsize = mp->m_sb.sb_agblocks;
217 218 219 220 221
		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 已提交
222
		agf->agf_flfirst = 0;
223
		agf->agf_fllast = cpu_to_be32(XFS_AGFL_SIZE(mp) - 1);
L
Linus Torvalds 已提交
224 225
		agf->agf_flcount = 0;
		tmpsize = agsize - XFS_PREALLOC_BLOCKS(mp);
226 227
		agf->agf_freeblks = cpu_to_be32(tmpsize);
		agf->agf_longest = cpu_to_be32(tmpsize);
L
Linus Torvalds 已提交
228 229 230 231 232 233 234 235
		error = xfs_bwrite(mp, bp);
		if (error) {
			goto error0;
		}
		/*
		 * AG inode header block
		 */
		bp = xfs_buf_get(mp->m_ddev_targp,
236 237
				 XFS_AG_DADDR(mp, agno, XFS_AGI_DADDR(mp)),
				 XFS_FSS_TO_BB(mp, 1), XBF_LOCK | XBF_MAPPED);
L
Linus Torvalds 已提交
238 239
		agi = XFS_BUF_TO_AGI(bp);
		memset(agi, 0, mp->m_sb.sb_sectsize);
240 241 242 243
		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 已提交
244
		agi->agi_count = 0;
245 246
		agi->agi_root = cpu_to_be32(XFS_IBT_BLOCK(mp));
		agi->agi_level = cpu_to_be32(1);
L
Linus Torvalds 已提交
247
		agi->agi_freecount = 0;
248 249
		agi->agi_newino = cpu_to_be32(NULLAGINO);
		agi->agi_dirino = cpu_to_be32(NULLAGINO);
L
Linus Torvalds 已提交
250
		for (bucket = 0; bucket < XFS_AGI_UNLINKED_BUCKETS; bucket++)
251
			agi->agi_unlinked[bucket] = cpu_to_be32(NULLAGINO);
L
Linus Torvalds 已提交
252 253 254 255 256 257 258 259
		error = xfs_bwrite(mp, bp);
		if (error) {
			goto error0;
		}
		/*
		 * BNO btree root block
		 */
		bp = xfs_buf_get(mp->m_ddev_targp,
260 261 262
				 XFS_AGB_TO_DADDR(mp, agno, XFS_BNO_BLOCK(mp)),
				 BTOBB(mp->m_sb.sb_blocksize),
				 XBF_LOCK | XBF_MAPPED);
263
		block = XFS_BUF_TO_BLOCK(bp);
L
Linus Torvalds 已提交
264
		memset(block, 0, mp->m_sb.sb_blocksize);
265
		block->bb_magic = cpu_to_be32(XFS_ABTB_MAGIC);
L
Linus Torvalds 已提交
266
		block->bb_level = 0;
267
		block->bb_numrecs = cpu_to_be16(1);
268 269
		block->bb_u.s.bb_leftsib = cpu_to_be32(NULLAGBLOCK);
		block->bb_u.s.bb_rightsib = cpu_to_be32(NULLAGBLOCK);
270
		arec = XFS_ALLOC_REC_ADDR(mp, block, 1);
271 272 273
		arec->ar_startblock = cpu_to_be32(XFS_PREALLOC_BLOCKS(mp));
		arec->ar_blockcount = cpu_to_be32(
			agsize - be32_to_cpu(arec->ar_startblock));
L
Linus Torvalds 已提交
274 275 276 277 278 279 280 281
		error = xfs_bwrite(mp, bp);
		if (error) {
			goto error0;
		}
		/*
		 * CNT btree root block
		 */
		bp = xfs_buf_get(mp->m_ddev_targp,
282 283 284
				 XFS_AGB_TO_DADDR(mp, agno, XFS_CNT_BLOCK(mp)),
				 BTOBB(mp->m_sb.sb_blocksize),
				 XBF_LOCK | XBF_MAPPED);
285
		block = XFS_BUF_TO_BLOCK(bp);
L
Linus Torvalds 已提交
286
		memset(block, 0, mp->m_sb.sb_blocksize);
287
		block->bb_magic = cpu_to_be32(XFS_ABTC_MAGIC);
L
Linus Torvalds 已提交
288
		block->bb_level = 0;
289
		block->bb_numrecs = cpu_to_be16(1);
290 291
		block->bb_u.s.bb_leftsib = cpu_to_be32(NULLAGBLOCK);
		block->bb_u.s.bb_rightsib = cpu_to_be32(NULLAGBLOCK);
292
		arec = XFS_ALLOC_REC_ADDR(mp, block, 1);
293 294 295 296
		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);
L
Linus Torvalds 已提交
297 298 299 300 301 302 303 304
		error = xfs_bwrite(mp, bp);
		if (error) {
			goto error0;
		}
		/*
		 * INO btree root block
		 */
		bp = xfs_buf_get(mp->m_ddev_targp,
305 306 307
				 XFS_AGB_TO_DADDR(mp, agno, XFS_IBT_BLOCK(mp)),
				 BTOBB(mp->m_sb.sb_blocksize),
				 XBF_LOCK | XBF_MAPPED);
308
		block = XFS_BUF_TO_BLOCK(bp);
L
Linus Torvalds 已提交
309
		memset(block, 0, mp->m_sb.sb_blocksize);
310
		block->bb_magic = cpu_to_be32(XFS_IBT_MAGIC);
L
Linus Torvalds 已提交
311 312
		block->bb_level = 0;
		block->bb_numrecs = 0;
313 314
		block->bb_u.s.bb_leftsib = cpu_to_be32(NULLAGBLOCK);
		block->bb_u.s.bb_rightsib = cpu_to_be32(NULLAGBLOCK);
L
Linus Torvalds 已提交
315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333
		error = xfs_bwrite(mp, bp);
		if (error) {
			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);
334
		be32_add_cpu(&agi->agi_length, new);
L
Linus Torvalds 已提交
335
		ASSERT(nagcount == oagcount ||
336
		       be32_to_cpu(agi->agi_length) == mp->m_sb.sb_agblocks);
L
Linus Torvalds 已提交
337 338 339 340 341 342 343 344 345 346
		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);
347
		be32_add_cpu(&agf->agf_length, new);
348 349
		ASSERT(be32_to_cpu(agf->agf_length) ==
		       be32_to_cpu(agi->agi_length));
350
		xfs_alloc_log_agf(tp, bp, XFS_AGF_LENGTH);
L
Linus Torvalds 已提交
351 352 353 354
		/*
		 * Free the new space.
		 */
		error = xfs_free_extent(tp, XFS_AGB_TO_FSB(mp, agno,
355
			be32_to_cpu(agf->agf_length) - new), new);
L
Linus Torvalds 已提交
356 357 358 359 360 361 362 363 364 365 366 367 368
		if (error) {
			goto error0;
		}
	}
	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);
369
	error = xfs_trans_commit(tp, 0);
L
Linus Torvalds 已提交
370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391
	if (error) {
		return error;
	}
	/* 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;
	for (agno = 1; agno < nagcount; agno++) {
		error = xfs_read_buf(mp, mp->m_ddev_targp,
				  XFS_AGB_TO_DADDR(mp, agno, XFS_SB_BLOCK(mp)),
				  XFS_FSS_TO_BB(mp, 1), 0, &bp);
		if (error) {
			xfs_fs_cmn_err(CE_WARN, mp,
			"error %d reading secondary superblock for ag %d",
				error, agno);
			break;
		}
392
		xfs_sb_to_disk(XFS_BUF_TO_SBP(bp), &mp->m_sb, XFS_SB_ALL_BITS);
L
Linus Torvalds 已提交
393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448
		/*
		 * If we get an error writing out the alternate superblocks,
		 * just issue a warning and continue.  The real work is
		 * already done and committed.
		 */
		if (!(error = xfs_bwrite(mp, bp))) {
			continue;
		} else {
			xfs_fs_cmn_err(CE_WARN, mp,
		"write error %d updating secondary superblock for ag %d",
				error, agno);
			break; /* no point in continuing */
		}
	}
	return 0;

 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;
449 450 451

	if (!capable(CAP_SYS_ADMIN))
		return XFS_ERROR(EPERM);
452
	if (!mutex_trylock(&mp->m_growlock))
L
Linus Torvalds 已提交
453 454
		return XFS_ERROR(EWOULDBLOCK);
	error = xfs_growfs_data_private(mp, in);
455
	mutex_unlock(&mp->m_growlock);
L
Linus Torvalds 已提交
456 457 458 459 460 461 462 463 464
	return error;
}

int
xfs_growfs_log(
	xfs_mount_t		*mp,
	xfs_growfs_log_t	*in)
{
	int error;
465 466 467

	if (!capable(CAP_SYS_ADMIN))
		return XFS_ERROR(EPERM);
468
	if (!mutex_trylock(&mp->m_growlock))
L
Linus Torvalds 已提交
469 470
		return XFS_ERROR(EWOULDBLOCK);
	error = xfs_growfs_log_private(mp, in);
471
	mutex_unlock(&mp->m_growlock);
L
Linus Torvalds 已提交
472 473 474 475 476 477 478 479 480 481 482 483
	return error;
}

/*
 * exported through ioctl XFS_IOC_FSCOUNTS
 */

int
xfs_fs_counts(
	xfs_mount_t		*mp,
	xfs_fsop_counts_t	*cnt)
{
484
	xfs_icsb_sync_counters(mp, XFS_ICSB_LAZY_COUNT);
E
Eric Sandeen 已提交
485
	spin_lock(&mp->m_sb_lock);
486
	cnt->freedata = mp->m_sb.sb_fdblocks - XFS_ALLOC_SET_ASIDE(mp);
L
Linus Torvalds 已提交
487 488 489
	cnt->freertx = mp->m_sb.sb_frextents;
	cnt->freeino = mp->m_sb.sb_ifree;
	cnt->allocino = mp->m_sb.sb_icount;
E
Eric Sandeen 已提交
490
	spin_unlock(&mp->m_sb_lock);
L
Linus Torvalds 已提交
491 492 493 494 495 496 497 498
	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
499
 * is kept in m_resblks_avail.
L
Linus Torvalds 已提交
500 501 502 503 504 505 506 507 508 509 510 511 512 513 514
 *
 * 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)
{
515
	__int64_t		lcounter, delta, fdblks_delta;
L
Linus Torvalds 已提交
516 517 518 519
	__uint64_t		request;

	/* If inval is null, report current values and return */
	if (inval == (__uint64_t *)NULL) {
520 521
		if (!outval)
			return EINVAL;
L
Linus Torvalds 已提交
522 523
		outval->resblks = mp->m_resblks;
		outval->resblks_avail = mp->m_resblks_avail;
524
		return 0;
L
Linus Torvalds 已提交
525 526 527
	}

	request = *inval;
528 529 530 531 532 533

	/*
	 * 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 已提交
534
	 * We do this under the m_sb_lock so that if we are near
535 536 537 538 539 540 541 542 543 544
	 * 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 已提交
545
	spin_lock(&mp->m_sb_lock);
546
	xfs_icsb_sync_counters_locked(mp, 0);
L
Linus Torvalds 已提交
547 548 549 550 551

	/*
	 * If our previous reservation was larger than the current value,
	 * then move any unused blocks back to the free pool.
	 */
552
	fdblks_delta = 0;
L
Linus Torvalds 已提交
553 554 555
	if (mp->m_resblks > request) {
		lcounter = mp->m_resblks_avail - request;
		if (lcounter  > 0) {		/* release unused blocks */
556
			fdblks_delta = lcounter;
L
Linus Torvalds 已提交
557 558 559 560
			mp->m_resblks_avail -= lcounter;
		}
		mp->m_resblks = request;
	} else {
561 562 563
		__int64_t	free;

		free =  mp->m_sb.sb_fdblocks - XFS_ALLOC_SET_ASIDE(mp);
564 565 566
		if (!free)
			goto out; /* ENOSPC and fdblks_delta = 0 */

L
Linus Torvalds 已提交
567
		delta = request - mp->m_resblks;
568
		lcounter = free - delta;
L
Linus Torvalds 已提交
569 570
		if (lcounter < 0) {
			/* We can't satisfy the request, just get what we can */
571 572
			mp->m_resblks += free;
			mp->m_resblks_avail += free;
573
			fdblks_delta = -free;
L
Linus Torvalds 已提交
574
		} else {
575
			fdblks_delta = -delta;
L
Linus Torvalds 已提交
576 577 578 579
			mp->m_resblks = request;
			mp->m_resblks_avail += delta;
		}
	}
580
out:
581 582 583 584
	if (outval) {
		outval->resblks = mp->m_resblks;
		outval->resblks_avail = mp->m_resblks_avail;
	}
E
Eric Sandeen 已提交
585
	spin_unlock(&mp->m_sb_lock);
586 587 588 589

	if (fdblks_delta) {
		/*
		 * If we are putting blocks back here, m_resblks_avail is
M
Malcolm Parsons 已提交
590
		 * already at its max so this will put it in the free pool.
591 592 593 594 595 596 597 598 599 600 601 602 603 604 605
		 *
		 * 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;
		error = xfs_mod_incore_sb(mp, XFS_SBS_FDBLOCKS, fdblks_delta, 0);
		if (error == ENOSPC)
			goto retry;
	}
606
	return 0;
L
Linus Torvalds 已提交
607 608
}

609
int
610 611
xfs_fs_log_dummy(
	xfs_mount_t	*mp)
612
{
613 614
	xfs_trans_t	*tp;
	xfs_inode_t	*ip;
615
	int		error;
616

617
	tp = _xfs_trans_alloc(mp, XFS_TRANS_DUMMY1, KM_SLEEP);
618 619
	error = xfs_trans_reserve(tp, 0, XFS_ICHANGE_LOG_RES(mp), 0, 0, 0);
	if (error) {
620
		xfs_trans_cancel(tp, 0);
621
		return error;
622 623 624 625 626 627 628 629 630
	}

	ip = mp->m_rootip;
	xfs_ilock(ip, XFS_ILOCK_EXCL);

	xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
	xfs_trans_ihold(tp, ip);
	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
	xfs_trans_set_sync(tp);
631
	error = xfs_trans_commit(tp, 0);
632 633

	xfs_iunlock(ip, XFS_ILOCK_EXCL);
634
	return error;
635 636
}

L
Linus Torvalds 已提交
637 638 639 640 641 642 643
int
xfs_fs_goingdown(
	xfs_mount_t	*mp,
	__uint32_t	inflags)
{
	switch (inflags) {
	case XFS_FSOP_GOING_FLAGS_DEFAULT: {
C
Christoph Hellwig 已提交
644
		struct super_block *sb = freeze_bdev(mp->m_super->s_bdev);
L
Linus Torvalds 已提交
645

646
		if (sb && !IS_ERR(sb)) {
647
			xfs_force_shutdown(mp, SHUTDOWN_FORCE_UMOUNT);
L
Linus Torvalds 已提交
648 649
			thaw_bdev(sb->s_bdev, sb);
		}
650

L
Linus Torvalds 已提交
651 652 653
		break;
	}
	case XFS_FSOP_GOING_FLAGS_LOGFLUSH:
654
		xfs_force_shutdown(mp, SHUTDOWN_FORCE_UMOUNT);
L
Linus Torvalds 已提交
655 656
		break;
	case XFS_FSOP_GOING_FLAGS_NOLOGFLUSH:
657 658
		xfs_force_shutdown(mp,
				SHUTDOWN_FORCE_UMOUNT | SHUTDOWN_LOG_IO_ERROR);
L
Linus Torvalds 已提交
659 660 661 662 663 664 665
		break;
	default:
		return XFS_ERROR(EINVAL);
	}

	return 0;
}