linux-imx

// SPDX-License-Identifier: GPL-2.0

/*

 * Copyright (C) 2009 Oracle.  All rights reserved.

 */

​

#include <linux/sched.h>

#include <linux/slab.h>

#include <linux/sort.h>

#include "ctree.h"

#include "delayed-ref.h"

#include "transaction.h"

#include "qgroup.h"

​

struct kmem_cache *btrfs_delayed_ref_head_cachep;

struct kmem_cache *btrfs_delayed_tree_ref_cachep;

struct kmem_cache *btrfs_delayed_data_ref_cachep;

struct kmem_cache *btrfs_delayed_extent_op_cachep;

/*

 * delayed back reference update tracking.  For subvolume trees

 * we queue up extent allocations and backref maintenance for

 * delayed processing.   This avoids deep call chains where we

 * add extents in the middle of btrfs_search_slot, and it allows

 * us to buffer up frequently modified backrefs in an rb tree instead

 * of hammering updates on the extent allocation tree.

 */

​

/*

 * compare two delayed tree backrefs with same bytenr and type

 */

static int comp_tree_refs(struct btrfs_delayed_tree_ref *ref1,

              struct btrfs_delayed_tree_ref *ref2)

{

    if (ref1->node.type == BTRFS_TREE_BLOCK_REF_KEY) {

        if (ref1->root < ref2->root)

            return -1;

        if (ref1->root > ref2->root)

            return 1;

    } else {

        if (ref1->parent < ref2->parent)

            return -1;

        if (ref1->parent > ref2->parent)

            return 1;

    }

    return 0;

}

​

/*

 * compare two delayed data backrefs with same bytenr and type

 */

static int comp_data_refs(struct btrfs_delayed_data_ref *ref1,

              struct btrfs_delayed_data_ref *ref2)

{

    if (ref1->node.type == BTRFS_EXTENT_DATA_REF_KEY) {

        if (ref1->root < ref2->root)

            return -1;

        if (ref1->root > ref2->root)

            return 1;

        if (ref1->objectid < ref2->objectid)

            return -1;

        if (ref1->objectid > ref2->objectid)

            return 1;

        if (ref1->offset < ref2->offset)

            return -1;

        if (ref1->offset > ref2->offset)

            return 1;

    } else {

        if (ref1->parent < ref2->parent)

            return -1;

        if (ref1->parent > ref2->parent)

            return 1;

    }

    return 0;

}

​

static int comp_refs(struct btrfs_delayed_ref_node *ref1,

             struct btrfs_delayed_ref_node *ref2,

             bool check_seq)

{

    int ret = 0;

​

    if (ref1->type < ref2->type)

        return -1;

    if (ref1->type > ref2->type)

        return 1;

    if (ref1->type == BTRFS_TREE_BLOCK_REF_KEY ||

        ref1->type == BTRFS_SHARED_BLOCK_REF_KEY)

        ret = comp_tree_refs(btrfs_delayed_node_to_tree_ref(ref1),

                     btrfs_delayed_node_to_tree_ref(ref2));

    else

        ret = comp_data_refs(btrfs_delayed_node_to_data_ref(ref1),

                     btrfs_delayed_node_to_data_ref(ref2));

    if (ret)