[linux.git] / fs / btrfs / delayed-inode.h

/* SPDX-License-Identifier: GPL-2.0 */
/*
 * Copyright (C) 2011 Fujitsu.  All rights reserved.
 * Written by Miao Xie <[email protected]>
 */

#ifndef BTRFS_DELAYED_INODE_H
#define BTRFS_DELAYED_INODE_H

#include <linux/rbtree.h>
#include <linux/spinlock.h>
#include <linux/mutex.h>
#include <linux/list.h>
#include <linux/wait.h>
#include <linux/atomic.h>
#include <linux/refcount.h>
#include "ctree.h"

/* types of the delayed item */
#define BTRFS_DELAYED_INSERTION_ITEM	1
#define BTRFS_DELAYED_DELETION_ITEM	2

struct btrfs_delayed_root {
	spinlock_t lock;
	struct list_head node_list;
	/*
	 * Used for delayed nodes which is waiting to be dealt with by the
	 * worker. If the delayed node is inserted into the work queue, we
	 * drop it from this list.
	 */
	struct list_head prepare_list;
	atomic_t items;		/* for delayed items */
	atomic_t items_seq;	/* for delayed items */
	int nodes;		/* for delayed nodes */
	wait_queue_head_t wait;
};

#define BTRFS_DELAYED_NODE_IN_LIST	0
#define BTRFS_DELAYED_NODE_INODE_DIRTY	1
#define BTRFS_DELAYED_NODE_DEL_IREF	2

struct btrfs_delayed_node {
	u64 inode_id;
	u64 bytes_reserved;
	struct btrfs_root *root;
	/* Used to add the node into the delayed root's node list. */
	struct list_head n_list;
	/*
	 * Used to add the node into the prepare list, the nodes in this list
	 * is waiting to be dealt with by the async worker.
	 */
	struct list_head p_list;
	struct rb_root_cached ins_root;
	struct rb_root_cached del_root;
	struct mutex mutex;
	struct btrfs_inode_item inode_item;
	refcount_t refs;
	u64 index_cnt;
	unsigned long flags;
	int count;
};

struct btrfs_delayed_item {
	struct rb_node rb_node;
	struct btrfs_key key;
	struct list_head tree_list;	/* used for batch insert/delete items */
	struct list_head readdir_list;	/* used for readdir items */
	u64 bytes_reserved;
	struct btrfs_delayed_node *delayed_node;
	refcount_t refs;
	int ins_or_del;
	u32 data_len;
	char data[0];
};

static inline void btrfs_init_delayed_root(
				struct btrfs_delayed_root *delayed_root)
{
	atomic_set(&delayed_root->items, 0);
	atomic_set(&delayed_root->items_seq, 0);
	delayed_root->nodes = 0;
	spin_lock_init(&delayed_root->lock);
	init_waitqueue_head(&delayed_root->wait);
	INIT_LIST_HEAD(&delayed_root->node_list);
	INIT_LIST_HEAD(&delayed_root->prepare_list);
}

int btrfs_insert_delayed_dir_index(struct btrfs_trans_handle *trans,
				   const char *name, int name_len,
				   struct btrfs_inode *dir,
				   struct btrfs_disk_key *disk_key, u8 type,
				   u64 index);

int btrfs_delete_delayed_dir_index(struct btrfs_trans_handle *trans,
				   struct btrfs_inode *dir, u64 index);

int btrfs_inode_delayed_dir_index_count(struct btrfs_inode *inode);

int btrfs_run_delayed_items(struct btrfs_trans_handle *trans);
int btrfs_run_delayed_items_nr(struct btrfs_trans_handle *trans, int nr);

void btrfs_balance_delayed_items(struct btrfs_fs_info *fs_info);

int btrfs_commit_inode_delayed_items(struct btrfs_trans_handle *trans,
				     struct btrfs_inode *inode);
/* Used for evicting the inode. */
void btrfs_remove_delayed_node(struct btrfs_inode *inode);
void btrfs_kill_delayed_inode_items(struct btrfs_inode *inode);
int btrfs_commit_inode_delayed_inode(struct btrfs_inode *inode);


int btrfs_delayed_update_inode(struct btrfs_trans_handle *trans,
			       struct btrfs_root *root, struct inode *inode);
int btrfs_fill_inode(struct inode *inode, u32 *rdev);
int btrfs_delayed_delete_inode_ref(struct btrfs_inode *inode);

/* Used for drop dead root */
void btrfs_kill_all_delayed_nodes(struct btrfs_root *root);

/* Used for clean the transaction */
void btrfs_destroy_delayed_inodes(struct btrfs_fs_info *fs_info);

/* Used for readdir() */
bool btrfs_readdir_get_delayed_items(struct inode *inode,
				     struct list_head *ins_list,
				     struct list_head *del_list);
void btrfs_readdir_put_delayed_items(struct inode *inode,
				     struct list_head *ins_list,
				     struct list_head *del_list);
int btrfs_should_delete_dir_index(struct list_head *del_list,
				  u64 index);
int btrfs_readdir_delayed_dir_index(struct dir_context *ctx,
				    struct list_head *ins_list);

/* for init */
int __init btrfs_delayed_inode_init(void);
void __cold btrfs_delayed_inode_exit(void);

/* for debugging */
void btrfs_assert_delayed_root_empty(struct btrfs_fs_info *fs_info);

#endif
Commit	Line	Data
9888c340	1	/* SPDX-License-Identifier: GPL-2.0 */
16cdcec7 MX	2	/*
	3	* Copyright (C) 2011 Fujitsu. All rights reserved.
	4	* Written by Miao Xie <[email protected]>
16cdcec7 MX	5	*/
16cdcec7 MX	6
9888c340 DS	7	#ifndef BTRFS_DELAYED_INODE_H
9888c340 DS	8	#define BTRFS_DELAYED_INODE_H
16cdcec7 MX	9
	10	#include <linux/rbtree.h>
	11	#include <linux/spinlock.h>
	12	#include <linux/mutex.h>
	13	#include <linux/list.h>
	14	#include <linux/wait.h>
60063497	15	#include <linux/atomic.h>
6de5f18e	16	#include <linux/refcount.h>
16cdcec7 MX	17	#include "ctree.h"
	18
	19	/* types of the delayed item */
	20	#define BTRFS_DELAYED_INSERTION_ITEM 1
	21	#define BTRFS_DELAYED_DELETION_ITEM 2
	22
	23	struct btrfs_delayed_root {
	24	spinlock_t lock;
	25	struct list_head node_list;
	26	/*
	27	* Used for delayed nodes which is waiting to be dealt with by the
	28	* worker. If the delayed node is inserted into the work queue, we
	29	* drop it from this list.
	30	*/
	31	struct list_head prepare_list;
	32	atomic_t items; /* for delayed items */
de3cb945	33	atomic_t items_seq; /* for delayed items */
16cdcec7 MX	34	int nodes; /* for delayed nodes */
	35	wait_queue_head_t wait;
	36	};
	37
7cf35d91 MX	38	#define BTRFS_DELAYED_NODE_IN_LIST 0
7cf35d91 MX	39	#define BTRFS_DELAYED_NODE_INODE_DIRTY 1
67de1176	40	#define BTRFS_DELAYED_NODE_DEL_IREF 2
7cf35d91	41
16cdcec7 MX	42	struct btrfs_delayed_node {
	43	u64 inode_id;
	44	u64 bytes_reserved;
	45	struct btrfs_root *root;
	46	/* Used to add the node into the delayed root's node list. */
	47	struct list_head n_list;
	48	/*
	49	* Used to add the node into the prepare list, the nodes in this list
	50	* is waiting to be dealt with by the async worker.
	51	*/
	52	struct list_head p_list;
03a1d4c8 LB	53	struct rb_root_cached ins_root;
03a1d4c8 LB	54	struct rb_root_cached del_root;
16cdcec7 MX	55	struct mutex mutex;
16cdcec7 MX	56	struct btrfs_inode_item inode_item;
6de5f18e	57	refcount_t refs;
16cdcec7	58	u64 index_cnt;
7cf35d91	59	unsigned long flags;
16cdcec7 MX	60	int count;
	61	};
	62
	63	struct btrfs_delayed_item {
	64	struct rb_node rb_node;
	65	struct btrfs_key key;
	66	struct list_head tree_list; /* used for batch insert/delete items */
	67	struct list_head readdir_list; /* used for readdir items */
	68	u64 bytes_reserved;
16cdcec7	69	struct btrfs_delayed_node *delayed_node;
089e77e1	70	refcount_t refs;
16cdcec7 MX	71	int ins_or_del;
	72	u32 data_len;
	73	char data[0];
	74	};
	75
	76	static inline void btrfs_init_delayed_root(
	77	struct btrfs_delayed_root *delayed_root)
	78	{
	79	atomic_set(&delayed_root->items, 0);
de3cb945	80	atomic_set(&delayed_root->items_seq, 0);
16cdcec7 MX	81	delayed_root->nodes = 0;
	82	spin_lock_init(&delayed_root->lock);
	83	init_waitqueue_head(&delayed_root->wait);
	84	INIT_LIST_HEAD(&delayed_root->node_list);
	85	INIT_LIST_HEAD(&delayed_root->prepare_list);
	86	}
	87
	88	int btrfs_insert_delayed_dir_index(struct btrfs_trans_handle *trans,
2ff7e61e	89	const char *name, int name_len,
6f45d185	90	struct btrfs_inode *dir,
16cdcec7 MX	91	struct btrfs_disk_key *disk_key, u8 type,
	92	u64 index);
	93
	94	int btrfs_delete_delayed_dir_index(struct btrfs_trans_handle *trans,
e67bbbb9	95	struct btrfs_inode *dir, u64 index);
16cdcec7	96
f5cc7b80	97	int btrfs_inode_delayed_dir_index_count(struct btrfs_inode *inode);
16cdcec7	98
e5c304e6 NB	99	int btrfs_run_delayed_items(struct btrfs_trans_handle *trans);
e5c304e6 NB	100	int btrfs_run_delayed_items_nr(struct btrfs_trans_handle *trans, int nr);
16cdcec7	101
2ff7e61e	102	void btrfs_balance_delayed_items(struct btrfs_fs_info *fs_info);
16cdcec7 MX	103
16cdcec7 MX	104	int btrfs_commit_inode_delayed_items(struct btrfs_trans_handle *trans,
5f4b32e9	105	struct btrfs_inode *inode);
16cdcec7	106	/* Used for evicting the inode. */
f48d1cf5	107	void btrfs_remove_delayed_node(struct btrfs_inode *inode);
4ccb5c72	108	void btrfs_kill_delayed_inode_items(struct btrfs_inode *inode);
aa79021f	109	int btrfs_commit_inode_delayed_inode(struct btrfs_inode *inode);
16cdcec7 MX	110
	111
	112	int btrfs_delayed_update_inode(struct btrfs_trans_handle *trans,
	113	struct btrfs_root root, struct inode inode);
2f7e33d4	114	int btrfs_fill_inode(struct inode inode, u32 rdev);
e07222c7	115	int btrfs_delayed_delete_inode_ref(struct btrfs_inode *inode);
16cdcec7 MX	116
	117	/* Used for drop dead root */
	118	void btrfs_kill_all_delayed_nodes(struct btrfs_root *root);
	119
67cde344	120	/* Used for clean the transaction */
ccdf9b30	121	void btrfs_destroy_delayed_inodes(struct btrfs_fs_info *fs_info);
67cde344	122
16cdcec7	123	/* Used for readdir() */
02dbfc99 OS	124	bool btrfs_readdir_get_delayed_items(struct inode *inode,
	125	struct list_head *ins_list,
	126	struct list_head *del_list);
	127	void btrfs_readdir_put_delayed_items(struct inode *inode,
	128	struct list_head *ins_list,
	129	struct list_head *del_list);
16cdcec7 MX	130	int btrfs_should_delete_dir_index(struct list_head *del_list,
16cdcec7 MX	131	u64 index);
9cdda8d3	132	int btrfs_readdir_delayed_dir_index(struct dir_context *ctx,
d2fbb2b5	133	struct list_head *ins_list);
16cdcec7 MX	134
	135	/* for init */
	136	int __init btrfs_delayed_inode_init(void);
e67c718b	137	void __cold btrfs_delayed_inode_exit(void);
e999376f CM	138
e999376f CM	139	/* for debugging */
ccdf9b30	140	void btrfs_assert_delayed_root_empty(struct btrfs_fs_info *fs_info);
e999376f	141
16cdcec7	142	#endif