1 // SPDX-License-Identifier: GPL-2.0 2 3 #include "ctree.h" 4 #include "block-rsv.h" 5 #include "space-info.h" 6 #include "math.h" 7 #include "transaction.h" 8 9 static u64 block_rsv_release_bytes(struct btrfs_fs_info *fs_info, 10 struct btrfs_block_rsv *block_rsv, 11 struct btrfs_block_rsv *dest, u64 num_bytes, 12 u64 *qgroup_to_release_ret) 13 { 14 struct btrfs_space_info *space_info = block_rsv->space_info; 15 u64 qgroup_to_release = 0; 16 u64 ret; 17 18 spin_lock(&block_rsv->lock); 19 if (num_bytes == (u64)-1) { 20 num_bytes = block_rsv->size; 21 qgroup_to_release = block_rsv->qgroup_rsv_size; 22 } 23 block_rsv->size -= num_bytes; 24 if (block_rsv->reserved >= block_rsv->size) { 25 num_bytes = block_rsv->reserved - block_rsv->size; 26 block_rsv->reserved = block_rsv->size; 27 block_rsv->full = 1; 28 } else { 29 num_bytes = 0; 30 } 31 if (block_rsv->qgroup_rsv_reserved >= block_rsv->qgroup_rsv_size) { 32 qgroup_to_release = block_rsv->qgroup_rsv_reserved - 33 block_rsv->qgroup_rsv_size; 34 block_rsv->qgroup_rsv_reserved = block_rsv->qgroup_rsv_size; 35 } else { 36 qgroup_to_release = 0; 37 } 38 spin_unlock(&block_rsv->lock); 39 40 ret = num_bytes; 41 if (num_bytes > 0) { 42 if (dest) { 43 spin_lock(&dest->lock); 44 if (!dest->full) { 45 u64 bytes_to_add; 46 47 bytes_to_add = dest->size - dest->reserved; 48 bytes_to_add = min(num_bytes, bytes_to_add); 49 dest->reserved += bytes_to_add; 50 if (dest->reserved >= dest->size) 51 dest->full = 1; 52 num_bytes -= bytes_to_add; 53 } 54 spin_unlock(&dest->lock); 55 } 56 if (num_bytes) 57 btrfs_space_info_add_old_bytes(fs_info, space_info, 58 num_bytes); 59 } 60 if (qgroup_to_release_ret) 61 *qgroup_to_release_ret = qgroup_to_release; 62 return ret; 63 } 64 65 int btrfs_block_rsv_migrate(struct btrfs_block_rsv *src, 66 struct btrfs_block_rsv *dst, u64 num_bytes, 67 bool update_size) 68 { 69 int ret; 70 71 ret = btrfs_block_rsv_use_bytes(src, num_bytes); 72 if (ret) 73 return ret; 74 75 btrfs_block_rsv_add_bytes(dst, num_bytes, update_size); 76 return 0; 77 } 78 79 void btrfs_init_block_rsv(struct btrfs_block_rsv *rsv, unsigned short type) 80 { 81 memset(rsv, 0, sizeof(*rsv)); 82 spin_lock_init(&rsv->lock); 83 rsv->type = type; 84 } 85 86 void btrfs_init_metadata_block_rsv(struct btrfs_fs_info *fs_info, 87 struct btrfs_block_rsv *rsv, 88 unsigned short type) 89 { 90 btrfs_init_block_rsv(rsv, type); 91 rsv->space_info = btrfs_find_space_info(fs_info, 92 BTRFS_BLOCK_GROUP_METADATA); 93 } 94 95 struct btrfs_block_rsv *btrfs_alloc_block_rsv(struct btrfs_fs_info *fs_info, 96 unsigned short type) 97 { 98 struct btrfs_block_rsv *block_rsv; 99 100 block_rsv = kmalloc(sizeof(*block_rsv), GFP_NOFS); 101 if (!block_rsv) 102 return NULL; 103 104 btrfs_init_metadata_block_rsv(fs_info, block_rsv, type); 105 return block_rsv; 106 } 107 108 void btrfs_free_block_rsv(struct btrfs_fs_info *fs_info, 109 struct btrfs_block_rsv *rsv) 110 { 111 if (!rsv) 112 return; 113 btrfs_block_rsv_release(fs_info, rsv, (u64)-1); 114 kfree(rsv); 115 } 116 117 int btrfs_block_rsv_add(struct btrfs_root *root, 118 struct btrfs_block_rsv *block_rsv, u64 num_bytes, 119 enum btrfs_reserve_flush_enum flush) 120 { 121 int ret; 122 123 if (num_bytes == 0) 124 return 0; 125 126 ret = btrfs_reserve_metadata_bytes(root, block_rsv, num_bytes, flush); 127 if (!ret) 128 btrfs_block_rsv_add_bytes(block_rsv, num_bytes, true); 129 130 return ret; 131 } 132 133 int btrfs_block_rsv_check(struct btrfs_block_rsv *block_rsv, int min_factor) 134 { 135 u64 num_bytes = 0; 136 int ret = -ENOSPC; 137 138 if (!block_rsv) 139 return 0; 140 141 spin_lock(&block_rsv->lock); 142 num_bytes = div_factor(block_rsv->size, min_factor); 143 if (block_rsv->reserved >= num_bytes) 144 ret = 0; 145 spin_unlock(&block_rsv->lock); 146 147 return ret; 148 } 149 150 int btrfs_block_rsv_refill(struct btrfs_root *root, 151 struct btrfs_block_rsv *block_rsv, u64 min_reserved, 152 enum btrfs_reserve_flush_enum flush) 153 { 154 u64 num_bytes = 0; 155 int ret = -ENOSPC; 156 157 if (!block_rsv) 158 return 0; 159 160 spin_lock(&block_rsv->lock); 161 num_bytes = min_reserved; 162 if (block_rsv->reserved >= num_bytes) 163 ret = 0; 164 else 165 num_bytes -= block_rsv->reserved; 166 spin_unlock(&block_rsv->lock); 167 168 if (!ret) 169 return 0; 170 171 ret = btrfs_reserve_metadata_bytes(root, block_rsv, num_bytes, flush); 172 if (!ret) { 173 btrfs_block_rsv_add_bytes(block_rsv, num_bytes, false); 174 return 0; 175 } 176 177 return ret; 178 } 179 180 u64 __btrfs_block_rsv_release(struct btrfs_fs_info *fs_info, 181 struct btrfs_block_rsv *block_rsv, 182 u64 num_bytes, u64 *qgroup_to_release) 183 { 184 struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv; 185 struct btrfs_block_rsv *delayed_rsv = &fs_info->delayed_refs_rsv; 186 struct btrfs_block_rsv *target = NULL; 187 188 /* 189 * If we are the delayed_rsv then push to the global rsv, otherwise dump 190 * into the delayed rsv if it is not full. 191 */ 192 if (block_rsv == delayed_rsv) 193 target = global_rsv; 194 else if (block_rsv != global_rsv && !delayed_rsv->full) 195 target = delayed_rsv; 196 197 if (target && block_rsv->space_info != target->space_info) 198 target = NULL; 199 200 return block_rsv_release_bytes(fs_info, block_rsv, target, num_bytes, 201 qgroup_to_release); 202 } 203 204 int btrfs_block_rsv_use_bytes(struct btrfs_block_rsv *block_rsv, u64 num_bytes) 205 { 206 int ret = -ENOSPC; 207 208 spin_lock(&block_rsv->lock); 209 if (block_rsv->reserved >= num_bytes) { 210 block_rsv->reserved -= num_bytes; 211 if (block_rsv->reserved < block_rsv->size) 212 block_rsv->full = 0; 213 ret = 0; 214 } 215 spin_unlock(&block_rsv->lock); 216 return ret; 217 } 218 219 void btrfs_block_rsv_add_bytes(struct btrfs_block_rsv *block_rsv, 220 u64 num_bytes, bool update_size) 221 { 222 spin_lock(&block_rsv->lock); 223 block_rsv->reserved += num_bytes; 224 if (update_size) 225 block_rsv->size += num_bytes; 226 else if (block_rsv->reserved >= block_rsv->size) 227 block_rsv->full = 1; 228 spin_unlock(&block_rsv->lock); 229 } 230 231 int btrfs_cond_migrate_bytes(struct btrfs_fs_info *fs_info, 232 struct btrfs_block_rsv *dest, u64 num_bytes, 233 int min_factor) 234 { 235 struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv; 236 u64 min_bytes; 237 238 if (global_rsv->space_info != dest->space_info) 239 return -ENOSPC; 240 241 spin_lock(&global_rsv->lock); 242 min_bytes = div_factor(global_rsv->size, min_factor); 243 if (global_rsv->reserved < min_bytes + num_bytes) { 244 spin_unlock(&global_rsv->lock); 245 return -ENOSPC; 246 } 247 global_rsv->reserved -= num_bytes; 248 if (global_rsv->reserved < global_rsv->size) 249 global_rsv->full = 0; 250 spin_unlock(&global_rsv->lock); 251 252 btrfs_block_rsv_add_bytes(dest, num_bytes, true); 253 return 0; 254 } 255 256 void btrfs_update_global_block_rsv(struct btrfs_fs_info *fs_info) 257 { 258 struct btrfs_block_rsv *block_rsv = &fs_info->global_block_rsv; 259 struct btrfs_space_info *sinfo = block_rsv->space_info; 260 u64 num_bytes; 261 262 /* 263 * The global block rsv is based on the size of the extent tree, the 264 * checksum tree and the root tree. If the fs is empty we want to set 265 * it to a minimal amount for safety. 266 */ 267 num_bytes = btrfs_root_used(&fs_info->extent_root->root_item) + 268 btrfs_root_used(&fs_info->csum_root->root_item) + 269 btrfs_root_used(&fs_info->tree_root->root_item); 270 num_bytes = max_t(u64, num_bytes, SZ_16M); 271 272 spin_lock(&sinfo->lock); 273 spin_lock(&block_rsv->lock); 274 275 block_rsv->size = min_t(u64, num_bytes, SZ_512M); 276 277 if (block_rsv->reserved < block_rsv->size) { 278 num_bytes = btrfs_space_info_used(sinfo, true); 279 if (sinfo->total_bytes > num_bytes) { 280 num_bytes = sinfo->total_bytes - num_bytes; 281 num_bytes = min(num_bytes, 282 block_rsv->size - block_rsv->reserved); 283 block_rsv->reserved += num_bytes; 284 btrfs_space_info_update_bytes_may_use(fs_info, sinfo, 285 num_bytes); 286 trace_btrfs_space_reservation(fs_info, "space_info", 287 sinfo->flags, num_bytes, 288 1); 289 } 290 } else if (block_rsv->reserved > block_rsv->size) { 291 num_bytes = block_rsv->reserved - block_rsv->size; 292 btrfs_space_info_update_bytes_may_use(fs_info, sinfo, 293 -num_bytes); 294 trace_btrfs_space_reservation(fs_info, "space_info", 295 sinfo->flags, num_bytes, 0); 296 block_rsv->reserved = block_rsv->size; 297 } 298 299 if (block_rsv->reserved == block_rsv->size) 300 block_rsv->full = 1; 301 else 302 block_rsv->full = 0; 303 304 spin_unlock(&block_rsv->lock); 305 spin_unlock(&sinfo->lock); 306 } 307 308 void btrfs_init_global_block_rsv(struct btrfs_fs_info *fs_info) 309 { 310 struct btrfs_space_info *space_info; 311 312 space_info = btrfs_find_space_info(fs_info, BTRFS_BLOCK_GROUP_SYSTEM); 313 fs_info->chunk_block_rsv.space_info = space_info; 314 315 space_info = btrfs_find_space_info(fs_info, BTRFS_BLOCK_GROUP_METADATA); 316 fs_info->global_block_rsv.space_info = space_info; 317 fs_info->trans_block_rsv.space_info = space_info; 318 fs_info->empty_block_rsv.space_info = space_info; 319 fs_info->delayed_block_rsv.space_info = space_info; 320 fs_info->delayed_refs_rsv.space_info = space_info; 321 322 fs_info->extent_root->block_rsv = &fs_info->delayed_refs_rsv; 323 fs_info->csum_root->block_rsv = &fs_info->delayed_refs_rsv; 324 fs_info->dev_root->block_rsv = &fs_info->global_block_rsv; 325 fs_info->tree_root->block_rsv = &fs_info->global_block_rsv; 326 if (fs_info->quota_root) 327 fs_info->quota_root->block_rsv = &fs_info->global_block_rsv; 328 fs_info->chunk_root->block_rsv = &fs_info->chunk_block_rsv; 329 330 btrfs_update_global_block_rsv(fs_info); 331 } 332 333 void btrfs_release_global_block_rsv(struct btrfs_fs_info *fs_info) 334 { 335 btrfs_block_rsv_release(fs_info, &fs_info->global_block_rsv, (u64)-1); 336 WARN_ON(fs_info->trans_block_rsv.size > 0); 337 WARN_ON(fs_info->trans_block_rsv.reserved > 0); 338 WARN_ON(fs_info->chunk_block_rsv.size > 0); 339 WARN_ON(fs_info->chunk_block_rsv.reserved > 0); 340 WARN_ON(fs_info->delayed_block_rsv.size > 0); 341 WARN_ON(fs_info->delayed_block_rsv.reserved > 0); 342 WARN_ON(fs_info->delayed_refs_rsv.reserved > 0); 343 WARN_ON(fs_info->delayed_refs_rsv.size > 0); 344 } 345 346 static struct btrfs_block_rsv *get_block_rsv( 347 const struct btrfs_trans_handle *trans, 348 const struct btrfs_root *root) 349 { 350 struct btrfs_fs_info *fs_info = root->fs_info; 351 struct btrfs_block_rsv *block_rsv = NULL; 352 353 if (test_bit(BTRFS_ROOT_REF_COWS, &root->state) || 354 (root == fs_info->csum_root && trans->adding_csums) || 355 (root == fs_info->uuid_root)) 356 block_rsv = trans->block_rsv; 357 358 if (!block_rsv) 359 block_rsv = root->block_rsv; 360 361 if (!block_rsv) 362 block_rsv = &fs_info->empty_block_rsv; 363 364 return block_rsv; 365 } 366 367 struct btrfs_block_rsv *btrfs_use_block_rsv(struct btrfs_trans_handle *trans, 368 struct btrfs_root *root, 369 u32 blocksize) 370 { 371 struct btrfs_fs_info *fs_info = root->fs_info; 372 struct btrfs_block_rsv *block_rsv; 373 struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv; 374 int ret; 375 bool global_updated = false; 376 377 block_rsv = get_block_rsv(trans, root); 378 379 if (unlikely(block_rsv->size == 0)) 380 goto try_reserve; 381 again: 382 ret = btrfs_block_rsv_use_bytes(block_rsv, blocksize); 383 if (!ret) 384 return block_rsv; 385 386 if (block_rsv->failfast) 387 return ERR_PTR(ret); 388 389 if (block_rsv->type == BTRFS_BLOCK_RSV_GLOBAL && !global_updated) { 390 global_updated = true; 391 btrfs_update_global_block_rsv(fs_info); 392 goto again; 393 } 394 395 /* 396 * The global reserve still exists to save us from ourselves, so don't 397 * warn_on if we are short on our delayed refs reserve. 398 */ 399 if (block_rsv->type != BTRFS_BLOCK_RSV_DELREFS && 400 btrfs_test_opt(fs_info, ENOSPC_DEBUG)) { 401 static DEFINE_RATELIMIT_STATE(_rs, 402 DEFAULT_RATELIMIT_INTERVAL * 10, 403 /*DEFAULT_RATELIMIT_BURST*/ 1); 404 if (__ratelimit(&_rs)) 405 WARN(1, KERN_DEBUG 406 "BTRFS: block rsv returned %d\n", ret); 407 } 408 try_reserve: 409 ret = btrfs_reserve_metadata_bytes(root, block_rsv, blocksize, 410 BTRFS_RESERVE_NO_FLUSH); 411 if (!ret) 412 return block_rsv; 413 /* 414 * If we couldn't reserve metadata bytes try and use some from 415 * the global reserve if its space type is the same as the global 416 * reservation. 417 */ 418 if (block_rsv->type != BTRFS_BLOCK_RSV_GLOBAL && 419 block_rsv->space_info == global_rsv->space_info) { 420 ret = btrfs_block_rsv_use_bytes(global_rsv, blocksize); 421 if (!ret) 422 return global_rsv; 423 } 424 return ERR_PTR(ret); 425 } 426