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 */ 39 static inline bool 40 xfs_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 */ 51 STATIC int 52 xfs_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 */ 81 static void 82 xfs_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 return; 95 } 96 97 /* 98 * In the early days of rmap+reflink, we always set the rmap maxlevels 99 * to 9 even if the AG was small enough that it would never grow to 100 * that height. Transaction reservation sizes influence the minimum 101 * log size calculation, which influences the size of the log that mkfs 102 * creates. Use the old value here to ensure that newly formatted 103 * small filesystems will mount on older kernels. 104 */ 105 if (xfs_has_rmapbt(mp) && xfs_has_reflink(mp)) 106 mp->m_rmap_maxlevels = XFS_OLD_REFLINK_RMAP_MAXLEVELS; 107 108 xfs_trans_resv_calc(mp, resv); 109 110 if (xfs_has_reflink(mp)) { 111 /* 112 * In the early days of reflink, typical log operation counts 113 * were greatly overestimated. 114 */ 115 resv->tr_write.tr_logcount = XFS_WRITE_LOG_COUNT_REFLINK; 116 resv->tr_itruncate.tr_logcount = 117 XFS_ITRUNCATE_LOG_COUNT_REFLINK; 118 resv->tr_qm_dqalloc.tr_logcount = XFS_WRITE_LOG_COUNT_REFLINK; 119 } else if (xfs_has_rmapbt(mp)) { 120 /* 121 * In the early days of non-reflink rmap, the impact of rmapbt 122 * updates on log counts were not taken into account at all. 123 */ 124 resv->tr_write.tr_logcount = XFS_WRITE_LOG_COUNT; 125 resv->tr_itruncate.tr_logcount = XFS_ITRUNCATE_LOG_COUNT; 126 resv->tr_qm_dqalloc.tr_logcount = XFS_WRITE_LOG_COUNT; 127 } 128 129 /* 130 * In the early days of reflink, we did not use deferred refcount 131 * update log items, so log reservations must be recomputed using the 132 * old calculations. 133 */ 134 resv->tr_write.tr_logres = 135 xfs_calc_write_reservation_minlogsize(mp); 136 resv->tr_itruncate.tr_logres = 137 xfs_calc_itruncate_reservation_minlogsize(mp); 138 resv->tr_qm_dqalloc.tr_logres = 139 xfs_calc_qm_dqalloc_reservation_minlogsize(mp); 140 141 /* Put everything back the way it was. This goes at the end. */ 142 mp->m_rmap_maxlevels = rmap_maxlevels; 143 } 144 145 /* 146 * Iterate over the log space reservation table to figure out and return 147 * the maximum one in terms of the pre-calculated values which were done 148 * at mount time. 149 */ 150 void 151 xfs_log_get_max_trans_res( 152 struct xfs_mount *mp, 153 struct xfs_trans_res *max_resp) 154 { 155 struct xfs_trans_resv resv = {}; 156 struct xfs_trans_res *resp; 157 struct xfs_trans_res *end_resp; 158 unsigned int i; 159 int log_space = 0; 160 int attr_space; 161 162 attr_space = xfs_log_calc_max_attrsetm_res(mp); 163 164 xfs_log_calc_trans_resv_for_minlogblocks(mp, &resv); 165 166 resp = (struct xfs_trans_res *)&resv; 167 end_resp = (struct xfs_trans_res *)(&resv + 1); 168 for (i = 0; resp < end_resp; i++, resp++) { 169 int tmp = resp->tr_logcount > 1 ? 170 resp->tr_logres * resp->tr_logcount : 171 resp->tr_logres; 172 173 trace_xfs_trans_resv_calc_minlogsize(mp, i, resp); 174 if (log_space < tmp) { 175 log_space = tmp; 176 *max_resp = *resp; /* struct copy */ 177 } 178 } 179 180 if (attr_space > log_space) { 181 *max_resp = resv.tr_attrsetm; /* struct copy */ 182 max_resp->tr_logres = attr_space; 183 } 184 trace_xfs_log_get_max_trans_res(mp, max_resp); 185 } 186 187 /* 188 * Calculate the minimum valid log size for the given superblock configuration. 189 * Used to calculate the minimum log size at mkfs time, and to determine if 190 * the log is large enough or not at mount time. Returns the minimum size in 191 * filesystem block size units. 192 */ 193 int 194 xfs_log_calc_minimum_size( 195 struct xfs_mount *mp) 196 { 197 struct xfs_trans_res tres = {0}; 198 int max_logres; 199 int min_logblks = 0; 200 int lsunit = 0; 201 202 xfs_log_get_max_trans_res(mp, &tres); 203 204 max_logres = xfs_log_calc_unit_res(mp, tres.tr_logres); 205 if (tres.tr_logcount > 1) 206 max_logres *= tres.tr_logcount; 207 208 if (xfs_has_logv2(mp) && mp->m_sb.sb_logsunit > 1) 209 lsunit = BTOBB(mp->m_sb.sb_logsunit); 210 211 /* 212 * Two factors should be taken into account for calculating the minimum 213 * log space. 214 * 1) The fundamental limitation is that no single transaction can be 215 * larger than half size of the log. 216 * 217 * From mkfs.xfs, this is considered by the XFS_MIN_LOG_FACTOR 218 * define, which is set to 3. That means we can definitely fit 219 * maximally sized 2 transactions in the log. We'll use this same 220 * value here. 221 * 222 * 2) If the lsunit option is specified, a transaction requires 2 LSU 223 * for the reservation because there are two log writes that can 224 * require padding - the transaction data and the commit record which 225 * are written separately and both can require padding to the LSU. 226 * Consider that we can have an active CIL reservation holding 2*LSU, 227 * but the CIL is not over a push threshold, in this case, if we 228 * don't have enough log space for at one new transaction, which 229 * includes another 2*LSU in the reservation, we will run into dead 230 * loop situation in log space grant procedure. i.e. 231 * xlog_grant_head_wait(). 232 * 233 * Hence the log size needs to be able to contain two maximally sized 234 * and padded transactions, which is (2 * (2 * LSU + maxlres)). 235 * 236 * Also, the log size should be a multiple of the log stripe unit, round 237 * it up to lsunit boundary if lsunit is specified. 238 */ 239 if (lsunit) { 240 min_logblks = roundup_64(BTOBB(max_logres), lsunit) + 241 2 * lsunit; 242 } else 243 min_logblks = BTOBB(max_logres) + 2 * BBSIZE; 244 min_logblks *= XFS_MIN_LOG_FACTOR; 245 246 return XFS_BB_TO_FSB(mp, min_logblks); 247 } 248