fs/btrfs/inode-item.c

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