extent-tree.c (424a47805a819ff59ada9549c4a21fe0ba95c446) extent-tree.c (550fa228ee7ebea3c3499897a7aef6536de73fff)
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright (C) 2007 Oracle. All rights reserved.
4 */
5
6#include <linux/sched.h>
7#include <linux/sched/signal.h>
8#include <linux/pagemap.h>

--- 4354 unchanged lines hidden (view full) ---

4363 block_rsv = root->block_rsv;
4364
4365 if (!block_rsv)
4366 block_rsv = &fs_info->empty_block_rsv;
4367
4368 return block_rsv;
4369}
4370
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright (C) 2007 Oracle. All rights reserved.
4 */
5
6#include <linux/sched.h>
7#include <linux/sched/signal.h>
8#include <linux/pagemap.h>

--- 4354 unchanged lines hidden (view full) ---

4363 block_rsv = root->block_rsv;
4364
4365 if (!block_rsv)
4366 block_rsv = &fs_info->empty_block_rsv;
4367
4368 return block_rsv;
4369}
4370
4371int btrfs_block_rsv_use_bytes(struct btrfs_block_rsv *block_rsv, u64 num_bytes)
4372{
4373 int ret = -ENOSPC;
4374 spin_lock(&block_rsv->lock);
4375 if (block_rsv->reserved >= num_bytes) {
4376 block_rsv->reserved -= num_bytes;
4377 if (block_rsv->reserved < block_rsv->size)
4378 block_rsv->full = 0;
4379 ret = 0;
4380 }
4381 spin_unlock(&block_rsv->lock);
4382 return ret;
4383}
4384
4385void btrfs_block_rsv_add_bytes(struct btrfs_block_rsv *block_rsv,
4386 u64 num_bytes, bool update_size)
4387{
4388 spin_lock(&block_rsv->lock);
4389 block_rsv->reserved += num_bytes;
4390 if (update_size)
4391 block_rsv->size += num_bytes;
4392 else if (block_rsv->reserved >= block_rsv->size)
4393 block_rsv->full = 1;
4394 spin_unlock(&block_rsv->lock);
4395}
4396
4397int btrfs_cond_migrate_bytes(struct btrfs_fs_info *fs_info,
4398 struct btrfs_block_rsv *dest, u64 num_bytes,
4399 int min_factor)
4400{
4401 struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv;
4402 u64 min_bytes;
4403
4404 if (global_rsv->space_info != dest->space_info)
4405 return -ENOSPC;
4406
4407 spin_lock(&global_rsv->lock);
4408 min_bytes = div_factor(global_rsv->size, min_factor);
4409 if (global_rsv->reserved < min_bytes + num_bytes) {
4410 spin_unlock(&global_rsv->lock);
4411 return -ENOSPC;
4412 }
4413 global_rsv->reserved -= num_bytes;
4414 if (global_rsv->reserved < global_rsv->size)
4415 global_rsv->full = 0;
4416 spin_unlock(&global_rsv->lock);
4417
4418 btrfs_block_rsv_add_bytes(dest, num_bytes, true);
4419 return 0;
4420}
4421
4422/**
4423 * btrfs_migrate_to_delayed_refs_rsv - transfer bytes to our delayed refs rsv.
4424 * @fs_info - the fs info for our fs.
4425 * @src - the source block rsv to transfer from.
4426 * @num_bytes - the number of bytes to transfer.
4427 *
4428 * This transfers up to the num_bytes amount from the src rsv to the
4429 * delayed_refs_rsv. Any extra bytes are returned to the space info.

--- 68 unchanged lines hidden (view full) ---

4498 if (ret)
4499 return ret;
4500 btrfs_block_rsv_add_bytes(block_rsv, num_bytes, 0);
4501 trace_btrfs_space_reservation(fs_info, "delayed_refs_rsv",
4502 0, num_bytes, 1);
4503 return 0;
4504}
4505
4371/**
4372 * btrfs_migrate_to_delayed_refs_rsv - transfer bytes to our delayed refs rsv.
4373 * @fs_info - the fs info for our fs.
4374 * @src - the source block rsv to transfer from.
4375 * @num_bytes - the number of bytes to transfer.
4376 *
4377 * This transfers up to the num_bytes amount from the src rsv to the
4378 * delayed_refs_rsv. Any extra bytes are returned to the space info.

--- 68 unchanged lines hidden (view full) ---

4447 if (ret)
4448 return ret;
4449 btrfs_block_rsv_add_bytes(block_rsv, num_bytes, 0);
4450 trace_btrfs_space_reservation(fs_info, "delayed_refs_rsv",
4451 0, num_bytes, 1);
4452 return 0;
4453}
4454
4506static u64 block_rsv_release_bytes(struct btrfs_fs_info *fs_info,
4507 struct btrfs_block_rsv *block_rsv,
4508 struct btrfs_block_rsv *dest, u64 num_bytes,
4509 u64 *qgroup_to_release_ret)
4510{
4511 struct btrfs_space_info *space_info = block_rsv->space_info;
4512 u64 qgroup_to_release = 0;
4513 u64 ret;
4514
4515 spin_lock(&block_rsv->lock);
4516 if (num_bytes == (u64)-1) {
4517 num_bytes = block_rsv->size;
4518 qgroup_to_release = block_rsv->qgroup_rsv_size;
4519 }
4520 block_rsv->size -= num_bytes;
4521 if (block_rsv->reserved >= block_rsv->size) {
4522 num_bytes = block_rsv->reserved - block_rsv->size;
4523 block_rsv->reserved = block_rsv->size;
4524 block_rsv->full = 1;
4525 } else {
4526 num_bytes = 0;
4527 }
4528 if (block_rsv->qgroup_rsv_reserved >= block_rsv->qgroup_rsv_size) {
4529 qgroup_to_release = block_rsv->qgroup_rsv_reserved -
4530 block_rsv->qgroup_rsv_size;
4531 block_rsv->qgroup_rsv_reserved = block_rsv->qgroup_rsv_size;
4532 } else {
4533 qgroup_to_release = 0;
4534 }
4535 spin_unlock(&block_rsv->lock);
4536
4537 ret = num_bytes;
4538 if (num_bytes > 0) {
4539 if (dest) {
4540 spin_lock(&dest->lock);
4541 if (!dest->full) {
4542 u64 bytes_to_add;
4543
4544 bytes_to_add = dest->size - dest->reserved;
4545 bytes_to_add = min(num_bytes, bytes_to_add);
4546 dest->reserved += bytes_to_add;
4547 if (dest->reserved >= dest->size)
4548 dest->full = 1;
4549 num_bytes -= bytes_to_add;
4550 }
4551 spin_unlock(&dest->lock);
4552 }
4553 if (num_bytes)
4554 btrfs_space_info_add_old_bytes(fs_info, space_info,
4555 num_bytes);
4556 }
4557 if (qgroup_to_release_ret)
4558 *qgroup_to_release_ret = qgroup_to_release;
4559 return ret;
4560}
4561
4562int btrfs_block_rsv_migrate(struct btrfs_block_rsv *src,
4563 struct btrfs_block_rsv *dst, u64 num_bytes,
4564 bool update_size)
4565{
4566 int ret;
4567
4568 ret = btrfs_block_rsv_use_bytes(src, num_bytes);
4569 if (ret)
4570 return ret;
4571
4572 btrfs_block_rsv_add_bytes(dst, num_bytes, update_size);
4573 return 0;
4574}
4575
4576void btrfs_init_block_rsv(struct btrfs_block_rsv *rsv, unsigned short type)
4577{
4578 memset(rsv, 0, sizeof(*rsv));
4579 spin_lock_init(&rsv->lock);
4580 rsv->type = type;
4581}
4582
4583void btrfs_init_metadata_block_rsv(struct btrfs_fs_info *fs_info,
4584 struct btrfs_block_rsv *rsv,
4585 unsigned short type)
4586{
4587 btrfs_init_block_rsv(rsv, type);
4588 rsv->space_info = btrfs_find_space_info(fs_info,
4589 BTRFS_BLOCK_GROUP_METADATA);
4590}
4591
4592struct btrfs_block_rsv *btrfs_alloc_block_rsv(struct btrfs_fs_info *fs_info,
4593 unsigned short type)
4594{
4595 struct btrfs_block_rsv *block_rsv;
4596
4597 block_rsv = kmalloc(sizeof(*block_rsv), GFP_NOFS);
4598 if (!block_rsv)
4599 return NULL;
4600
4601 btrfs_init_metadata_block_rsv(fs_info, block_rsv, type);
4602 return block_rsv;
4603}
4604
4605void btrfs_free_block_rsv(struct btrfs_fs_info *fs_info,
4606 struct btrfs_block_rsv *rsv)
4607{
4608 if (!rsv)
4609 return;
4610 btrfs_block_rsv_release(fs_info, rsv, (u64)-1);
4611 kfree(rsv);
4612}
4613
4614int btrfs_block_rsv_add(struct btrfs_root *root,
4615 struct btrfs_block_rsv *block_rsv, u64 num_bytes,
4616 enum btrfs_reserve_flush_enum flush)
4617{
4618 int ret;
4619
4620 if (num_bytes == 0)
4621 return 0;
4622
4623 ret = btrfs_reserve_metadata_bytes(root, block_rsv, num_bytes, flush);
4624 if (!ret)
4625 btrfs_block_rsv_add_bytes(block_rsv, num_bytes, true);
4626
4627 return ret;
4628}
4629
4630int btrfs_block_rsv_check(struct btrfs_block_rsv *block_rsv, int min_factor)
4631{
4632 u64 num_bytes = 0;
4633 int ret = -ENOSPC;
4634
4635 if (!block_rsv)
4636 return 0;
4637
4638 spin_lock(&block_rsv->lock);
4639 num_bytes = div_factor(block_rsv->size, min_factor);
4640 if (block_rsv->reserved >= num_bytes)
4641 ret = 0;
4642 spin_unlock(&block_rsv->lock);
4643
4644 return ret;
4645}
4646
4647int btrfs_block_rsv_refill(struct btrfs_root *root,
4648 struct btrfs_block_rsv *block_rsv, u64 min_reserved,
4649 enum btrfs_reserve_flush_enum flush)
4650{
4651 u64 num_bytes = 0;
4652 int ret = -ENOSPC;
4653
4654 if (!block_rsv)
4655 return 0;
4656
4657 spin_lock(&block_rsv->lock);
4658 num_bytes = min_reserved;
4659 if (block_rsv->reserved >= num_bytes)
4660 ret = 0;
4661 else
4662 num_bytes -= block_rsv->reserved;
4663 spin_unlock(&block_rsv->lock);
4664
4665 if (!ret)
4666 return 0;
4667
4668 ret = btrfs_reserve_metadata_bytes(root, block_rsv, num_bytes, flush);
4669 if (!ret) {
4670 btrfs_block_rsv_add_bytes(block_rsv, num_bytes, false);
4671 return 0;
4672 }
4673
4674 return ret;
4675}
4676
4677u64 __btrfs_block_rsv_release(struct btrfs_fs_info *fs_info,
4678 struct btrfs_block_rsv *block_rsv,
4679 u64 num_bytes, u64 *qgroup_to_release)
4680{
4681 struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv;
4682 struct btrfs_block_rsv *delayed_rsv = &fs_info->delayed_refs_rsv;
4683 struct btrfs_block_rsv *target = NULL;
4684
4685 /*
4686 * If we are the delayed_rsv then push to the global rsv, otherwise dump
4687 * into the delayed rsv if it is not full.
4688 */
4689 if (block_rsv == delayed_rsv)
4690 target = global_rsv;
4691 else if (block_rsv != global_rsv && !delayed_rsv->full)
4692 target = delayed_rsv;
4693
4694 if (target && block_rsv->space_info != target->space_info)
4695 target = NULL;
4696
4697 return block_rsv_release_bytes(fs_info, block_rsv, target, num_bytes,
4698 qgroup_to_release);
4699}
4700
4701/**
4702 * btrfs_inode_rsv_release - release any excessive reservation.
4703 * @inode - the inode we need to release from.
4704 * @qgroup_free - free or convert qgroup meta.
4705 * Unlike normal operation, qgroup meta reservation needs to know if we are
4706 * freeing qgroup reservation or just converting it into per-trans. Normally
4707 * @qgroup_free is true for error handling, and false for normal release.
4708 *

--- 5555 unchanged lines hidden --- 		4455/**
4456 * btrfs_inode_rsv_release - release any excessive reservation.
4457 * @inode - the inode we need to release from.
4458 * @qgroup_free - free or convert qgroup meta.
4459 * Unlike normal operation, qgroup meta reservation needs to know if we are
4460 * freeing qgroup reservation or just converting it into per-trans. Normally
4461 * @qgroup_free is true for error handling, and false for normal release.
4462 *

--- 5555 unchanged lines hidden ---