1/*
  2 * Copyright (C) 2007 Oracle.  All rights reserved.
  3 *
  4 * This program is free software; you can redistribute it and/or
  5 * modify it under the terms of the GNU General Public
  6 * License v2 as published by the Free Software Foundation.
  7 *
  8 * This program is distributed in the hope that it will be useful,
  9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 11 * General Public License for more details.
 12 *
 13 * You should have received a copy of the GNU General Public
 14 * License along with this program; if not, write to the
 15 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 16 * Boston, MA 021110-1307, USA.
 17 */
 18
 19#ifndef __BTRFS_ORDERED_DATA__
 20#define __BTRFS_ORDERED_DATA__
 21
 22/* one of these per inode */
 23struct btrfs_ordered_inode_tree {
 24	spinlock_t lock;
 25	struct rb_root tree;
 26	struct rb_node *last;
 27};
 28
 29struct btrfs_ordered_sum {
 30	/* bytenr is the start of this extent on disk */
 31	u64 bytenr;
 32
 33	/*
 34	 * this is the length in bytes covered by the sums array below.
 35	 */
 36	int len;
 37	struct list_head list;
 38	/* last field is a variable length array of csums */
 39	u32 sums[];
 40};
 41
 42/*
 43 * bits for the flags field:
 44 *
 45 * BTRFS_ORDERED_IO_DONE is set when all of the blocks are written.
 46 * It is used to make sure metadata is inserted into the tree only once
 47 * per extent.
 48 *
 49 * BTRFS_ORDERED_COMPLETE is set when the extent is removed from the
 50 * rbtree, just before waking any waiters.  It is used to indicate the
 51 * IO is done and any metadata is inserted into the tree.
 52 */
 53#define BTRFS_ORDERED_IO_DONE 0 /* set when all the pages are written */
 54
 55#define BTRFS_ORDERED_COMPLETE 1 /* set when removed from the tree */
 56
 57#define BTRFS_ORDERED_NOCOW 2 /* set when we want to write in place */
 58
 59#define BTRFS_ORDERED_COMPRESSED 3 /* writing a zlib compressed extent */
 
 
 
 
 
 
 
 60
 61#define BTRFS_ORDERED_PREALLOC 4 /* set when writing to prealloced extent */
 
 
 
 
 62
 63#define BTRFS_ORDERED_DIRECT 5 /* set when we're doing DIO with this extent */
 64
 65#define BTRFS_ORDERED_IOERR 6 /* We had an io error when writing this out */
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 66
 67#define BTRFS_ORDERED_UPDATED_ISIZE 7 /* indicates whether this ordered extent
 68				       * has done its due diligence in updating
 69				       * the isize. */
 70#define BTRFS_ORDERED_LOGGED_CSUM 8 /* We've logged the csums on this ordered
 71				       ordered extent */
 72#define BTRFS_ORDERED_TRUNCATED 9 /* Set when we have to truncate an extent */
 
 73
 74struct btrfs_ordered_extent {
 75	/* logical offset in the file */
 76	u64 file_offset;
 77
 78	/* disk byte number */
 79	u64 start;
 80
 81	/* ram length of the extent in bytes */
 82	u64 len;
 83
 84	/* extent length on disk */
 85	u64 disk_len;
 
 86
 87	/* number of bytes that still need writing */
 88	u64 bytes_left;
 89
 90	/* number of bytes that still need csumming */
 91	u64 csum_bytes_left;
 92
 93	/*
 94	 * the end of the ordered extent which is behind it but
 95	 * didn't update disk_i_size. Please see the comment of
 96	 * btrfs_ordered_update_i_size();
 97	 */
 98	u64 outstanding_isize;
 99
100	/*
101	 * If we get truncated we need to adjust the file extent we enter for
102	 * this ordered extent so that we do not expose stale data.
103	 */
104	u64 truncated_len;
105
106	/* flags (described above) */
107	unsigned long flags;
108
109	/* compression algorithm */
110	int compress_type;
111
 
 
 
112	/* reference count */
113	atomic_t refs;
114
115	/* the inode we belong to */
116	struct inode *inode;
117
118	/* list of checksums for insertion when the extent io is done */
119	struct list_head list;
120
121	/* If we need to wait on this to be done */
122	struct list_head log_list;
123
124	/* used to wait for the BTRFS_ORDERED_COMPLETE bit */
125	wait_queue_head_t wait;
126
127	/* our friendly rbtree entry */
128	struct rb_node rb_node;
129
130	/* a per root list of all the pending ordered extents */
131	struct list_head root_extent_list;
132
133	struct btrfs_work work;
134
135	struct completion completion;
136	struct btrfs_work flush_work;
137	struct list_head work_list;
138};
139
140/*
141 * calculates the total size you need to allocate for an ordered sum
142 * structure spanning 'bytes' in the file
143 */
144static inline int btrfs_ordered_sum_size(struct btrfs_root *root,
145					 unsigned long bytes)
146{
147	int num_sectors = (int)DIV_ROUND_UP(bytes, root->sectorsize);
148	return sizeof(struct btrfs_ordered_sum) + num_sectors * sizeof(u32);
149}
150
151static inline void
152btrfs_ordered_inode_tree_init(struct btrfs_ordered_inode_tree *t)
153{
154	spin_lock_init(&t->lock);
155	t->tree = RB_ROOT;
156	t->last = NULL;
157}
158
 
 
159void btrfs_put_ordered_extent(struct btrfs_ordered_extent *entry);
160void btrfs_remove_ordered_extent(struct inode *inode,
161				struct btrfs_ordered_extent *entry);
162int btrfs_dec_test_ordered_pending(struct inode *inode,
163				   struct btrfs_ordered_extent **cached,
164				   u64 file_offset, u64 io_size, int uptodate);
165int btrfs_dec_test_first_ordered_pending(struct inode *inode,
166				   struct btrfs_ordered_extent **cached,
167				   u64 *file_offset, u64 io_size,
168				   int uptodate);
169int btrfs_add_ordered_extent(struct inode *inode, u64 file_offset,
170			     u64 start, u64 len, u64 disk_len, int type);
171int btrfs_add_ordered_extent_dio(struct inode *inode, u64 file_offset,
172				 u64 start, u64 len, u64 disk_len, int type);
173int btrfs_add_ordered_extent_compress(struct inode *inode, u64 file_offset,
174				      u64 start, u64 len, u64 disk_len,
175				      int type, int compress_type);
176void btrfs_add_ordered_sum(struct inode *inode,
177			   struct btrfs_ordered_extent *entry,
178			   struct btrfs_ordered_sum *sum);
179struct btrfs_ordered_extent *btrfs_lookup_ordered_extent(struct inode *inode,
180							 u64 file_offset);
181void btrfs_start_ordered_extent(struct inode *inode,
182				struct btrfs_ordered_extent *entry, int wait);
183int btrfs_wait_ordered_range(struct inode *inode, u64 start, u64 len);
184struct btrfs_ordered_extent *
185btrfs_lookup_first_ordered_extent(struct inode * inode, u64 file_offset);
186struct btrfs_ordered_extent *btrfs_lookup_ordered_range(struct inode *inode,
187							u64 file_offset,
188							u64 len);
189int btrfs_ordered_update_i_size(struct inode *inode, u64 offset,
190				struct btrfs_ordered_extent *ordered);
191int btrfs_find_ordered_sum(struct inode *inode, u64 offset, u64 disk_bytenr,
192			   u32 *sum, int len);
193int btrfs_run_ordered_operations(struct btrfs_trans_handle *trans,
194				 struct btrfs_root *root, int wait);
195void btrfs_add_ordered_operation(struct btrfs_trans_handle *trans,
196				 struct btrfs_root *root,
197				 struct inode *inode);
198int btrfs_wait_ordered_extents(struct btrfs_root *root, int nr);
199void btrfs_wait_ordered_roots(struct btrfs_fs_info *fs_info, int nr);
200void btrfs_get_logged_extents(struct inode *inode,
201			      struct list_head *logged_list);
202void btrfs_put_logged_extents(struct list_head *logged_list);
203void btrfs_submit_logged_extents(struct list_head *logged_list,
204				 struct btrfs_root *log);
205void btrfs_wait_logged_extents(struct btrfs_root *log, u64 transid);
206void btrfs_free_logged_extents(struct btrfs_root *log, u64 transid);
207int __init ordered_data_init(void);
208void ordered_data_exit(void);
 
209#endif

  1/* SPDX-License-Identifier: GPL-2.0 */
  2/*
  3 * Copyright (C) 2007 Oracle.  All rights reserved.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  4 */
  5
  6#ifndef BTRFS_ORDERED_DATA_H
  7#define BTRFS_ORDERED_DATA_H
  8
  9/* one of these per inode */
 10struct btrfs_ordered_inode_tree {
 11	spinlock_t lock;
 12	struct rb_root tree;
 13	struct rb_node *last;
 14};
 15
 16struct btrfs_ordered_sum {
 17	/* bytenr is the start of this extent on disk */
 18	u64 bytenr;
 19
 20	/*
 21	 * this is the length in bytes covered by the sums array below.
 22	 */
 23	int len;
 24	struct list_head list;
 25	/* last field is a variable length array of csums */
 26	u8 sums[];
 27};
 28
 29/*
 30 * Bits for btrfs_ordered_extent::flags.
 31 *
 32 * BTRFS_ORDERED_IO_DONE is set when all of the blocks are written.
 33 * It is used to make sure metadata is inserted into the tree only once
 34 * per extent.
 35 *
 36 * BTRFS_ORDERED_COMPLETE is set when the extent is removed from the
 37 * rbtree, just before waking any waiters.  It is used to indicate the
 38 * IO is done and any metadata is inserted into the tree.
 39 */
 40enum {
 41	/*
 42	 * Different types for ordered extents, one and only one of the 4 types
 43	 * need to be set when creating ordered extent.
 44	 *
 45	 * REGULAR:	For regular non-compressed COW write
 46	 * NOCOW:	For NOCOW write into existing non-hole extent
 47	 * PREALLOC:	For NOCOW write into preallocated extent
 48	 * COMPRESSED:	For compressed COW write
 49	 */
 50	BTRFS_ORDERED_REGULAR,
 51	BTRFS_ORDERED_NOCOW,
 52	BTRFS_ORDERED_PREALLOC,
 53	BTRFS_ORDERED_COMPRESSED,
 54
 55	/*
 56	 * Extra bit for direct io, can only be set for
 57	 * REGULAR/NOCOW/PREALLOC. No direct io for compressed extent.
 58	 */
 59	BTRFS_ORDERED_DIRECT,
 60
 61	/* Extra status bits for ordered extents */
 62
 63	/* set when all the pages are written */
 64	BTRFS_ORDERED_IO_DONE,
 65	/* set when removed from the tree */
 66	BTRFS_ORDERED_COMPLETE,
 67	/* We had an io error when writing this out */
 68	BTRFS_ORDERED_IOERR,
 69	/* Set when we have to truncate an extent */
 70	BTRFS_ORDERED_TRUNCATED,
 71	/* Used during fsync to track already logged extents */
 72	BTRFS_ORDERED_LOGGED,
 73	/* We have already logged all the csums of the ordered extent */
 74	BTRFS_ORDERED_LOGGED_CSUM,
 75	/* We wait for this extent to complete in the current transaction */
 76	BTRFS_ORDERED_PENDING,
 77	/* BTRFS_IOC_ENCODED_WRITE */
 78	BTRFS_ORDERED_ENCODED,
 79};
 80
 81/* BTRFS_ORDERED_* flags that specify the type of the extent. */
 82#define BTRFS_ORDERED_TYPE_FLAGS ((1UL << BTRFS_ORDERED_REGULAR) |	\
 83				  (1UL << BTRFS_ORDERED_NOCOW) |	\
 84				  (1UL << BTRFS_ORDERED_PREALLOC) |	\
 85				  (1UL << BTRFS_ORDERED_COMPRESSED) |	\
 86				  (1UL << BTRFS_ORDERED_DIRECT) |	\
 87				  (1UL << BTRFS_ORDERED_ENCODED))
 88
 89struct btrfs_ordered_extent {
 90	/* logical offset in the file */
 91	u64 file_offset;
 92
 93	/*
 94	 * These fields directly correspond to the same fields in
 95	 * btrfs_file_extent_item.
 96	 */
 97	u64 num_bytes;
 98	u64 ram_bytes;
 99	u64 disk_bytenr;
100	u64 disk_num_bytes;
101	u64 offset;
102
103	/* number of bytes that still need writing */
104	u64 bytes_left;
105
 
 
 
106	/*
107	 * the end of the ordered extent which is behind it but
108	 * didn't update disk_i_size. Please see the comment of
109	 * btrfs_ordered_update_i_size();
110	 */
111	u64 outstanding_isize;
112
113	/*
114	 * If we get truncated we need to adjust the file extent we enter for
115	 * this ordered extent so that we do not expose stale data.
116	 */
117	u64 truncated_len;
118
119	/* flags (described above) */
120	unsigned long flags;
121
122	/* compression algorithm */
123	int compress_type;
124
125	/* Qgroup reserved space */
126	int qgroup_rsv;
127
128	/* reference count */
129	refcount_t refs;
130
131	/* the inode we belong to */
132	struct inode *inode;
133
134	/* list of checksums for insertion when the extent io is done */
135	struct list_head list;
136
137	/* used for fast fsyncs */
138	struct list_head log_list;
139
140	/* used to wait for the BTRFS_ORDERED_COMPLETE bit */
141	wait_queue_head_t wait;
142
143	/* our friendly rbtree entry */
144	struct rb_node rb_node;
145
146	/* a per root list of all the pending ordered extents */
147	struct list_head root_extent_list;
148
149	struct btrfs_work work;
150
151	struct completion completion;
152	struct btrfs_work flush_work;
153	struct list_head work_list;
 
154
155	/*
156	 * Used to reverse-map physical address returned from ZONE_APPEND write
157	 * command in a workqueue context
158	 */
159	u64 physical;
160	struct block_device *bdev;
161};
 
 
 
162
163static inline void
164btrfs_ordered_inode_tree_init(struct btrfs_ordered_inode_tree *t)
165{
166	spin_lock_init(&t->lock);
167	t->tree = RB_ROOT;
168	t->last = NULL;
169}
170
171int btrfs_finish_ordered_io(struct btrfs_ordered_extent *ordered_extent);
172
173void btrfs_put_ordered_extent(struct btrfs_ordered_extent *entry);
174void btrfs_remove_ordered_extent(struct btrfs_inode *btrfs_inode,
175				struct btrfs_ordered_extent *entry);
176void btrfs_mark_ordered_io_finished(struct btrfs_inode *inode,
177				struct page *page, u64 file_offset,
178				u64 num_bytes, bool uptodate);
179bool btrfs_dec_test_ordered_pending(struct btrfs_inode *inode,
180				    struct btrfs_ordered_extent **cached,
181				    u64 file_offset, u64 io_size);
182int btrfs_add_ordered_extent(struct btrfs_inode *inode, u64 file_offset,
183			     u64 num_bytes, u64 ram_bytes, u64 disk_bytenr,
184			     u64 disk_num_bytes, u64 offset, unsigned flags,
185			     int compress_type);
186void btrfs_add_ordered_sum(struct btrfs_ordered_extent *entry,
 
 
 
 
 
187			   struct btrfs_ordered_sum *sum);
188struct btrfs_ordered_extent *btrfs_lookup_ordered_extent(struct btrfs_inode *inode,
189							 u64 file_offset);
190void btrfs_start_ordered_extent(struct btrfs_ordered_extent *entry, int wait);
 
191int btrfs_wait_ordered_range(struct inode *inode, u64 start, u64 len);
192struct btrfs_ordered_extent *
193btrfs_lookup_first_ordered_extent(struct btrfs_inode *inode, u64 file_offset);
194struct btrfs_ordered_extent *btrfs_lookup_first_ordered_range(
195			struct btrfs_inode *inode, u64 file_offset, u64 len);
196struct btrfs_ordered_extent *btrfs_lookup_ordered_range(
197		struct btrfs_inode *inode,
198		u64 file_offset,
199		u64 len);
200void btrfs_get_ordered_extents_for_logging(struct btrfs_inode *inode,
201					   struct list_head *list);
202u64 btrfs_wait_ordered_extents(struct btrfs_root *root, u64 nr,
203			       const u64 range_start, const u64 range_len);
204void btrfs_wait_ordered_roots(struct btrfs_fs_info *fs_info, u64 nr,
205			      const u64 range_start, const u64 range_len);
206void btrfs_lock_and_flush_ordered_range(struct btrfs_inode *inode, u64 start,
207					u64 end,
208					struct extent_state **cached_state);
209bool btrfs_try_lock_ordered_range(struct btrfs_inode *inode, u64 start, u64 end,
210				  struct extent_state **cached_state);
211int btrfs_split_ordered_extent(struct btrfs_ordered_extent *ordered, u64 pre,
212			       u64 post);
 
 
213int __init ordered_data_init(void);
214void __cold ordered_data_exit(void);
215
216#endif