xref: /openbmc/linux/fs/xfs/xfs_fsops.c (revision 64c70b1c)
1 /*
2  * Copyright (c) 2000-2005 Silicon Graphics, Inc.
3  * All Rights Reserved.
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License as
7  * published by the Free Software Foundation.
8  *
9  * This program is distributed in the hope that it would be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write the Free Software Foundation,
16  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
17  */
18 #include "xfs.h"
19 #include "xfs_fs.h"
20 #include "xfs_types.h"
21 #include "xfs_bit.h"
22 #include "xfs_inum.h"
23 #include "xfs_log.h"
24 #include "xfs_trans.h"
25 #include "xfs_sb.h"
26 #include "xfs_ag.h"
27 #include "xfs_dir2.h"
28 #include "xfs_dmapi.h"
29 #include "xfs_mount.h"
30 #include "xfs_bmap_btree.h"
31 #include "xfs_alloc_btree.h"
32 #include "xfs_ialloc_btree.h"
33 #include "xfs_dir2_sf.h"
34 #include "xfs_attr_sf.h"
35 #include "xfs_dinode.h"
36 #include "xfs_inode.h"
37 #include "xfs_inode_item.h"
38 #include "xfs_btree.h"
39 #include "xfs_error.h"
40 #include "xfs_alloc.h"
41 #include "xfs_ialloc.h"
42 #include "xfs_fsops.h"
43 #include "xfs_itable.h"
44 #include "xfs_trans_space.h"
45 #include "xfs_rtalloc.h"
46 #include "xfs_rw.h"
47 
48 /*
49  * File system operations
50  */
51 
52 int
53 xfs_fs_geometry(
54 	xfs_mount_t		*mp,
55 	xfs_fsop_geom_t		*geo,
56 	int			new_version)
57 {
58 	geo->blocksize = mp->m_sb.sb_blocksize;
59 	geo->rtextsize = mp->m_sb.sb_rextsize;
60 	geo->agblocks = mp->m_sb.sb_agblocks;
61 	geo->agcount = mp->m_sb.sb_agcount;
62 	geo->logblocks = mp->m_sb.sb_logblocks;
63 	geo->sectsize = mp->m_sb.sb_sectsize;
64 	geo->inodesize = mp->m_sb.sb_inodesize;
65 	geo->imaxpct = mp->m_sb.sb_imax_pct;
66 	geo->datablocks = mp->m_sb.sb_dblocks;
67 	geo->rtblocks = mp->m_sb.sb_rblocks;
68 	geo->rtextents = mp->m_sb.sb_rextents;
69 	geo->logstart = mp->m_sb.sb_logstart;
70 	ASSERT(sizeof(geo->uuid)==sizeof(mp->m_sb.sb_uuid));
71 	memcpy(geo->uuid, &mp->m_sb.sb_uuid, sizeof(mp->m_sb.sb_uuid));
72 	if (new_version >= 2) {
73 		geo->sunit = mp->m_sb.sb_unit;
74 		geo->swidth = mp->m_sb.sb_width;
75 	}
76 	if (new_version >= 3) {
77 		geo->version = XFS_FSOP_GEOM_VERSION;
78 		geo->flags =
79 			(XFS_SB_VERSION_HASATTR(&mp->m_sb) ?
80 				XFS_FSOP_GEOM_FLAGS_ATTR : 0) |
81 			(XFS_SB_VERSION_HASNLINK(&mp->m_sb) ?
82 				XFS_FSOP_GEOM_FLAGS_NLINK : 0) |
83 			(XFS_SB_VERSION_HASQUOTA(&mp->m_sb) ?
84 				XFS_FSOP_GEOM_FLAGS_QUOTA : 0) |
85 			(XFS_SB_VERSION_HASALIGN(&mp->m_sb) ?
86 				XFS_FSOP_GEOM_FLAGS_IALIGN : 0) |
87 			(XFS_SB_VERSION_HASDALIGN(&mp->m_sb) ?
88 				XFS_FSOP_GEOM_FLAGS_DALIGN : 0) |
89 			(XFS_SB_VERSION_HASSHARED(&mp->m_sb) ?
90 				XFS_FSOP_GEOM_FLAGS_SHARED : 0) |
91 			(XFS_SB_VERSION_HASEXTFLGBIT(&mp->m_sb) ?
92 				XFS_FSOP_GEOM_FLAGS_EXTFLG : 0) |
93 			(XFS_SB_VERSION_HASDIRV2(&mp->m_sb) ?
94 				XFS_FSOP_GEOM_FLAGS_DIRV2 : 0) |
95 			(XFS_SB_VERSION_HASSECTOR(&mp->m_sb) ?
96 				XFS_FSOP_GEOM_FLAGS_SECTOR : 0) |
97 			(XFS_SB_VERSION_HASATTR2(&mp->m_sb) ?
98 				XFS_FSOP_GEOM_FLAGS_ATTR2 : 0);
99 		geo->logsectsize = XFS_SB_VERSION_HASSECTOR(&mp->m_sb) ?
100 				mp->m_sb.sb_logsectsize : BBSIZE;
101 		geo->rtsectsize = mp->m_sb.sb_blocksize;
102 		geo->dirblocksize = mp->m_dirblksize;
103 	}
104 	if (new_version >= 4) {
105 		geo->flags |=
106 			(XFS_SB_VERSION_HASLOGV2(&mp->m_sb) ?
107 				XFS_FSOP_GEOM_FLAGS_LOGV2 : 0);
108 		geo->logsunit = mp->m_sb.sb_logsunit;
109 	}
110 	return 0;
111 }
112 
113 static int
114 xfs_growfs_data_private(
115 	xfs_mount_t		*mp,		/* mount point for filesystem */
116 	xfs_growfs_data_t	*in)		/* growfs data input struct */
117 {
118 	xfs_agf_t		*agf;
119 	xfs_agi_t		*agi;
120 	xfs_agnumber_t		agno;
121 	xfs_extlen_t		agsize;
122 	xfs_extlen_t		tmpsize;
123 	xfs_alloc_rec_t		*arec;
124 	xfs_btree_sblock_t	*block;
125 	xfs_buf_t		*bp;
126 	int			bucket;
127 	int			dpct;
128 	int			error;
129 	xfs_agnumber_t		nagcount;
130 	xfs_agnumber_t		nagimax = 0;
131 	xfs_rfsblock_t		nb, nb_mod;
132 	xfs_rfsblock_t		new;
133 	xfs_rfsblock_t		nfree;
134 	xfs_agnumber_t		oagcount;
135 	int			pct;
136 	xfs_sb_t		*sbp;
137 	xfs_trans_t		*tp;
138 
139 	nb = in->newblocks;
140 	pct = in->imaxpct;
141 	if (nb < mp->m_sb.sb_dblocks || pct < 0 || pct > 100)
142 		return XFS_ERROR(EINVAL);
143 	dpct = pct - mp->m_sb.sb_imax_pct;
144 	error = xfs_read_buf(mp, mp->m_ddev_targp,
145 			XFS_FSB_TO_BB(mp, nb) - XFS_FSS_TO_BB(mp, 1),
146 			XFS_FSS_TO_BB(mp, 1), 0, &bp);
147 	if (error)
148 		return error;
149 	ASSERT(bp);
150 	xfs_buf_relse(bp);
151 
152 	new = nb;	/* use new as a temporary here */
153 	nb_mod = do_div(new, mp->m_sb.sb_agblocks);
154 	nagcount = new + (nb_mod != 0);
155 	if (nb_mod && nb_mod < XFS_MIN_AG_BLOCKS) {
156 		nagcount--;
157 		nb = nagcount * mp->m_sb.sb_agblocks;
158 		if (nb < mp->m_sb.sb_dblocks)
159 			return XFS_ERROR(EINVAL);
160 	}
161 	new = nb - mp->m_sb.sb_dblocks;
162 	oagcount = mp->m_sb.sb_agcount;
163 	if (nagcount > oagcount) {
164 		down_write(&mp->m_peraglock);
165 		mp->m_perag = kmem_realloc(mp->m_perag,
166 			sizeof(xfs_perag_t) * nagcount,
167 			sizeof(xfs_perag_t) * oagcount,
168 			KM_SLEEP);
169 		memset(&mp->m_perag[oagcount], 0,
170 			(nagcount - oagcount) * sizeof(xfs_perag_t));
171 		mp->m_flags |= XFS_MOUNT_32BITINODES;
172 		nagimax = xfs_initialize_perag(XFS_MTOVFS(mp), mp, nagcount);
173 		up_write(&mp->m_peraglock);
174 	}
175 	tp = xfs_trans_alloc(mp, XFS_TRANS_GROWFS);
176 	if ((error = xfs_trans_reserve(tp, XFS_GROWFS_SPACE_RES(mp),
177 			XFS_GROWDATA_LOG_RES(mp), 0, 0, 0))) {
178 		xfs_trans_cancel(tp, 0);
179 		return error;
180 	}
181 
182 	nfree = 0;
183 	for (agno = nagcount - 1; agno >= oagcount; agno--, new -= agsize) {
184 		/*
185 		 * AG freelist header block
186 		 */
187 		bp = xfs_buf_get(mp->m_ddev_targp,
188 				  XFS_AG_DADDR(mp, agno, XFS_AGF_DADDR(mp)),
189 				  XFS_FSS_TO_BB(mp, 1), 0);
190 		agf = XFS_BUF_TO_AGF(bp);
191 		memset(agf, 0, mp->m_sb.sb_sectsize);
192 		agf->agf_magicnum = cpu_to_be32(XFS_AGF_MAGIC);
193 		agf->agf_versionnum = cpu_to_be32(XFS_AGF_VERSION);
194 		agf->agf_seqno = cpu_to_be32(agno);
195 		if (agno == nagcount - 1)
196 			agsize =
197 				nb -
198 				(agno * (xfs_rfsblock_t)mp->m_sb.sb_agblocks);
199 		else
200 			agsize = mp->m_sb.sb_agblocks;
201 		agf->agf_length = cpu_to_be32(agsize);
202 		agf->agf_roots[XFS_BTNUM_BNOi] = cpu_to_be32(XFS_BNO_BLOCK(mp));
203 		agf->agf_roots[XFS_BTNUM_CNTi] = cpu_to_be32(XFS_CNT_BLOCK(mp));
204 		agf->agf_levels[XFS_BTNUM_BNOi] = cpu_to_be32(1);
205 		agf->agf_levels[XFS_BTNUM_CNTi] = cpu_to_be32(1);
206 		agf->agf_flfirst = 0;
207 		agf->agf_fllast = cpu_to_be32(XFS_AGFL_SIZE(mp) - 1);
208 		agf->agf_flcount = 0;
209 		tmpsize = agsize - XFS_PREALLOC_BLOCKS(mp);
210 		agf->agf_freeblks = cpu_to_be32(tmpsize);
211 		agf->agf_longest = cpu_to_be32(tmpsize);
212 		error = xfs_bwrite(mp, bp);
213 		if (error) {
214 			goto error0;
215 		}
216 		/*
217 		 * AG inode header block
218 		 */
219 		bp = xfs_buf_get(mp->m_ddev_targp,
220 				  XFS_AG_DADDR(mp, agno, XFS_AGI_DADDR(mp)),
221 				  XFS_FSS_TO_BB(mp, 1), 0);
222 		agi = XFS_BUF_TO_AGI(bp);
223 		memset(agi, 0, mp->m_sb.sb_sectsize);
224 		agi->agi_magicnum = cpu_to_be32(XFS_AGI_MAGIC);
225 		agi->agi_versionnum = cpu_to_be32(XFS_AGI_VERSION);
226 		agi->agi_seqno = cpu_to_be32(agno);
227 		agi->agi_length = cpu_to_be32(agsize);
228 		agi->agi_count = 0;
229 		agi->agi_root = cpu_to_be32(XFS_IBT_BLOCK(mp));
230 		agi->agi_level = cpu_to_be32(1);
231 		agi->agi_freecount = 0;
232 		agi->agi_newino = cpu_to_be32(NULLAGINO);
233 		agi->agi_dirino = cpu_to_be32(NULLAGINO);
234 		for (bucket = 0; bucket < XFS_AGI_UNLINKED_BUCKETS; bucket++)
235 			agi->agi_unlinked[bucket] = cpu_to_be32(NULLAGINO);
236 		error = xfs_bwrite(mp, bp);
237 		if (error) {
238 			goto error0;
239 		}
240 		/*
241 		 * BNO btree root block
242 		 */
243 		bp = xfs_buf_get(mp->m_ddev_targp,
244 			XFS_AGB_TO_DADDR(mp, agno, XFS_BNO_BLOCK(mp)),
245 			BTOBB(mp->m_sb.sb_blocksize), 0);
246 		block = XFS_BUF_TO_SBLOCK(bp);
247 		memset(block, 0, mp->m_sb.sb_blocksize);
248 		block->bb_magic = cpu_to_be32(XFS_ABTB_MAGIC);
249 		block->bb_level = 0;
250 		block->bb_numrecs = cpu_to_be16(1);
251 		block->bb_leftsib = cpu_to_be32(NULLAGBLOCK);
252 		block->bb_rightsib = cpu_to_be32(NULLAGBLOCK);
253 		arec = XFS_BTREE_REC_ADDR(xfs_alloc, block, 1);
254 		arec->ar_startblock = cpu_to_be32(XFS_PREALLOC_BLOCKS(mp));
255 		arec->ar_blockcount = cpu_to_be32(
256 			agsize - be32_to_cpu(arec->ar_startblock));
257 		error = xfs_bwrite(mp, bp);
258 		if (error) {
259 			goto error0;
260 		}
261 		/*
262 		 * CNT btree root block
263 		 */
264 		bp = xfs_buf_get(mp->m_ddev_targp,
265 			XFS_AGB_TO_DADDR(mp, agno, XFS_CNT_BLOCK(mp)),
266 			BTOBB(mp->m_sb.sb_blocksize), 0);
267 		block = XFS_BUF_TO_SBLOCK(bp);
268 		memset(block, 0, mp->m_sb.sb_blocksize);
269 		block->bb_magic = cpu_to_be32(XFS_ABTC_MAGIC);
270 		block->bb_level = 0;
271 		block->bb_numrecs = cpu_to_be16(1);
272 		block->bb_leftsib = cpu_to_be32(NULLAGBLOCK);
273 		block->bb_rightsib = cpu_to_be32(NULLAGBLOCK);
274 		arec = XFS_BTREE_REC_ADDR(xfs_alloc, block, 1);
275 		arec->ar_startblock = cpu_to_be32(XFS_PREALLOC_BLOCKS(mp));
276 		arec->ar_blockcount = cpu_to_be32(
277 			agsize - be32_to_cpu(arec->ar_startblock));
278 		nfree += be32_to_cpu(arec->ar_blockcount);
279 		error = xfs_bwrite(mp, bp);
280 		if (error) {
281 			goto error0;
282 		}
283 		/*
284 		 * INO btree root block
285 		 */
286 		bp = xfs_buf_get(mp->m_ddev_targp,
287 			XFS_AGB_TO_DADDR(mp, agno, XFS_IBT_BLOCK(mp)),
288 			BTOBB(mp->m_sb.sb_blocksize), 0);
289 		block = XFS_BUF_TO_SBLOCK(bp);
290 		memset(block, 0, mp->m_sb.sb_blocksize);
291 		block->bb_magic = cpu_to_be32(XFS_IBT_MAGIC);
292 		block->bb_level = 0;
293 		block->bb_numrecs = 0;
294 		block->bb_leftsib = cpu_to_be32(NULLAGBLOCK);
295 		block->bb_rightsib = cpu_to_be32(NULLAGBLOCK);
296 		error = xfs_bwrite(mp, bp);
297 		if (error) {
298 			goto error0;
299 		}
300 	}
301 	xfs_trans_agblocks_delta(tp, nfree);
302 	/*
303 	 * There are new blocks in the old last a.g.
304 	 */
305 	if (new) {
306 		/*
307 		 * Change the agi length.
308 		 */
309 		error = xfs_ialloc_read_agi(mp, tp, agno, &bp);
310 		if (error) {
311 			goto error0;
312 		}
313 		ASSERT(bp);
314 		agi = XFS_BUF_TO_AGI(bp);
315 		be32_add(&agi->agi_length, new);
316 		ASSERT(nagcount == oagcount ||
317 		       be32_to_cpu(agi->agi_length) == mp->m_sb.sb_agblocks);
318 		xfs_ialloc_log_agi(tp, bp, XFS_AGI_LENGTH);
319 		/*
320 		 * Change agf length.
321 		 */
322 		error = xfs_alloc_read_agf(mp, tp, agno, 0, &bp);
323 		if (error) {
324 			goto error0;
325 		}
326 		ASSERT(bp);
327 		agf = XFS_BUF_TO_AGF(bp);
328 		be32_add(&agf->agf_length, new);
329 		ASSERT(be32_to_cpu(agf->agf_length) ==
330 		       be32_to_cpu(agi->agi_length));
331 		/*
332 		 * Free the new space.
333 		 */
334 		error = xfs_free_extent(tp, XFS_AGB_TO_FSB(mp, agno,
335 			be32_to_cpu(agf->agf_length) - new), new);
336 		if (error) {
337 			goto error0;
338 		}
339 	}
340 	if (nagcount > oagcount)
341 		xfs_trans_mod_sb(tp, XFS_TRANS_SB_AGCOUNT, nagcount - oagcount);
342 	if (nb > mp->m_sb.sb_dblocks)
343 		xfs_trans_mod_sb(tp, XFS_TRANS_SB_DBLOCKS,
344 				 nb - mp->m_sb.sb_dblocks);
345 	if (nfree)
346 		xfs_trans_mod_sb(tp, XFS_TRANS_SB_FDBLOCKS, nfree);
347 	if (dpct)
348 		xfs_trans_mod_sb(tp, XFS_TRANS_SB_IMAXPCT, dpct);
349 	error = xfs_trans_commit(tp, 0);
350 	if (error) {
351 		return error;
352 	}
353 	/* New allocation groups fully initialized, so update mount struct */
354 	if (nagimax)
355 		mp->m_maxagi = nagimax;
356 	if (mp->m_sb.sb_imax_pct) {
357 		__uint64_t icount = mp->m_sb.sb_dblocks * mp->m_sb.sb_imax_pct;
358 		do_div(icount, 100);
359 		mp->m_maxicount = icount << mp->m_sb.sb_inopblog;
360 	} else
361 		mp->m_maxicount = 0;
362 	for (agno = 1; agno < nagcount; agno++) {
363 		error = xfs_read_buf(mp, mp->m_ddev_targp,
364 				  XFS_AGB_TO_DADDR(mp, agno, XFS_SB_BLOCK(mp)),
365 				  XFS_FSS_TO_BB(mp, 1), 0, &bp);
366 		if (error) {
367 			xfs_fs_cmn_err(CE_WARN, mp,
368 			"error %d reading secondary superblock for ag %d",
369 				error, agno);
370 			break;
371 		}
372 		sbp = XFS_BUF_TO_SBP(bp);
373 		xfs_xlatesb(sbp, &mp->m_sb, -1, XFS_SB_ALL_BITS);
374 		/*
375 		 * If we get an error writing out the alternate superblocks,
376 		 * just issue a warning and continue.  The real work is
377 		 * already done and committed.
378 		 */
379 		if (!(error = xfs_bwrite(mp, bp))) {
380 			continue;
381 		} else {
382 			xfs_fs_cmn_err(CE_WARN, mp,
383 		"write error %d updating secondary superblock for ag %d",
384 				error, agno);
385 			break; /* no point in continuing */
386 		}
387 	}
388 	return 0;
389 
390  error0:
391 	xfs_trans_cancel(tp, XFS_TRANS_ABORT);
392 	return error;
393 }
394 
395 static int
396 xfs_growfs_log_private(
397 	xfs_mount_t		*mp,	/* mount point for filesystem */
398 	xfs_growfs_log_t	*in)	/* growfs log input struct */
399 {
400 	xfs_extlen_t		nb;
401 
402 	nb = in->newblocks;
403 	if (nb < XFS_MIN_LOG_BLOCKS || nb < XFS_B_TO_FSB(mp, XFS_MIN_LOG_BYTES))
404 		return XFS_ERROR(EINVAL);
405 	if (nb == mp->m_sb.sb_logblocks &&
406 	    in->isint == (mp->m_sb.sb_logstart != 0))
407 		return XFS_ERROR(EINVAL);
408 	/*
409 	 * Moving the log is hard, need new interfaces to sync
410 	 * the log first, hold off all activity while moving it.
411 	 * Can have shorter or longer log in the same space,
412 	 * or transform internal to external log or vice versa.
413 	 */
414 	return XFS_ERROR(ENOSYS);
415 }
416 
417 /*
418  * protected versions of growfs function acquire and release locks on the mount
419  * point - exported through ioctls: XFS_IOC_FSGROWFSDATA, XFS_IOC_FSGROWFSLOG,
420  * XFS_IOC_FSGROWFSRT
421  */
422 
423 
424 int
425 xfs_growfs_data(
426 	xfs_mount_t		*mp,
427 	xfs_growfs_data_t	*in)
428 {
429 	int error;
430 	if (!cpsema(&mp->m_growlock))
431 		return XFS_ERROR(EWOULDBLOCK);
432 	error = xfs_growfs_data_private(mp, in);
433 	vsema(&mp->m_growlock);
434 	return error;
435 }
436 
437 int
438 xfs_growfs_log(
439 	xfs_mount_t		*mp,
440 	xfs_growfs_log_t	*in)
441 {
442 	int error;
443 	if (!cpsema(&mp->m_growlock))
444 		return XFS_ERROR(EWOULDBLOCK);
445 	error = xfs_growfs_log_private(mp, in);
446 	vsema(&mp->m_growlock);
447 	return error;
448 }
449 
450 /*
451  * exported through ioctl XFS_IOC_FSCOUNTS
452  */
453 
454 int
455 xfs_fs_counts(
456 	xfs_mount_t		*mp,
457 	xfs_fsop_counts_t	*cnt)
458 {
459 	unsigned long	s;
460 
461 	xfs_icsb_sync_counters_flags(mp, XFS_ICSB_LAZY_COUNT);
462 	s = XFS_SB_LOCK(mp);
463 	cnt->freedata = mp->m_sb.sb_fdblocks - XFS_ALLOC_SET_ASIDE(mp);
464 	cnt->freertx = mp->m_sb.sb_frextents;
465 	cnt->freeino = mp->m_sb.sb_ifree;
466 	cnt->allocino = mp->m_sb.sb_icount;
467 	XFS_SB_UNLOCK(mp, s);
468 	return 0;
469 }
470 
471 /*
472  * exported through ioctl XFS_IOC_SET_RESBLKS & XFS_IOC_GET_RESBLKS
473  *
474  * xfs_reserve_blocks is called to set m_resblks
475  * in the in-core mount table. The number of unused reserved blocks
476  * is kept in m_resblks_avail.
477  *
478  * Reserve the requested number of blocks if available. Otherwise return
479  * as many as possible to satisfy the request. The actual number
480  * reserved are returned in outval
481  *
482  * A null inval pointer indicates that only the current reserved blocks
483  * available  should  be returned no settings are changed.
484  */
485 
486 int
487 xfs_reserve_blocks(
488 	xfs_mount_t             *mp,
489 	__uint64_t              *inval,
490 	xfs_fsop_resblks_t      *outval)
491 {
492 	__int64_t		lcounter, delta, fdblks_delta;
493 	__uint64_t		request;
494 	unsigned long		s;
495 
496 	/* If inval is null, report current values and return */
497 
498 	if (inval == (__uint64_t *)NULL) {
499 		outval->resblks = mp->m_resblks;
500 		outval->resblks_avail = mp->m_resblks_avail;
501 		return 0;
502 	}
503 
504 	request = *inval;
505 
506 	/*
507 	 * With per-cpu counters, this becomes an interesting
508 	 * problem. we needto work out if we are freeing or allocation
509 	 * blocks first, then we can do the modification as necessary.
510 	 *
511 	 * We do this under the XFS_SB_LOCK so that if we are near
512 	 * ENOSPC, we will hold out any changes while we work out
513 	 * what to do. This means that the amount of free space can
514 	 * change while we do this, so we need to retry if we end up
515 	 * trying to reserve more space than is available.
516 	 *
517 	 * We also use the xfs_mod_incore_sb() interface so that we
518 	 * don't have to care about whether per cpu counter are
519 	 * enabled, disabled or even compiled in....
520 	 */
521 retry:
522 	s = XFS_SB_LOCK(mp);
523 	xfs_icsb_sync_counters_flags(mp, XFS_ICSB_SB_LOCKED);
524 
525 	/*
526 	 * If our previous reservation was larger than the current value,
527 	 * then move any unused blocks back to the free pool.
528 	 */
529 	fdblks_delta = 0;
530 	if (mp->m_resblks > request) {
531 		lcounter = mp->m_resblks_avail - request;
532 		if (lcounter  > 0) {		/* release unused blocks */
533 			fdblks_delta = lcounter;
534 			mp->m_resblks_avail -= lcounter;
535 		}
536 		mp->m_resblks = request;
537 	} else {
538 		__int64_t	free;
539 
540 		free =  mp->m_sb.sb_fdblocks - XFS_ALLOC_SET_ASIDE(mp);
541 		if (!free)
542 			goto out; /* ENOSPC and fdblks_delta = 0 */
543 
544 		delta = request - mp->m_resblks;
545 		lcounter = free - delta;
546 		if (lcounter < 0) {
547 			/* We can't satisfy the request, just get what we can */
548 			mp->m_resblks += free;
549 			mp->m_resblks_avail += free;
550 			fdblks_delta = -free;
551 			mp->m_sb.sb_fdblocks = XFS_ALLOC_SET_ASIDE(mp);
552 		} else {
553 			fdblks_delta = -delta;
554 			mp->m_sb.sb_fdblocks =
555 				lcounter + XFS_ALLOC_SET_ASIDE(mp);
556 			mp->m_resblks = request;
557 			mp->m_resblks_avail += delta;
558 		}
559 	}
560 out:
561 	outval->resblks = mp->m_resblks;
562 	outval->resblks_avail = mp->m_resblks_avail;
563 	XFS_SB_UNLOCK(mp, s);
564 
565 	if (fdblks_delta) {
566 		/*
567 		 * If we are putting blocks back here, m_resblks_avail is
568 		 * already at it's max so this will put it in the free pool.
569 		 *
570 		 * If we need space, we'll either succeed in getting it
571 		 * from the free block count or we'll get an enospc. If
572 		 * we get a ENOSPC, it means things changed while we were
573 		 * calculating fdblks_delta and so we should try again to
574 		 * see if there is anything left to reserve.
575 		 *
576 		 * Don't set the reserved flag here - we don't want to reserve
577 		 * the extra reserve blocks from the reserve.....
578 		 */
579 		int error;
580 		error = xfs_mod_incore_sb(mp, XFS_SBS_FDBLOCKS, fdblks_delta, 0);
581 		if (error == ENOSPC)
582 			goto retry;
583 	}
584 
585 	return 0;
586 }
587 
588 void
589 xfs_fs_log_dummy(
590 	xfs_mount_t	*mp)
591 {
592 	xfs_trans_t	*tp;
593 	xfs_inode_t	*ip;
594 
595 	tp = _xfs_trans_alloc(mp, XFS_TRANS_DUMMY1);
596 	if (xfs_trans_reserve(tp, 0, XFS_ICHANGE_LOG_RES(mp), 0, 0, 0)) {
597 		xfs_trans_cancel(tp, 0);
598 		return;
599 	}
600 
601 	ip = mp->m_rootip;
602 	xfs_ilock(ip, XFS_ILOCK_EXCL);
603 
604 	xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
605 	xfs_trans_ihold(tp, ip);
606 	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
607 	xfs_trans_set_sync(tp);
608 	xfs_trans_commit(tp, 0);
609 
610 	xfs_iunlock(ip, XFS_ILOCK_EXCL);
611 }
612 
613 int
614 xfs_fs_goingdown(
615 	xfs_mount_t	*mp,
616 	__uint32_t	inflags)
617 {
618 	switch (inflags) {
619 	case XFS_FSOP_GOING_FLAGS_DEFAULT: {
620 		struct bhv_vfs *vfsp = XFS_MTOVFS(mp);
621 		struct super_block *sb = freeze_bdev(vfsp->vfs_super->s_bdev);
622 
623 		if (sb && !IS_ERR(sb)) {
624 			xfs_force_shutdown(mp, SHUTDOWN_FORCE_UMOUNT);
625 			thaw_bdev(sb->s_bdev, sb);
626 		}
627 
628 		break;
629 	}
630 	case XFS_FSOP_GOING_FLAGS_LOGFLUSH:
631 		xfs_force_shutdown(mp, SHUTDOWN_FORCE_UMOUNT);
632 		break;
633 	case XFS_FSOP_GOING_FLAGS_NOLOGFLUSH:
634 		xfs_force_shutdown(mp,
635 				SHUTDOWN_FORCE_UMOUNT | SHUTDOWN_LOG_IO_ERROR);
636 		break;
637 	default:
638 		return XFS_ERROR(EINVAL);
639 	}
640 
641 	return 0;
642 }
643