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 "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(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(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  * btrfs_insert_inode_extref() - Inserts 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(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(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(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(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(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(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                         btrfs_init_data_ref(&ref, btrfs_header_owner(leaf),
 681                                         control->ino, extent_offset,
 682                                         root->root_key.objectid, false);
 683                         ret = btrfs_free_extent(trans, &ref);
 684                         if (ret) {
 685                                 btrfs_abort_transaction(trans, ret);
 686                                 break;
 687                         }
 688                         if (be_nice && btrfs_check_space_for_delayed_refs(fs_info))
 689                                 refill_delayed_refs_rsv = true;
 690                 }
 691
 692                 if (found_type == BTRFS_INODE_ITEM_KEY)
 693                         break;
 694
 695                 if (path->slots[0] == 0 ||
 696                     path->slots[0] != pending_del_slot ||
 697                     refill_delayed_refs_rsv) {
 698                         if (pending_del_nr) {
 699                                 ret = btrfs_del_items(trans, root, path,
 700                                                 pending_del_slot,
 701                                                 pending_del_nr);
 702                                 if (ret) {
 703                                         btrfs_abort_transaction(trans, ret);
 704                                         break;
 705                                 }
 706                                 pending_del_nr = 0;
 707                         }
 708                         btrfs_release_path(path);
 709
 710                         /*
 711                          * We can generate a lot of delayed refs, so we need to
 712                          * throttle every once and a while and make sure we're
 713                          * adding enough space to keep up with the work we are
 714                          * generating.  Since we hold a transaction here we
 715                          * can't flush, and we don't want to FLUSH_LIMIT because
 716                          * we could have generated too many delayed refs to
 717                          * actually allocate, so just bail if we're short and
 718                          * let the normal reservation dance happen higher up.
 719                          */
 720                         if (refill_delayed_refs_rsv) {
 721                                 ret = btrfs_delayed_refs_rsv_refill(fs_info,
 722                                                         BTRFS_RESERVE_NO_FLUSH);
 723                                 if (ret) {
 724                                         ret = -EAGAIN;
 725                                         break;
 726                                 }
 727                         }
 728                         goto search_again;
 729                 } else {
 730                         path->slots[0]--;
 731                 }
 732         }
 733 out:
 734         if (ret >= 0 && pending_del_nr) {
 735                 int err;
 736
 737                 err = btrfs_del_items(trans, root, path, pending_del_slot,
 738                                       pending_del_nr);
 739                 if (err) {
 740                         btrfs_abort_transaction(trans, err);
 741                         ret = err;
 742                 }
 743         }
 744
 745         ASSERT(control->last_size >= new_size);
 746         if (!ret && control->last_size > new_size)
 747                 control->last_size = new_size;
 748
 749         btrfs_free_path(path);
 750         return ret;
 751 }