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 18 struct 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 45 struct 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 */ 82 struct btrfs_inode_extref * 83 btrfs_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 107 static 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 172 out: 173 btrfs_free_path(path); 174 175 return ret; 176 } 177 178 int 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); 233 out: 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 */ 254 static 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 304 out: 305 btrfs_free_path(path); 306 return ret; 307 } 308 309 /* Will return 0, -ENOMEM, -EMLINK, or -EEXIST or anything from the CoW path */ 310 int 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 369 out: 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 386 int 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 401 int 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 427 static 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 */ 459 int 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 504 search_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 } 639 delete: 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 } 734 out: 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 } 753