1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright (c) 2000-2005 Silicon Graphics, Inc.
4 * All Rights Reserved.
5 */
6#include "xfs.h"
7#include "xfs_fs.h"
8#include "xfs_shared.h"
9#include "xfs_format.h"
10#include "xfs_log_format.h"
11#include "xfs_trans_resv.h"
12#include "xfs_sb.h"
13#include "xfs_mount.h"
14#include "xfs_trans.h"
15#include "xfs_error.h"
16#include "xfs_alloc.h"
17#include "xfs_fsops.h"
18#include "xfs_trans_space.h"
19#include "xfs_log.h"
20#include "xfs_log_priv.h"
21#include "xfs_ag.h"
22#include "xfs_ag_resv.h"
23#include "xfs_trace.h"
24
25/*
26 * Write new AG headers to disk. Non-transactional, but need to be
27 * written and completed prior to the growfs transaction being logged.
28 * To do this, we use a delayed write buffer list and wait for
29 * submission and IO completion of the list as a whole. This allows the
30 * IO subsystem to merge all the AG headers in a single AG into a single
31 * IO and hide most of the latency of the IO from us.
32 *
33 * This also means that if we get an error whilst building the buffer
34 * list to write, we can cancel the entire list without having written
35 * anything.
36 */
37static int
38xfs_resizefs_init_new_ags(
39	struct xfs_trans	*tp,
40	struct aghdr_init_data	*id,
41	xfs_agnumber_t		oagcount,
42	xfs_agnumber_t		nagcount,
43	xfs_rfsblock_t		delta,
44	struct xfs_perag	*last_pag,
45	bool			*lastag_extended)
46{
47	struct xfs_mount	*mp = tp->t_mountp;
48	xfs_rfsblock_t		nb = mp->m_sb.sb_dblocks + delta;
49	int			error;
50
51	*lastag_extended = false;
52
53	INIT_LIST_HEAD(&id->buffer_list);
54	for (id->agno = nagcount - 1;
55	     id->agno >= oagcount;
56	     id->agno--, delta -= id->agsize) {
57
58		if (id->agno == nagcount - 1)
59			id->agsize = nb - (id->agno *
60					(xfs_rfsblock_t)mp->m_sb.sb_agblocks);
61		else
62			id->agsize = mp->m_sb.sb_agblocks;
63
64		error = xfs_ag_init_headers(mp, id);
65		if (error) {
66			xfs_buf_delwri_cancel(&id->buffer_list);
67			return error;
68		}
69	}
70
71	error = xfs_buf_delwri_submit(&id->buffer_list);
72	if (error)
73		return error;
74
75	if (delta) {
76		*lastag_extended = true;
77		error = xfs_ag_extend_space(last_pag, tp, delta);
78	}
79	return error;
80}
81
82/*
83 * growfs operations
84 */
85static int
86xfs_growfs_data_private(
87	struct xfs_mount	*mp,		/* mount point for filesystem */
88	struct xfs_growfs_data	*in)		/* growfs data input struct */
89{
90	struct xfs_buf		*bp;
91	int			error;
92	xfs_agnumber_t		nagcount;
93	xfs_agnumber_t		nagimax = 0;
94	xfs_rfsblock_t		nb, nb_div, nb_mod;
95	int64_t			delta;
96	bool			lastag_extended = false;
97	xfs_agnumber_t		oagcount;
98	struct xfs_trans	*tp;
99	struct aghdr_init_data	id = {};
100	struct xfs_perag	*last_pag;
101
102	nb = in->newblocks;
103	error = xfs_sb_validate_fsb_count(&mp->m_sb, nb);
104	if (error)
105		return error;
106
107	if (nb > mp->m_sb.sb_dblocks) {
108		error = xfs_buf_read_uncached(mp->m_ddev_targp,
109				XFS_FSB_TO_BB(mp, nb) - XFS_FSS_TO_BB(mp, 1),
110				XFS_FSS_TO_BB(mp, 1), 0, &bp, NULL);
111		if (error)
112			return error;
113		xfs_buf_relse(bp);
114	}
115
116	nb_div = nb;
117	nb_mod = do_div(nb_div, mp->m_sb.sb_agblocks);
118	if (nb_mod && nb_mod >= XFS_MIN_AG_BLOCKS)
119		nb_div++;
120	else if (nb_mod)
121		nb = nb_div * mp->m_sb.sb_agblocks;
122
123	if (nb_div > XFS_MAX_AGNUMBER + 1) {
124		nb_div = XFS_MAX_AGNUMBER + 1;
125		nb = nb_div * mp->m_sb.sb_agblocks;
126	}
127	nagcount = nb_div;
128	delta = nb - mp->m_sb.sb_dblocks;
129	/*
130	 * Reject filesystems with a single AG because they are not
131	 * supported, and reject a shrink operation that would cause a
132	 * filesystem to become unsupported.
133	 */
134	if (delta < 0 && nagcount < 2)
135		return -EINVAL;
136
137	/* No work to do */
138	if (delta == 0)
139		return 0;
140
141	oagcount = mp->m_sb.sb_agcount;
142	/* allocate the new per-ag structures */
143	if (nagcount > oagcount) {
144		error = xfs_initialize_perag(mp, nagcount, nb, &nagimax);
145		if (error)
146			return error;
147	} else if (nagcount < oagcount) {
148		/* TODO: shrinking the entire AGs hasn't yet completed */
149		return -EINVAL;
150	}
151
152	if (delta > 0)
153		error = xfs_trans_alloc(mp, &M_RES(mp)->tr_growdata,
154				XFS_GROWFS_SPACE_RES(mp), 0, XFS_TRANS_RESERVE,
155				&tp);
156	else
157		error = xfs_trans_alloc(mp, &M_RES(mp)->tr_growdata, -delta, 0,
158				0, &tp);
159	if (error)
160		goto out_free_unused_perag;
161
162	last_pag = xfs_perag_get(mp, oagcount - 1);
163	if (delta > 0) {
164		error = xfs_resizefs_init_new_ags(tp, &id, oagcount, nagcount,
165				delta, last_pag, &lastag_extended);
166	} else {
167		xfs_warn_mount(mp, XFS_OPSTATE_WARNED_SHRINK,
168	"EXPERIMENTAL online shrink feature in use. Use at your own risk!");
169
170		error = xfs_ag_shrink_space(last_pag, &tp, -delta);
171	}
172	xfs_perag_put(last_pag);
173	if (error)
174		goto out_trans_cancel;
175
176	/*
177	 * Update changed superblock fields transactionally. These are not
178	 * seen by the rest of the world until the transaction commit applies
179	 * them atomically to the superblock.
180	 */
181	if (nagcount > oagcount)
182		xfs_trans_mod_sb(tp, XFS_TRANS_SB_AGCOUNT, nagcount - oagcount);
183	if (delta)
184		xfs_trans_mod_sb(tp, XFS_TRANS_SB_DBLOCKS, delta);
185	if (id.nfree)
186		xfs_trans_mod_sb(tp, XFS_TRANS_SB_FDBLOCKS, id.nfree);
187
188	/*
189	 * Sync sb counters now to reflect the updated values. This is
190	 * particularly important for shrink because the write verifier
191	 * will fail if sb_fdblocks is ever larger than sb_dblocks.
192	 */
193	if (xfs_has_lazysbcount(mp))
194		xfs_log_sb(tp);
195
196	xfs_trans_set_sync(tp);
197	error = xfs_trans_commit(tp);
198	if (error)
199		return error;
200
201	/* New allocation groups fully initialized, so update mount struct */
202	if (nagimax)
203		mp->m_maxagi = nagimax;
204	xfs_set_low_space_thresholds(mp);
205	mp->m_alloc_set_aside = xfs_alloc_set_aside(mp);
206
207	if (delta > 0) {
208		/*
209		 * If we expanded the last AG, free the per-AG reservation
210		 * so we can reinitialize it with the new size.
211		 */
212		if (lastag_extended) {
213			struct xfs_perag	*pag;
214
215			pag = xfs_perag_get(mp, id.agno);
216			xfs_ag_resv_free(pag);
217			xfs_perag_put(pag);
218		}
219		/*
220		 * Reserve AG metadata blocks. ENOSPC here does not mean there
221		 * was a growfs failure, just that there still isn't space for
222		 * new user data after the grow has been run.
223		 */
224		error = xfs_fs_reserve_ag_blocks(mp);
225		if (error == -ENOSPC)
226			error = 0;
227	}
228	return error;
229
230out_trans_cancel:
231	xfs_trans_cancel(tp);
232out_free_unused_perag:
233	if (nagcount > oagcount)
234		xfs_free_unused_perag_range(mp, oagcount, nagcount);
235	return error;
236}
237
238static int
239xfs_growfs_log_private(
240	struct xfs_mount	*mp,	/* mount point for filesystem */
241	struct xfs_growfs_log	*in)	/* growfs log input struct */
242{
243	xfs_extlen_t		nb;
244
245	nb = in->newblocks;
246	if (nb < XFS_MIN_LOG_BLOCKS || nb < XFS_B_TO_FSB(mp, XFS_MIN_LOG_BYTES))
247		return -EINVAL;
248	if (nb == mp->m_sb.sb_logblocks &&
249	    in->isint == (mp->m_sb.sb_logstart != 0))
250		return -EINVAL;
251	/*
252	 * Moving the log is hard, need new interfaces to sync
253	 * the log first, hold off all activity while moving it.
254	 * Can have shorter or longer log in the same space,
255	 * or transform internal to external log or vice versa.
256	 */
257	return -ENOSYS;
258}
259
260static int
261xfs_growfs_imaxpct(
262	struct xfs_mount	*mp,
263	__u32			imaxpct)
264{
265	struct xfs_trans	*tp;
266	int			dpct;
267	int			error;
268
269	if (imaxpct > 100)
270		return -EINVAL;
271
272	error = xfs_trans_alloc(mp, &M_RES(mp)->tr_growdata,
273			XFS_GROWFS_SPACE_RES(mp), 0, XFS_TRANS_RESERVE, &tp);
274	if (error)
275		return error;
276
277	dpct = imaxpct - mp->m_sb.sb_imax_pct;
278	xfs_trans_mod_sb(tp, XFS_TRANS_SB_IMAXPCT, dpct);
279	xfs_trans_set_sync(tp);
280	return xfs_trans_commit(tp);
281}
282
283/*
284 * protected versions of growfs function acquire and release locks on the mount
285 * point - exported through ioctls: XFS_IOC_FSGROWFSDATA, XFS_IOC_FSGROWFSLOG,
286 * XFS_IOC_FSGROWFSRT
287 */
288int
289xfs_growfs_data(
290	struct xfs_mount	*mp,
291	struct xfs_growfs_data	*in)
292{
293	int			error = 0;
294
295	if (!capable(CAP_SYS_ADMIN))
296		return -EPERM;
297	if (!mutex_trylock(&mp->m_growlock))
298		return -EWOULDBLOCK;
299
300	/* update imaxpct separately to the physical grow of the filesystem */
301	if (in->imaxpct != mp->m_sb.sb_imax_pct) {
302		error = xfs_growfs_imaxpct(mp, in->imaxpct);
303		if (error)
304			goto out_error;
305	}
306
307	if (in->newblocks != mp->m_sb.sb_dblocks) {
308		error = xfs_growfs_data_private(mp, in);
309		if (error)
310			goto out_error;
311	}
312
313	/* Post growfs calculations needed to reflect new state in operations */
314	if (mp->m_sb.sb_imax_pct) {
315		uint64_t icount = mp->m_sb.sb_dblocks * mp->m_sb.sb_imax_pct;
316		do_div(icount, 100);
317		M_IGEO(mp)->maxicount = XFS_FSB_TO_INO(mp, icount);
318	} else
319		M_IGEO(mp)->maxicount = 0;
320
321	/* Update secondary superblocks now the physical grow has completed */
322	error = xfs_update_secondary_sbs(mp);
323
324out_error:
325	/*
326	 * Increment the generation unconditionally, the error could be from
327	 * updating the secondary superblocks, in which case the new size
328	 * is live already.
329	 */
330	mp->m_generation++;
331	mutex_unlock(&mp->m_growlock);
332	return error;
333}
334
335int
336xfs_growfs_log(
337	xfs_mount_t		*mp,
338	struct xfs_growfs_log	*in)
339{
340	int error;
341
342	if (!capable(CAP_SYS_ADMIN))
343		return -EPERM;
344	if (!mutex_trylock(&mp->m_growlock))
345		return -EWOULDBLOCK;
346	error = xfs_growfs_log_private(mp, in);
347	mutex_unlock(&mp->m_growlock);
348	return error;
349}
350
351/*
352 * Reserve the requested number of blocks if available. Otherwise return
353 * as many as possible to satisfy the request. The actual number
354 * reserved are returned in outval.
355 */
356int
357xfs_reserve_blocks(
358	struct xfs_mount	*mp,
359	uint64_t		request)
360{
361	int64_t			lcounter, delta;
362	int64_t			fdblks_delta = 0;
363	int64_t			free;
364	int			error = 0;
365
366	/*
367	 * With per-cpu counters, this becomes an interesting problem. we need
368	 * to work out if we are freeing or allocation blocks first, then we can
369	 * do the modification as necessary.
370	 *
371	 * We do this under the m_sb_lock so that if we are near ENOSPC, we will
372	 * hold out any changes while we work out what to do. This means that
373	 * the amount of free space can change while we do this, so we need to
374	 * retry if we end up trying to reserve more space than is available.
375	 */
376	spin_lock(&mp->m_sb_lock);
377
378	/*
379	 * If our previous reservation was larger than the current value,
380	 * then move any unused blocks back to the free pool. Modify the resblks
381	 * counters directly since we shouldn't have any problems unreserving
382	 * space.
383	 */
384	if (mp->m_resblks > request) {
385		lcounter = mp->m_resblks_avail - request;
386		if (lcounter > 0) {		/* release unused blocks */
387			fdblks_delta = lcounter;
388			mp->m_resblks_avail -= lcounter;
389		}
390		mp->m_resblks = request;
391		if (fdblks_delta) {
392			spin_unlock(&mp->m_sb_lock);
393			xfs_add_fdblocks(mp, fdblks_delta);
394			spin_lock(&mp->m_sb_lock);
395		}
396
397		goto out;
398	}
399
400	/*
401	 * If the request is larger than the current reservation, reserve the
402	 * blocks before we update the reserve counters. Sample m_fdblocks and
403	 * perform a partial reservation if the request exceeds free space.
404	 *
405	 * The code below estimates how many blocks it can request from
406	 * fdblocks to stash in the reserve pool.  This is a classic TOCTOU
407	 * race since fdblocks updates are not always coordinated via
408	 * m_sb_lock.  Set the reserve size even if there's not enough free
409	 * space to fill it because mod_fdblocks will refill an undersized
410	 * reserve when it can.
411	 */
412	free = percpu_counter_sum(&mp->m_fdblocks) -
413						xfs_fdblocks_unavailable(mp);
414	delta = request - mp->m_resblks;
415	mp->m_resblks = request;
416	if (delta > 0 && free > 0) {
417		/*
418		 * We'll either succeed in getting space from the free block
419		 * count or we'll get an ENOSPC.  Don't set the reserved flag
420		 * here - we don't want to reserve the extra reserve blocks
421		 * from the reserve.
422		 *
423		 * The desired reserve size can change after we drop the lock.
424		 * Use mod_fdblocks to put the space into the reserve or into
425		 * fdblocks as appropriate.
426		 */
427		fdblks_delta = min(free, delta);
428		spin_unlock(&mp->m_sb_lock);
429		error = xfs_dec_fdblocks(mp, fdblks_delta, 0);
430		if (!error)
431			xfs_add_fdblocks(mp, fdblks_delta);
432		spin_lock(&mp->m_sb_lock);
433	}
434out:
435	spin_unlock(&mp->m_sb_lock);
436	return error;
437}
438
439int
440xfs_fs_goingdown(
441	xfs_mount_t	*mp,
442	uint32_t	inflags)
443{
444	switch (inflags) {
445	case XFS_FSOP_GOING_FLAGS_DEFAULT: {
446		if (!bdev_freeze(mp->m_super->s_bdev)) {
447			xfs_force_shutdown(mp, SHUTDOWN_FORCE_UMOUNT);
448			bdev_thaw(mp->m_super->s_bdev);
449		}
450		break;
451	}
452	case XFS_FSOP_GOING_FLAGS_LOGFLUSH:
453		xfs_force_shutdown(mp, SHUTDOWN_FORCE_UMOUNT);
454		break;
455	case XFS_FSOP_GOING_FLAGS_NOLOGFLUSH:
456		xfs_force_shutdown(mp,
457				SHUTDOWN_FORCE_UMOUNT | SHUTDOWN_LOG_IO_ERROR);
458		break;
459	default:
460		return -EINVAL;
461	}
462
463	return 0;
464}
465
466/*
467 * Force a shutdown of the filesystem instantly while keeping the filesystem
468 * consistent. We don't do an unmount here; just shutdown the shop, make sure
469 * that absolutely nothing persistent happens to this filesystem after this
470 * point.
471 *
472 * The shutdown state change is atomic, resulting in the first and only the
473 * first shutdown call processing the shutdown. This means we only shutdown the
474 * log once as it requires, and we don't spam the logs when multiple concurrent
475 * shutdowns race to set the shutdown flags.
476 */
477void
478xfs_do_force_shutdown(
479	struct xfs_mount *mp,
480	uint32_t	flags,
481	char		*fname,
482	int		lnnum)
483{
484	int		tag;
485	const char	*why;
486
487
488	if (test_and_set_bit(XFS_OPSTATE_SHUTDOWN, &mp->m_opstate)) {
489		xlog_shutdown_wait(mp->m_log);
490		return;
491	}
492	if (mp->m_sb_bp)
493		mp->m_sb_bp->b_flags |= XBF_DONE;
494
495	if (flags & SHUTDOWN_FORCE_UMOUNT)
496		xfs_alert(mp, "User initiated shutdown received.");
497
498	if (xlog_force_shutdown(mp->m_log, flags)) {
499		tag = XFS_PTAG_SHUTDOWN_LOGERROR;
500		why = "Log I/O Error";
501	} else if (flags & SHUTDOWN_CORRUPT_INCORE) {
502		tag = XFS_PTAG_SHUTDOWN_CORRUPT;
503		why = "Corruption of in-memory data";
504	} else if (flags & SHUTDOWN_CORRUPT_ONDISK) {
505		tag = XFS_PTAG_SHUTDOWN_CORRUPT;
506		why = "Corruption of on-disk metadata";
507	} else if (flags & SHUTDOWN_DEVICE_REMOVED) {
508		tag = XFS_PTAG_SHUTDOWN_IOERROR;
509		why = "Block device removal";
510	} else {
511		tag = XFS_PTAG_SHUTDOWN_IOERROR;
512		why = "Metadata I/O Error";
513	}
514
515	trace_xfs_force_shutdown(mp, tag, flags, fname, lnnum);
516
517	xfs_alert_tag(mp, tag,
518"%s (0x%x) detected at %pS (%s:%d).  Shutting down filesystem.",
519			why, flags, __return_address, fname, lnnum);
520	xfs_alert(mp,
521		"Please unmount the filesystem and rectify the problem(s)");
522	if (xfs_error_level >= XFS_ERRLEVEL_HIGH)
523		xfs_stack_trace();
524}
525
526/*
527 * Reserve free space for per-AG metadata.
528 */
529int
530xfs_fs_reserve_ag_blocks(
531	struct xfs_mount	*mp)
532{
533	xfs_agnumber_t		agno;
534	struct xfs_perag	*pag;
535	int			error = 0;
536	int			err2;
537
538	mp->m_finobt_nores = false;
539	for_each_perag(mp, agno, pag) {
540		err2 = xfs_ag_resv_init(pag, NULL);
541		if (err2 && !error)
542			error = err2;
543	}
544
545	if (error && error != -ENOSPC) {
546		xfs_warn(mp,
547	"Error %d reserving per-AG metadata reserve pool.", error);
548		xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
549	}
550
551	return error;
552}
553
554/*
555 * Free space reserved for per-AG metadata.
556 */
557void
558xfs_fs_unreserve_ag_blocks(
559	struct xfs_mount	*mp)
560{
561	xfs_agnumber_t		agno;
562	struct xfs_perag	*pag;
563
564	for_each_perag(mp, agno, pag)
565		xfs_ag_resv_free(pag);
566}
567