1 /* SPDX-License-Identifier: GPL-2.0 */ 2 /* 3 * Copyright (c) 2021-2024 Oracle. All Rights Reserved. 4 * Author: Darrick J. Wong <djwong@kernel.org> 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_trans.h" 14 #include "xfs_btree.h" 15 #include "xfs_error.h" 16 #include "xfs_buf_mem.h" 17 #include "xfs_btree_mem.h" 18 #include "xfs_ag.h" 19 #include "xfs_buf_item.h" 20 #include "xfs_trace.h" 21 22 /* Set the root of an in-memory btree. */ 23 void 24 xfbtree_set_root( 25 struct xfs_btree_cur *cur, 26 const union xfs_btree_ptr *ptr, 27 int inc) 28 { 29 ASSERT(cur->bc_ops->type == XFS_BTREE_TYPE_MEM); 30 31 cur->bc_mem.xfbtree->root = *ptr; 32 cur->bc_mem.xfbtree->nlevels += inc; 33 } 34 35 /* Initialize a pointer from the in-memory btree header. */ 36 void 37 xfbtree_init_ptr_from_cur( 38 struct xfs_btree_cur *cur, 39 union xfs_btree_ptr *ptr) 40 { 41 ASSERT(cur->bc_ops->type == XFS_BTREE_TYPE_MEM); 42 43 *ptr = cur->bc_mem.xfbtree->root; 44 } 45 46 /* Duplicate an in-memory btree cursor. */ 47 struct xfs_btree_cur * 48 xfbtree_dup_cursor( 49 struct xfs_btree_cur *cur) 50 { 51 struct xfs_btree_cur *ncur; 52 53 ASSERT(cur->bc_ops->type == XFS_BTREE_TYPE_MEM); 54 55 ncur = xfs_btree_alloc_cursor(cur->bc_mp, cur->bc_tp, cur->bc_ops, 56 cur->bc_maxlevels, cur->bc_cache); 57 ncur->bc_flags = cur->bc_flags; 58 ncur->bc_nlevels = cur->bc_nlevels; 59 ncur->bc_mem.xfbtree = cur->bc_mem.xfbtree; 60 61 if (cur->bc_mem.pag) 62 ncur->bc_mem.pag = xfs_perag_hold(cur->bc_mem.pag); 63 64 return ncur; 65 } 66 67 /* Close the btree xfile and release all resources. */ 68 void 69 xfbtree_destroy( 70 struct xfbtree *xfbt) 71 { 72 xfs_buftarg_drain(xfbt->target); 73 } 74 75 /* Compute the number of bytes available for records. */ 76 static inline unsigned int 77 xfbtree_rec_bytes( 78 struct xfs_mount *mp, 79 const struct xfs_btree_ops *ops) 80 { 81 return XMBUF_BLOCKSIZE - XFS_BTREE_LBLOCK_CRC_LEN; 82 } 83 84 /* Initialize an empty leaf block as the btree root. */ 85 STATIC int 86 xfbtree_init_leaf_block( 87 struct xfs_mount *mp, 88 struct xfbtree *xfbt, 89 const struct xfs_btree_ops *ops) 90 { 91 struct xfs_buf *bp; 92 xfbno_t bno = xfbt->highest_bno++; 93 int error; 94 95 error = xfs_buf_get(xfbt->target, xfbno_to_daddr(bno), XFBNO_BBSIZE, 96 &bp); 97 if (error) 98 return error; 99 100 trace_xfbtree_create_root_buf(xfbt, bp); 101 102 bp->b_ops = ops->buf_ops; 103 xfs_btree_init_buf(mp, bp, ops, 0, 0, xfbt->owner); 104 xfs_buf_relse(bp); 105 106 xfbt->root.l = cpu_to_be64(bno); 107 return 0; 108 } 109 110 /* 111 * Create an in-memory btree root that can be used with the given xmbuf. 112 * Callers must set xfbt->owner. 113 */ 114 int 115 xfbtree_init( 116 struct xfs_mount *mp, 117 struct xfbtree *xfbt, 118 struct xfs_buftarg *btp, 119 const struct xfs_btree_ops *ops) 120 { 121 unsigned int blocklen = xfbtree_rec_bytes(mp, ops); 122 unsigned int keyptr_len; 123 int error; 124 125 /* Requires a long-format CRC-format btree */ 126 if (!xfs_has_crc(mp)) { 127 ASSERT(xfs_has_crc(mp)); 128 return -EINVAL; 129 } 130 if (ops->ptr_len != XFS_BTREE_LONG_PTR_LEN) { 131 ASSERT(ops->ptr_len == XFS_BTREE_LONG_PTR_LEN); 132 return -EINVAL; 133 } 134 135 memset(xfbt, 0, sizeof(*xfbt)); 136 xfbt->target = btp; 137 138 /* Set up min/maxrecs for this btree. */ 139 keyptr_len = ops->key_len + sizeof(__be64); 140 xfbt->maxrecs[0] = blocklen / ops->rec_len; 141 xfbt->maxrecs[1] = blocklen / keyptr_len; 142 xfbt->minrecs[0] = xfbt->maxrecs[0] / 2; 143 xfbt->minrecs[1] = xfbt->maxrecs[1] / 2; 144 xfbt->highest_bno = 0; 145 xfbt->nlevels = 1; 146 147 /* Initialize the empty btree. */ 148 error = xfbtree_init_leaf_block(mp, xfbt, ops); 149 if (error) 150 goto err_freesp; 151 152 trace_xfbtree_init(mp, xfbt, ops); 153 154 return 0; 155 156 err_freesp: 157 xfs_buftarg_drain(xfbt->target); 158 return error; 159 } 160 161 /* Allocate a block to our in-memory btree. */ 162 int 163 xfbtree_alloc_block( 164 struct xfs_btree_cur *cur, 165 const union xfs_btree_ptr *start, 166 union xfs_btree_ptr *new, 167 int *stat) 168 { 169 struct xfbtree *xfbt = cur->bc_mem.xfbtree; 170 xfbno_t bno = xfbt->highest_bno++; 171 172 ASSERT(cur->bc_ops->type == XFS_BTREE_TYPE_MEM); 173 174 trace_xfbtree_alloc_block(xfbt, cur, bno); 175 176 /* Fail if the block address exceeds the maximum for the buftarg. */ 177 if (!xfbtree_verify_bno(xfbt, bno)) { 178 ASSERT(xfbtree_verify_bno(xfbt, bno)); 179 *stat = 0; 180 return 0; 181 } 182 183 new->l = cpu_to_be64(bno); 184 *stat = 1; 185 return 0; 186 } 187 188 /* Free a block from our in-memory btree. */ 189 int 190 xfbtree_free_block( 191 struct xfs_btree_cur *cur, 192 struct xfs_buf *bp) 193 { 194 struct xfbtree *xfbt = cur->bc_mem.xfbtree; 195 xfs_daddr_t daddr = xfs_buf_daddr(bp); 196 xfbno_t bno = xfs_daddr_to_xfbno(daddr); 197 198 ASSERT(cur->bc_ops->type == XFS_BTREE_TYPE_MEM); 199 200 trace_xfbtree_free_block(xfbt, cur, bno); 201 202 if (bno + 1 == xfbt->highest_bno) 203 xfbt->highest_bno--; 204 205 return 0; 206 } 207 208 /* Return the minimum number of records for a btree block. */ 209 int 210 xfbtree_get_minrecs( 211 struct xfs_btree_cur *cur, 212 int level) 213 { 214 struct xfbtree *xfbt = cur->bc_mem.xfbtree; 215 216 return xfbt->minrecs[level != 0]; 217 } 218 219 /* Return the maximum number of records for a btree block. */ 220 int 221 xfbtree_get_maxrecs( 222 struct xfs_btree_cur *cur, 223 int level) 224 { 225 struct xfbtree *xfbt = cur->bc_mem.xfbtree; 226 227 return xfbt->maxrecs[level != 0]; 228 } 229 230 /* If this log item is a buffer item that came from the xfbtree, return it. */ 231 static inline struct xfs_buf * 232 xfbtree_buf_match( 233 struct xfbtree *xfbt, 234 const struct xfs_log_item *lip) 235 { 236 const struct xfs_buf_log_item *bli; 237 struct xfs_buf *bp; 238 239 if (lip->li_type != XFS_LI_BUF) 240 return NULL; 241 242 bli = container_of(lip, struct xfs_buf_log_item, bli_item); 243 bp = bli->bli_buf; 244 if (bp->b_target != xfbt->target) 245 return NULL; 246 247 return bp; 248 } 249 250 /* 251 * Commit changes to the incore btree immediately by writing all dirty xfbtree 252 * buffers to the backing xfile. This detaches all xfbtree buffers from the 253 * transaction, even on failure. The buffer locks are dropped between the 254 * delwri queue and submit, so the caller must synchronize btree access. 255 * 256 * Normally we'd let the buffers commit with the transaction and get written to 257 * the xfile via the log, but online repair stages ephemeral btrees in memory 258 * and uses the btree_staging functions to write new btrees to disk atomically. 259 * The in-memory btree (and its backing store) are discarded at the end of the 260 * repair phase, which means that xfbtree buffers cannot commit with the rest 261 * of a transaction. 262 * 263 * In other words, online repair only needs the transaction to collect buffer 264 * pointers and to avoid buffer deadlocks, not to guarantee consistency of 265 * updates. 266 */ 267 int 268 xfbtree_trans_commit( 269 struct xfbtree *xfbt, 270 struct xfs_trans *tp) 271 { 272 struct xfs_log_item *lip, *n; 273 bool tp_dirty = false; 274 int error = 0; 275 276 /* 277 * For each xfbtree buffer attached to the transaction, write the dirty 278 * buffers to the xfile and release them. 279 */ 280 list_for_each_entry_safe(lip, n, &tp->t_items, li_trans) { 281 struct xfs_buf *bp = xfbtree_buf_match(xfbt, lip); 282 283 if (!bp) { 284 if (test_bit(XFS_LI_DIRTY, &lip->li_flags)) 285 tp_dirty |= true; 286 continue; 287 } 288 289 trace_xfbtree_trans_commit_buf(xfbt, bp); 290 291 xmbuf_trans_bdetach(tp, bp); 292 293 /* 294 * If the buffer fails verification, note the failure but 295 * continue walking the transaction items so that we remove all 296 * ephemeral btree buffers. 297 */ 298 if (!error) 299 error = xmbuf_finalize(bp); 300 301 xfs_buf_relse(bp); 302 } 303 304 /* 305 * Reset the transaction's dirty flag to reflect the dirty state of the 306 * log items that are still attached. 307 */ 308 tp->t_flags = (tp->t_flags & ~XFS_TRANS_DIRTY) | 309 (tp_dirty ? XFS_TRANS_DIRTY : 0); 310 311 return error; 312 } 313 314 /* 315 * Cancel changes to the incore btree by detaching all the xfbtree buffers. 316 * Changes are not undone, so callers must not access the btree ever again. 317 */ 318 void 319 xfbtree_trans_cancel( 320 struct xfbtree *xfbt, 321 struct xfs_trans *tp) 322 { 323 struct xfs_log_item *lip, *n; 324 bool tp_dirty = false; 325 326 list_for_each_entry_safe(lip, n, &tp->t_items, li_trans) { 327 struct xfs_buf *bp = xfbtree_buf_match(xfbt, lip); 328 329 if (!bp) { 330 if (test_bit(XFS_LI_DIRTY, &lip->li_flags)) 331 tp_dirty |= true; 332 continue; 333 } 334 335 trace_xfbtree_trans_cancel_buf(xfbt, bp); 336 337 xmbuf_trans_bdetach(tp, bp); 338 xfs_buf_relse(bp); 339 } 340 341 /* 342 * Reset the transaction's dirty flag to reflect the dirty state of the 343 * log items that are still attached. 344 */ 345 tp->t_flags = (tp->t_flags & ~XFS_TRANS_DIRTY) | 346 (tp_dirty ? XFS_TRANS_DIRTY : 0); 347 } 348