xfs_log_rlimit.c

  1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * Copyright (c) 2013 Jie Liu.
  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_mount.h"
 13#include "xfs_da_format.h"
 14#include "xfs_trans_space.h"
 15#include "xfs_da_btree.h"
 16#include "xfs_bmap_btree.h"
 17#include "xfs_trace.h"
 18
 19/*
 20 * Shortly after enabling the large extents count feature in 2023, longstanding
 21 * bugs were found in the code that computes the minimum log size.  Luckily,
 22 * the bugs resulted in over-estimates of that size, so there's no impact to
 23 * existing users.  However, we don't want to reduce the minimum log size
 24 * because that can create the situation where a newer mkfs writes a new
 25 * filesystem that an older kernel won't mount.
 26 *
 27 * Several years prior, we also discovered that the transaction reservations
 28 * for rmap and reflink operations were unnecessarily large.  That was fixed,
 29 * but the minimum log size computation was left alone to avoid the
 30 * compatibility problems noted above.  Fix that too.
 31 *
 32 * Therefore, we only may correct the computation starting with filesystem
 33 * features that didn't exist in 2023.  In other words, only turn this on if
 34 * the filesystem has parent pointers.
 35 *
 36 * This function can be called before the XFS_HAS_* flags have been set up,
 37 * (e.g. mkfs) so we must check the ondisk superblock.
 38 */
 39static inline bool
 40xfs_want_minlogsize_fixes(
 41	struct xfs_sb	*sb)
 42{
 43	return xfs_sb_is_v5(sb) &&
 44	       xfs_sb_has_incompat_feature(sb, XFS_SB_FEAT_INCOMPAT_PARENT);
 45}
 46
 47/*
 48 * Calculate the maximum length in bytes that would be required for a local
 49 * attribute value as large attributes out of line are not logged.
 50 */
 51STATIC int
 52xfs_log_calc_max_attrsetm_res(
 53	struct xfs_mount	*mp)
 54{
 55	int			size;
 56	int			nblks;
 57
 58	size = xfs_attr_leaf_entsize_local_max(mp->m_attr_geo->blksize) -
 59	       MAXNAMELEN - 1;
 60	nblks = XFS_DAENTER_SPACE_RES(mp, XFS_ATTR_FORK);
 61	nblks += XFS_B_TO_FSB(mp, size);
 62
 63	/*
 64	 * If the feature set is new enough, correct a unit conversion error in
 65	 * the xattr transaction reservation code that resulted in oversized
 66	 * minimum log size computations.
 67	 */
 68	if (xfs_want_minlogsize_fixes(&mp->m_sb))
 69		size = XFS_B_TO_FSB(mp, size);
 70
 71	nblks += XFS_NEXTENTADD_SPACE_RES(mp, size, XFS_ATTR_FORK);
 72
 73	return  M_RES(mp)->tr_attrsetm.tr_logres +
 74		M_RES(mp)->tr_attrsetrt.tr_logres * nblks;
 75}
 76
 77/*
 78 * Compute an alternate set of log reservation sizes for use exclusively with
 79 * minimum log size calculations.
 80 */
 81static void
 82xfs_log_calc_trans_resv_for_minlogblocks(
 83	struct xfs_mount	*mp,
 84	struct xfs_trans_resv	*resv)
 85{
 86	unsigned int		rmap_maxlevels = mp->m_rmap_maxlevels;
 87
 88	/*
 89	 * If the feature set is new enough, drop the oversized minimum log
 90	 * size computation introduced by the original reflink code.
 91	 */
 92	if (xfs_want_minlogsize_fixes(&mp->m_sb)) {
 93		xfs_trans_resv_calc(mp, resv);
 94		resv->tr_atomic_ioend = M_RES(mp)->tr_atomic_ioend;
 95		return;
 96	}
 97
 98	/*
 99	 * In the early days of rmap+reflink, we always set the rmap maxlevels
100	 * to 9 even if the AG was small enough that it would never grow to
101	 * that height.  Transaction reservation sizes influence the minimum
102	 * log size calculation, which influences the size of the log that mkfs
103	 * creates.  Use the old value here to ensure that newly formatted
104	 * small filesystems will mount on older kernels.
105	 */
106	if (xfs_has_rmapbt(mp) && xfs_has_reflink(mp))
107		mp->m_rmap_maxlevels = XFS_OLD_REFLINK_RMAP_MAXLEVELS;
108
109	xfs_trans_resv_calc(mp, resv);
110
111	/* Copy the dynamic transaction reservation types from the running fs */
112	resv->tr_atomic_ioend = M_RES(mp)->tr_atomic_ioend;
113
114	if (xfs_has_reflink(mp)) {
115		/*
116		 * In the early days of reflink, typical log operation counts
117		 * were greatly overestimated.
118		 */
119		resv->tr_write.tr_logcount = XFS_WRITE_LOG_COUNT_REFLINK;
120		resv->tr_itruncate.tr_logcount =
121				XFS_ITRUNCATE_LOG_COUNT_REFLINK;
122		resv->tr_qm_dqalloc.tr_logcount = XFS_WRITE_LOG_COUNT_REFLINK;
123	} else if (xfs_has_rmapbt(mp)) {
124		/*
125		 * In the early days of non-reflink rmap, the impact of rmapbt
126		 * updates on log counts were not taken into account at all.
127		 */
128		resv->tr_write.tr_logcount = XFS_WRITE_LOG_COUNT;
129		resv->tr_itruncate.tr_logcount = XFS_ITRUNCATE_LOG_COUNT;
130		resv->tr_qm_dqalloc.tr_logcount = XFS_WRITE_LOG_COUNT;
131	}
132
133	/*
134	 * In the early days of reflink, we did not use deferred refcount
135	 * update log items, so log reservations must be recomputed using the
136	 * old calculations.
137	 */
138	resv->tr_write.tr_logres =
139			xfs_calc_write_reservation_minlogsize(mp);
140	resv->tr_itruncate.tr_logres =
141			xfs_calc_itruncate_reservation_minlogsize(mp);
142	resv->tr_qm_dqalloc.tr_logres =
143			xfs_calc_qm_dqalloc_reservation_minlogsize(mp);
144
145	/* Put everything back the way it was.  This goes at the end. */
146	mp->m_rmap_maxlevels = rmap_maxlevels;
147}
148
149/*
150 * Iterate over the log space reservation table to figure out and return
151 * the maximum one in terms of the pre-calculated values which were done
152 * at mount time.
153 */
154void
155xfs_log_get_max_trans_res(
156	struct xfs_mount	*mp,
157	struct xfs_trans_res	*max_resp)
158{
159	struct xfs_trans_resv	resv = {};
160	struct xfs_trans_res	*resp;
161	struct xfs_trans_res	*end_resp;
162	unsigned int		i;
163	int			log_space = 0;
164	int			attr_space;
165
166	attr_space = xfs_log_calc_max_attrsetm_res(mp);
167
168	xfs_log_calc_trans_resv_for_minlogblocks(mp, &resv);
169
170	resp = (struct xfs_trans_res *)&resv;
171	end_resp = (struct xfs_trans_res *)(&resv + 1);
172	for (i = 0; resp < end_resp; i++, resp++) {
173		int		tmp = resp->tr_logcount > 1 ?
174				      resp->tr_logres * resp->tr_logcount :
175				      resp->tr_logres;
176
177		trace_xfs_trans_resv_calc_minlogsize(mp, i, resp);
178		if (log_space < tmp) {
179			log_space = tmp;
180			*max_resp = *resp;		/* struct copy */
181		}
182	}
183
184	if (attr_space > log_space) {
185		*max_resp = resv.tr_attrsetm;	/* struct copy */
186		max_resp->tr_logres = attr_space;
187	}
188	trace_xfs_log_get_max_trans_res(mp, max_resp);
189}
190
191/*
192 * Calculate the minimum valid log size for the given superblock configuration.
193 * Used to calculate the minimum log size at mkfs time, and to determine if
194 * the log is large enough or not at mount time. Returns the minimum size in
195 * filesystem block size units.
196 */
197int
198xfs_log_calc_minimum_size(
199	struct xfs_mount	*mp)
200{
201	struct xfs_trans_res	tres = {0};
202	int			max_logres;
203	int			min_logblks = 0;
204	int			lsunit = 0;
205
206	xfs_log_get_max_trans_res(mp, &tres);
207
208	max_logres = xfs_log_calc_unit_res(mp, tres.tr_logres);
209	if (tres.tr_logcount > 1)
210		max_logres *= tres.tr_logcount;
211
212	if (xfs_has_logv2(mp) && mp->m_sb.sb_logsunit > 1)
213		lsunit = BTOBB(mp->m_sb.sb_logsunit);
214
215	/*
216	 * Two factors should be taken into account for calculating the minimum
217	 * log space.
218	 * 1) The fundamental limitation is that no single transaction can be
219	 *    larger than half size of the log.
220	 *
221	 *    From mkfs.xfs, this is considered by the XFS_MIN_LOG_FACTOR
222	 *    define, which is set to 3. That means we can definitely fit
223	 *    maximally sized 2 transactions in the log. We'll use this same
224	 *    value here.
225	 *
226	 * 2) If the lsunit option is specified, a transaction requires 2 LSU
227	 *    for the reservation because there are two log writes that can
228	 *    require padding - the transaction data and the commit record which
229	 *    are written separately and both can require padding to the LSU.
230	 *    Consider that we can have an active CIL reservation holding 2*LSU,
231	 *    but the CIL is not over a push threshold, in this case, if we
232	 *    don't have enough log space for at one new transaction, which
233	 *    includes another 2*LSU in the reservation, we will run into dead
234	 *    loop situation in log space grant procedure. i.e.
235	 *    xlog_grant_head_wait().
236	 *
237	 *    Hence the log size needs to be able to contain two maximally sized
238	 *    and padded transactions, which is (2 * (2 * LSU + maxlres)).
239	 *
240	 * Also, the log size should be a multiple of the log stripe unit, round
241	 * it up to lsunit boundary if lsunit is specified.
242	 */
243	if (lsunit) {
244		min_logblks = roundup_64(BTOBB(max_logres), lsunit) +
245			      2 * lsunit;
246	} else
247		min_logblks = BTOBB(max_logres) + 2 * BBSIZE;
248	min_logblks *= XFS_MIN_LOG_FACTOR;
249
250	return XFS_BB_TO_FSB(mp, min_logblks);
251}