1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * Copyright (C) 2007 Oracle.  All rights reserved.
  4 */
  5
  6#include "ctree.h"
  7#include "fs.h"
  8#include "messages.h"
  9#include "inode-item.h"
 10#include "disk-io.h"
 11#include "transaction.h"
 12#include "print-tree.h"
 13#include "space-info.h"
 14#include "accessors.h"
 15#include "extent-tree.h"
 16#include "file-item.h"
 17
 18struct btrfs_inode_ref *btrfs_find_name_in_backref(struct extent_buffer *leaf,
 19						   int slot,
 20						   const struct fscrypt_str *name)
 21{
 22	struct btrfs_inode_ref *ref;
 23	unsigned long ptr;
 24	unsigned long name_ptr;
 25	u32 item_size;
 26	u32 cur_offset = 0;
 27	int len;
 28
 29	item_size = btrfs_item_size(leaf, slot);
 30	ptr = btrfs_item_ptr_offset(leaf, slot);
 31	while (cur_offset < item_size) {
 32		ref = (struct btrfs_inode_ref *)(ptr + cur_offset);
 33		len = btrfs_inode_ref_name_len(leaf, ref);
 34		name_ptr = (unsigned long)(ref + 1);
 35		cur_offset += len + sizeof(*ref);
 36		if (len != name->len)
 37			continue;
 38		if (memcmp_extent_buffer(leaf, name->name, name_ptr,
 39					 name->len) == 0)
 40			return ref;
 41	}
 42	return NULL;
 43}
 44
 45struct btrfs_inode_extref *btrfs_find_name_in_ext_backref(
 46		struct extent_buffer *leaf, int slot, u64 ref_objectid,
 47		const struct fscrypt_str *name)
 48{
 49	struct btrfs_inode_extref *extref;
 50	unsigned long ptr;
 51	unsigned long name_ptr;
 52	u32 item_size;
 53	u32 cur_offset = 0;
 54	int ref_name_len;
 55
 56	item_size = btrfs_item_size(leaf, slot);
 57	ptr = btrfs_item_ptr_offset(leaf, slot);
 58
 59	/*
 60	 * Search all extended backrefs in this item. We're only
 61	 * looking through any collisions so most of the time this is
 62	 * just going to compare against one buffer. If all is well,
 63	 * we'll return success and the inode ref object.
 64	 */
 65	while (cur_offset < item_size) {
 66		extref = (struct btrfs_inode_extref *) (ptr + cur_offset);
 67		name_ptr = (unsigned long)(&extref->name);
 68		ref_name_len = btrfs_inode_extref_name_len(leaf, extref);
 69
 70		if (ref_name_len == name->len &&
 71		    btrfs_inode_extref_parent(leaf, extref) == ref_objectid &&
 72		    (memcmp_extent_buffer(leaf, name->name, name_ptr,
 73					  name->len) == 0))
 74			return extref;
 75
 76		cur_offset += ref_name_len + sizeof(*extref);
 77	}
 78	return NULL;
 79}
 80
 81/* Returns NULL if no extref found */
 82struct btrfs_inode_extref *
 83btrfs_lookup_inode_extref(struct btrfs_trans_handle *trans,
 84			  struct btrfs_root *root,
 85			  struct btrfs_path *path,
 86			  const struct fscrypt_str *name,
 87			  u64 inode_objectid, u64 ref_objectid, int ins_len,
 88			  int cow)
 89{
 90	int ret;
 91	struct btrfs_key key;
 92
 93	key.objectid = inode_objectid;
 94	key.type = BTRFS_INODE_EXTREF_KEY;
 95	key.offset = btrfs_extref_hash(ref_objectid, name->name, name->len);
 96
 97	ret = btrfs_search_slot(trans, root, &key, path, ins_len, cow);
 98	if (ret < 0)
 99		return ERR_PTR(ret);
100	if (ret > 0)
101		return NULL;
102	return btrfs_find_name_in_ext_backref(path->nodes[0], path->slots[0],
103					      ref_objectid, name);
104
105}
106
107static int btrfs_del_inode_extref(struct btrfs_trans_handle *trans,
108				  struct btrfs_root *root,
109				  const struct fscrypt_str *name,
110				  u64 inode_objectid, u64 ref_objectid,
111				  u64 *index)
112{
113	struct btrfs_path *path;
114	struct btrfs_key key;
115	struct btrfs_inode_extref *extref;
116	struct extent_buffer *leaf;
117	int ret;
118	int del_len = name->len + sizeof(*extref);
119	unsigned long ptr;
120	unsigned long item_start;
121	u32 item_size;
122
123	key.objectid = inode_objectid;
124	key.type = BTRFS_INODE_EXTREF_KEY;
125	key.offset = btrfs_extref_hash(ref_objectid, name->name, name->len);
126
127	path = btrfs_alloc_path();
128	if (!path)
129		return -ENOMEM;
130
131	ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
132	if (ret > 0)
133		ret = -ENOENT;
134	if (ret < 0)
135		goto out;
136
137	/*
138	 * Sanity check - did we find the right item for this name?
139	 * This should always succeed so error here will make the FS
140	 * readonly.
141	 */
142	extref = btrfs_find_name_in_ext_backref(path->nodes[0], path->slots[0],
143						ref_objectid, name);
144	if (!extref) {
145		btrfs_handle_fs_error(root->fs_info, -ENOENT, NULL);
146		ret = -EROFS;
147		goto out;
148	}
149
150	leaf = path->nodes[0];
151	item_size = btrfs_item_size(leaf, path->slots[0]);
152	if (index)
153		*index = btrfs_inode_extref_index(leaf, extref);
154
155	if (del_len == item_size) {
156		/*
157		 * Common case only one ref in the item, remove the
158		 * whole item.
159		 */
160		ret = btrfs_del_item(trans, root, path);
161		goto out;
162	}
163
164	ptr = (unsigned long)extref;
165	item_start = btrfs_item_ptr_offset(leaf, path->slots[0]);
166
167	memmove_extent_buffer(leaf, ptr, ptr + del_len,
168			      item_size - (ptr + del_len - item_start));
169
170	btrfs_truncate_item(trans, path, item_size - del_len, 1);
171
172out:
173	btrfs_free_path(path);
174
175	return ret;
176}
177
178int btrfs_del_inode_ref(struct btrfs_trans_handle *trans,
179			struct btrfs_root *root, const struct fscrypt_str *name,
 
180			u64 inode_objectid, u64 ref_objectid, u64 *index)
181{
182	struct btrfs_path *path;
183	struct btrfs_key key;
184	struct btrfs_inode_ref *ref;
185	struct extent_buffer *leaf;
186	unsigned long ptr;
187	unsigned long item_start;
188	u32 item_size;
189	u32 sub_item_len;
190	int ret;
191	int search_ext_refs = 0;
192	int del_len = name->len + sizeof(*ref);
193
194	key.objectid = inode_objectid;
195	key.offset = ref_objectid;
196	key.type = BTRFS_INODE_REF_KEY;
197
198	path = btrfs_alloc_path();
199	if (!path)
200		return -ENOMEM;
201
202	ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
203	if (ret > 0) {
204		ret = -ENOENT;
205		search_ext_refs = 1;
206		goto out;
207	} else if (ret < 0) {
208		goto out;
209	}
210
211	ref = btrfs_find_name_in_backref(path->nodes[0], path->slots[0], name);
 
212	if (!ref) {
213		ret = -ENOENT;
214		search_ext_refs = 1;
215		goto out;
216	}
217	leaf = path->nodes[0];
218	item_size = btrfs_item_size(leaf, path->slots[0]);
219
220	if (index)
221		*index = btrfs_inode_ref_index(leaf, ref);
222
223	if (del_len == item_size) {
224		ret = btrfs_del_item(trans, root, path);
225		goto out;
226	}
227	ptr = (unsigned long)ref;
228	sub_item_len = name->len + sizeof(*ref);
229	item_start = btrfs_item_ptr_offset(leaf, path->slots[0]);
230	memmove_extent_buffer(leaf, ptr, ptr + sub_item_len,
231			      item_size - (ptr + sub_item_len - item_start));
232	btrfs_truncate_item(trans, path, item_size - sub_item_len, 1);
233out:
234	btrfs_free_path(path);
235
236	if (search_ext_refs) {
237		/*
238		 * No refs were found, or we could not find the
239		 * name in our ref array. Find and remove the extended
240		 * inode ref then.
241		 */
242		return btrfs_del_inode_extref(trans, root, name,
243					      inode_objectid, ref_objectid, index);
244	}
245
246	return ret;
247}
248
249/*
250 * Insert an extended inode ref into a tree.
251 *
252 * The caller must have checked against BTRFS_LINK_MAX already.
253 */
254static int btrfs_insert_inode_extref(struct btrfs_trans_handle *trans,
255				     struct btrfs_root *root,
256				     const struct fscrypt_str *name,
257				     u64 inode_objectid, u64 ref_objectid,
258				     u64 index)
259{
260	struct btrfs_inode_extref *extref;
261	int ret;
262	int ins_len = name->len + sizeof(*extref);
263	unsigned long ptr;
264	struct btrfs_path *path;
265	struct btrfs_key key;
266	struct extent_buffer *leaf;
 
267
268	key.objectid = inode_objectid;
269	key.type = BTRFS_INODE_EXTREF_KEY;
270	key.offset = btrfs_extref_hash(ref_objectid, name->name, name->len);
271
272	path = btrfs_alloc_path();
273	if (!path)
274		return -ENOMEM;
275
276	ret = btrfs_insert_empty_item(trans, root, path, &key,
277				      ins_len);
278	if (ret == -EEXIST) {
279		if (btrfs_find_name_in_ext_backref(path->nodes[0],
280						   path->slots[0],
281						   ref_objectid,
282						   name))
283			goto out;
284
285		btrfs_extend_item(trans, path, ins_len);
286		ret = 0;
287	}
288	if (ret < 0)
289		goto out;
290
291	leaf = path->nodes[0];
 
292	ptr = (unsigned long)btrfs_item_ptr(leaf, path->slots[0], char);
293	ptr += btrfs_item_size(leaf, path->slots[0]) - ins_len;
294	extref = (struct btrfs_inode_extref *)ptr;
295
296	btrfs_set_inode_extref_name_len(path->nodes[0], extref, name->len);
297	btrfs_set_inode_extref_index(path->nodes[0], extref, index);
298	btrfs_set_inode_extref_parent(path->nodes[0], extref, ref_objectid);
299
300	ptr = (unsigned long)&extref->name;
301	write_extent_buffer(path->nodes[0], name->name, ptr, name->len);
302	btrfs_mark_buffer_dirty(trans, path->nodes[0]);
303
304out:
305	btrfs_free_path(path);
306	return ret;
307}
308
309/* Will return 0, -ENOMEM, -EMLINK, or -EEXIST or anything from the CoW path */
310int btrfs_insert_inode_ref(struct btrfs_trans_handle *trans,
311			   struct btrfs_root *root, const struct fscrypt_str *name,
 
312			   u64 inode_objectid, u64 ref_objectid, u64 index)
313{
314	struct btrfs_fs_info *fs_info = root->fs_info;
315	struct btrfs_path *path;
316	struct btrfs_key key;
317	struct btrfs_inode_ref *ref;
318	unsigned long ptr;
319	int ret;
320	int ins_len = name->len + sizeof(*ref);
321
322	key.objectid = inode_objectid;
323	key.offset = ref_objectid;
324	key.type = BTRFS_INODE_REF_KEY;
325
326	path = btrfs_alloc_path();
327	if (!path)
328		return -ENOMEM;
329
330	path->skip_release_on_error = 1;
331	ret = btrfs_insert_empty_item(trans, root, path, &key,
332				      ins_len);
333	if (ret == -EEXIST) {
334		u32 old_size;
335		ref = btrfs_find_name_in_backref(path->nodes[0], path->slots[0],
336						 name);
337		if (ref)
338			goto out;
339
340		old_size = btrfs_item_size(path->nodes[0], path->slots[0]);
341		btrfs_extend_item(trans, path, ins_len);
342		ref = btrfs_item_ptr(path->nodes[0], path->slots[0],
343				     struct btrfs_inode_ref);
344		ref = (struct btrfs_inode_ref *)((unsigned long)ref + old_size);
345		btrfs_set_inode_ref_name_len(path->nodes[0], ref, name->len);
346		btrfs_set_inode_ref_index(path->nodes[0], ref, index);
347		ptr = (unsigned long)(ref + 1);
348		ret = 0;
349	} else if (ret < 0) {
350		if (ret == -EOVERFLOW) {
351			if (btrfs_find_name_in_backref(path->nodes[0],
352						       path->slots[0],
353						       name))
354				ret = -EEXIST;
355			else
356				ret = -EMLINK;
357		}
358		goto out;
359	} else {
360		ref = btrfs_item_ptr(path->nodes[0], path->slots[0],
361				     struct btrfs_inode_ref);
362		btrfs_set_inode_ref_name_len(path->nodes[0], ref, name->len);
363		btrfs_set_inode_ref_index(path->nodes[0], ref, index);
364		ptr = (unsigned long)(ref + 1);
365	}
366	write_extent_buffer(path->nodes[0], name->name, ptr, name->len);
367	btrfs_mark_buffer_dirty(trans, path->nodes[0]);
368
369out:
370	btrfs_free_path(path);
371
372	if (ret == -EMLINK) {
373		struct btrfs_super_block *disk_super = fs_info->super_copy;
374		/* We ran out of space in the ref array. Need to
375		 * add an extended ref. */
376		if (btrfs_super_incompat_flags(disk_super)
377		    & BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF)
378			ret = btrfs_insert_inode_extref(trans, root, name,
 
379							inode_objectid,
380							ref_objectid, index);
381	}
382
383	return ret;
384}
385
386int btrfs_insert_empty_inode(struct btrfs_trans_handle *trans,
387			     struct btrfs_root *root,
388			     struct btrfs_path *path, u64 objectid)
389{
390	struct btrfs_key key;
391	int ret;
392	key.objectid = objectid;
393	key.type = BTRFS_INODE_ITEM_KEY;
394	key.offset = 0;
395
396	ret = btrfs_insert_empty_item(trans, root, path, &key,
397				      sizeof(struct btrfs_inode_item));
398	return ret;
399}
400
401int btrfs_lookup_inode(struct btrfs_trans_handle *trans, struct btrfs_root
402		       *root, struct btrfs_path *path,
403		       struct btrfs_key *location, int mod)
404{
405	int ins_len = mod < 0 ? -1 : 0;
406	int cow = mod != 0;
407	int ret;
408	int slot;
409	struct extent_buffer *leaf;
410	struct btrfs_key found_key;
411
412	ret = btrfs_search_slot(trans, root, location, path, ins_len, cow);
413	if (ret > 0 && location->type == BTRFS_ROOT_ITEM_KEY &&
414	    location->offset == (u64)-1 && path->slots[0] != 0) {
415		slot = path->slots[0] - 1;
416		leaf = path->nodes[0];
417		btrfs_item_key_to_cpu(leaf, &found_key, slot);
418		if (found_key.objectid == location->objectid &&
419		    found_key.type == location->type) {
420			path->slots[0]--;
421			return 0;
422		}
423	}
424	return ret;
425}
426
427static inline void btrfs_trace_truncate(struct btrfs_inode *inode,
428					struct extent_buffer *leaf,
429					struct btrfs_file_extent_item *fi,
430					u64 offset, int extent_type, int slot)
431{
432	if (!inode)
433		return;
434	if (extent_type == BTRFS_FILE_EXTENT_INLINE)
435		trace_btrfs_truncate_show_fi_inline(inode, leaf, fi, slot,
436						    offset);
437	else
438		trace_btrfs_truncate_show_fi_regular(inode, leaf, fi, offset);
439}
440
441/*
442 * Remove inode items from a given root.
443 *
444 * @trans:		A transaction handle.
445 * @root:		The root from which to remove items.
446 * @inode:		The inode whose items we want to remove.
447 * @control:		The btrfs_truncate_control to control how and what we
448 *			are truncating.
449 *
450 * Remove all keys associated with the inode from the given root that have a key
451 * with a type greater than or equals to @min_type. When @min_type has a value of
452 * BTRFS_EXTENT_DATA_KEY, only remove file extent items that have an offset value
453 * greater than or equals to @new_size. If a file extent item that starts before
454 * @new_size and ends after it is found, its length is adjusted.
455 *
456 * Returns: 0 on success, < 0 on error and NEED_TRUNCATE_BLOCK when @min_type is
457 * BTRFS_EXTENT_DATA_KEY and the caller must truncate the last block.
458 */
459int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,
460			       struct btrfs_root *root,
461			       struct btrfs_truncate_control *control)
462{
463	struct btrfs_fs_info *fs_info = root->fs_info;
464	struct btrfs_path *path;
465	struct extent_buffer *leaf;
466	struct btrfs_file_extent_item *fi;
467	struct btrfs_key key;
468	struct btrfs_key found_key;
469	u64 new_size = control->new_size;
470	u64 extent_num_bytes = 0;
471	u64 extent_offset = 0;
472	u64 item_end = 0;
473	u32 found_type = (u8)-1;
474	int del_item;
475	int pending_del_nr = 0;
476	int pending_del_slot = 0;
477	int extent_type = -1;
478	int ret;
479	u64 bytes_deleted = 0;
480	bool be_nice = false;
481
482	ASSERT(control->inode || !control->clear_extent_range);
483	ASSERT(new_size == 0 || control->min_type == BTRFS_EXTENT_DATA_KEY);
484
485	control->last_size = new_size;
486	control->sub_bytes = 0;
487
488	/*
489	 * For shareable roots we want to back off from time to time, this turns
490	 * out to be subvolume roots, reloc roots, and data reloc roots.
491	 */
492	if (test_bit(BTRFS_ROOT_SHAREABLE, &root->state))
493		be_nice = true;
494
495	path = btrfs_alloc_path();
496	if (!path)
497		return -ENOMEM;
498	path->reada = READA_BACK;
499
500	key.objectid = control->ino;
501	key.offset = (u64)-1;
502	key.type = (u8)-1;
503
504search_again:
505	/*
506	 * With a 16K leaf size and 128MiB extents, you can actually queue up a
507	 * huge file in a single leaf.  Most of the time that bytes_deleted is
508	 * > 0, it will be huge by the time we get here
509	 */
510	if (be_nice && bytes_deleted > SZ_32M &&
511	    btrfs_should_end_transaction(trans)) {
512		ret = -EAGAIN;
513		goto out;
514	}
515
516	ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
517	if (ret < 0)
518		goto out;
519
520	if (ret > 0) {
521		ret = 0;
522		/* There are no items in the tree for us to truncate, we're done */
523		if (path->slots[0] == 0)
524			goto out;
525		path->slots[0]--;
526	}
527
528	while (1) {
529		u64 clear_start = 0, clear_len = 0, extent_start = 0;
530		bool refill_delayed_refs_rsv = false;
531
532		fi = NULL;
533		leaf = path->nodes[0];
534		btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
535		found_type = found_key.type;
536
537		if (found_key.objectid != control->ino)
538			break;
539
540		if (found_type < control->min_type)
541			break;
542
543		item_end = found_key.offset;
544		if (found_type == BTRFS_EXTENT_DATA_KEY) {
545			fi = btrfs_item_ptr(leaf, path->slots[0],
546					    struct btrfs_file_extent_item);
547			extent_type = btrfs_file_extent_type(leaf, fi);
548			if (extent_type != BTRFS_FILE_EXTENT_INLINE)
549				item_end +=
550				    btrfs_file_extent_num_bytes(leaf, fi);
551			else if (extent_type == BTRFS_FILE_EXTENT_INLINE)
552				item_end += btrfs_file_extent_ram_bytes(leaf, fi);
553
554			btrfs_trace_truncate(control->inode, leaf, fi,
555					     found_key.offset, extent_type,
556					     path->slots[0]);
557			item_end--;
558		}
559		if (found_type > control->min_type) {
560			del_item = 1;
561		} else {
562			if (item_end < new_size)
563				break;
564			if (found_key.offset >= new_size)
565				del_item = 1;
566			else
567				del_item = 0;
568		}
569
570		/* FIXME, shrink the extent if the ref count is only 1 */
571		if (found_type != BTRFS_EXTENT_DATA_KEY)
572			goto delete;
573
574		control->extents_found++;
575
576		if (extent_type != BTRFS_FILE_EXTENT_INLINE) {
577			u64 num_dec;
578
579			clear_start = found_key.offset;
580			extent_start = btrfs_file_extent_disk_bytenr(leaf, fi);
581			if (!del_item) {
582				u64 orig_num_bytes =
583					btrfs_file_extent_num_bytes(leaf, fi);
584				extent_num_bytes = ALIGN(new_size -
585						found_key.offset,
586						fs_info->sectorsize);
587				clear_start = ALIGN(new_size, fs_info->sectorsize);
588
589				btrfs_set_file_extent_num_bytes(leaf, fi,
590							 extent_num_bytes);
591				num_dec = (orig_num_bytes - extent_num_bytes);
592				if (extent_start != 0)
593					control->sub_bytes += num_dec;
594				btrfs_mark_buffer_dirty(trans, leaf);
595			} else {
596				extent_num_bytes =
597					btrfs_file_extent_disk_num_bytes(leaf, fi);
598				extent_offset = found_key.offset -
599					btrfs_file_extent_offset(leaf, fi);
600
601				/* FIXME blocksize != 4096 */
602				num_dec = btrfs_file_extent_num_bytes(leaf, fi);
603				if (extent_start != 0)
604					control->sub_bytes += num_dec;
605			}
606			clear_len = num_dec;
607		} else if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
608			/*
609			 * We can't truncate inline items that have had
610			 * special encodings
611			 */
612			if (!del_item &&
613			    btrfs_file_extent_encryption(leaf, fi) == 0 &&
614			    btrfs_file_extent_other_encoding(leaf, fi) == 0 &&
615			    btrfs_file_extent_compression(leaf, fi) == 0) {
616				u32 size = (u32)(new_size - found_key.offset);
617
618				btrfs_set_file_extent_ram_bytes(leaf, fi, size);
619				size = btrfs_file_extent_calc_inline_size(size);
620				btrfs_truncate_item(trans, path, size, 1);
621			} else if (!del_item) {
622				/*
623				 * We have to bail so the last_size is set to
624				 * just before this extent.
625				 */
626				ret = BTRFS_NEED_TRUNCATE_BLOCK;
627				break;
628			} else {
629				/*
630				 * Inline extents are special, we just treat
631				 * them as a full sector worth in the file
632				 * extent tree just for simplicity sake.
633				 */
634				clear_len = fs_info->sectorsize;
635			}
636
637			control->sub_bytes += item_end + 1 - new_size;
638		}
639delete:
640		/*
641		 * We only want to clear the file extent range if we're
642		 * modifying the actual inode's mapping, which is just the
643		 * normal truncate path.
644		 */
645		if (control->clear_extent_range) {
646			ret = btrfs_inode_clear_file_extent_range(control->inode,
647						  clear_start, clear_len);
648			if (ret) {
649				btrfs_abort_transaction(trans, ret);
650				break;
651			}
652		}
653
654		if (del_item) {
655			ASSERT(!pending_del_nr ||
656			       ((path->slots[0] + 1) == pending_del_slot));
657
658			control->last_size = found_key.offset;
659			if (!pending_del_nr) {
660				/* No pending yet, add ourselves */
661				pending_del_slot = path->slots[0];
662				pending_del_nr = 1;
663			} else if (path->slots[0] + 1 == pending_del_slot) {
664				/* Hop on the pending chunk */
665				pending_del_nr++;
666				pending_del_slot = path->slots[0];
667			}
668		} else {
669			control->last_size = new_size;
670			break;
671		}
672
673		if (del_item && extent_start != 0 && !control->skip_ref_updates) {
674			struct btrfs_ref ref = { 0 };
675
676			bytes_deleted += extent_num_bytes;
677
678			btrfs_init_generic_ref(&ref, BTRFS_DROP_DELAYED_REF,
679					extent_start, extent_num_bytes, 0,
680					root->root_key.objectid);
681			btrfs_init_data_ref(&ref, btrfs_header_owner(leaf),
682					control->ino, extent_offset,
683					root->root_key.objectid, false);
684			ret = btrfs_free_extent(trans, &ref);
685			if (ret) {
686				btrfs_abort_transaction(trans, ret);
687				break;
688			}
689			if (be_nice && btrfs_check_space_for_delayed_refs(fs_info))
690				refill_delayed_refs_rsv = true;
691		}
692
693		if (found_type == BTRFS_INODE_ITEM_KEY)
694			break;
695
696		if (path->slots[0] == 0 ||
697		    path->slots[0] != pending_del_slot ||
698		    refill_delayed_refs_rsv) {
699			if (pending_del_nr) {
700				ret = btrfs_del_items(trans, root, path,
701						pending_del_slot,
702						pending_del_nr);
703				if (ret) {
704					btrfs_abort_transaction(trans, ret);
705					break;
706				}
707				pending_del_nr = 0;
708			}
709			btrfs_release_path(path);
710
711			/*
712			 * We can generate a lot of delayed refs, so we need to
713			 * throttle every once and a while and make sure we're
714			 * adding enough space to keep up with the work we are
715			 * generating.  Since we hold a transaction here we
716			 * can't flush, and we don't want to FLUSH_LIMIT because
717			 * we could have generated too many delayed refs to
718			 * actually allocate, so just bail if we're short and
719			 * let the normal reservation dance happen higher up.
720			 */
721			if (refill_delayed_refs_rsv) {
722				ret = btrfs_delayed_refs_rsv_refill(fs_info,
723							BTRFS_RESERVE_NO_FLUSH);
724				if (ret) {
725					ret = -EAGAIN;
726					break;
727				}
728			}
729			goto search_again;
730		} else {
731			path->slots[0]--;
732		}
733	}
734out:
735	if (ret >= 0 && pending_del_nr) {
736		int err;
737
738		err = btrfs_del_items(trans, root, path, pending_del_slot,
739				      pending_del_nr);
740		if (err) {
741			btrfs_abort_transaction(trans, err);
742			ret = err;
743		}
744	}
745
746	ASSERT(control->last_size >= new_size);
747	if (!ret && control->last_size > new_size)
748		control->last_size = new_size;
749
750	btrfs_free_path(path);
751	return ret;
752}