linux-imx

// SPDX-License-Identifier: GPL-2.0

/*

 * Copyright (C) 2011 Fujitsu.  All rights reserved.

 * Written by Miao Xie <miaox@cn.fujitsu.com>

 */

​

#include <linux/slab.h>

#include <linux/iversion.h>

#include "delayed-inode.h"

#include "disk-io.h"

#include "transaction.h"

#include "ctree.h"

#include "qgroup.h"

​

#define BTRFS_DELAYED_WRITEBACK     512

#define BTRFS_DELAYED_BACKGROUND    128

#define BTRFS_DELAYED_BATCH     16

​

static struct kmem_cache *delayed_node_cache;

​

int __init btrfs_delayed_inode_init(void)

{

    delayed_node_cache = kmem_cache_create("btrfs_delayed_node",

                    sizeof(struct btrfs_delayed_node),

                    0,

                    SLAB_MEM_SPREAD,

                    NULL);

    if (!delayed_node_cache)

        return -ENOMEM;

    return 0;

}

​

void __cold btrfs_delayed_inode_exit(void)

{

    kmem_cache_destroy(delayed_node_cache);

}

​

static inline void btrfs_init_delayed_node(

                struct btrfs_delayed_node *delayed_node,

                struct btrfs_root *root, u64 inode_id)

{

    delayed_node->root = root;

    delayed_node->inode_id = inode_id;

    refcount_set(&delayed_node->refs, 0);

    delayed_node->ins_root = RB_ROOT_CACHED;

    delayed_node->del_root = RB_ROOT_CACHED;

    mutex_init(&delayed_node->mutex);

    INIT_LIST_HEAD(&delayed_node->n_list);

    INIT_LIST_HEAD(&delayed_node->p_list);

}

​

static inline int btrfs_is_continuous_delayed_item(

                    struct btrfs_delayed_item *item1,

                    struct btrfs_delayed_item *item2)

{

    if (item1->key.type == BTRFS_DIR_INDEX_KEY &&

        item1->key.objectid == item2->key.objectid &&

        item1->key.type == item2->key.type &&

        item1->key.offset + 1 == item2->key.offset)

        return 1;

    return 0;

}

​

static struct btrfs_delayed_node *btrfs_get_delayed_node(

        struct btrfs_inode *btrfs_inode)

{

    struct btrfs_root *root = btrfs_inode->root;

    u64 ino = btrfs_ino(btrfs_inode);

    struct btrfs_delayed_node *node;

​

    node = READ_ONCE(btrfs_inode->delayed_node);

    if (node) {

        refcount_inc(&node->refs);

        return node;

    }

​

    spin_lock(&root->inode_lock);

    node = radix_tree_lookup(&root->delayed_nodes_tree, ino);

​

    if (node) {

        if (btrfs_inode->delayed_node) {

            refcount_inc(&node->refs);  /* can be accessed */

            BUG_ON(btrfs_inode->delayed_node != node);

            spin_unlock(&root->inode_lock);

            return node;

        }

​

        /*

         * It's possible that we're racing into the middle of removing

         * this node from the radix tree.  In this case, the refcount

         * was zero and it should never go back to one.  Just return

         * NULL like it was never in the radix at all; our release