fs/ntfs3/attrib.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  *
   4  * Copyright (C) 2019-2021 Paragon Software GmbH, All rights reserved.
   5  *
   6  * TODO: Merge attr_set_size/attr_data_get_block/attr_allocate_frame?
   7  */
   8
   9 #include <linux/fs.h>
  10 #include <linux/slab.h>
  11 #include <linux/kernel.h>
  12
  13 #include "debug.h"
  14 #include "ntfs.h"
  15 #include "ntfs_fs.h"
  16
  17 /*
  18  * You can set external NTFS_MIN_LOG2_OF_CLUMP/NTFS_MAX_LOG2_OF_CLUMP to manage
  19  * preallocate algorithm.
  20  */
  21 #ifndef NTFS_MIN_LOG2_OF_CLUMP
  22 #define NTFS_MIN_LOG2_OF_CLUMP 16
  23 #endif
  24
  25 #ifndef NTFS_MAX_LOG2_OF_CLUMP
  26 #define NTFS_MAX_LOG2_OF_CLUMP 26
  27 #endif
  28
  29 // 16M
  30 #define NTFS_CLUMP_MIN (1 << (NTFS_MIN_LOG2_OF_CLUMP + 8))
  31 // 16G
  32 #define NTFS_CLUMP_MAX (1ull << (NTFS_MAX_LOG2_OF_CLUMP + 8))
  33
  34 static inline u64 get_pre_allocated(u64 size)
  35 {
  36         u32 clump;
  37         u8 align_shift;
  38         u64 ret;
  39
  40         if (size <= NTFS_CLUMP_MIN) {
  41                 clump = 1 << NTFS_MIN_LOG2_OF_CLUMP;
  42                 align_shift = NTFS_MIN_LOG2_OF_CLUMP;
  43         } else if (size >= NTFS_CLUMP_MAX) {
  44                 clump = 1 << NTFS_MAX_LOG2_OF_CLUMP;
  45                 align_shift = NTFS_MAX_LOG2_OF_CLUMP;
  46         } else {
  47                 align_shift = NTFS_MIN_LOG2_OF_CLUMP - 1 +
  48                               __ffs(size >> (8 + NTFS_MIN_LOG2_OF_CLUMP));
  49                 clump = 1u << align_shift;
  50         }
  51
  52         ret = (((size + clump - 1) >> align_shift)) << align_shift;
  53
  54         return ret;
  55 }
  56
  57 /*
  58  * attr_load_runs - Load all runs stored in @attr.
  59  */
  60 static int attr_load_runs(struct ATTRIB *attr, struct ntfs_inode *ni,
  61                           struct runs_tree *run, const CLST *vcn)
  62 {
  63         int err;
  64         CLST svcn = le64_to_cpu(attr->nres.svcn);
  65         CLST evcn = le64_to_cpu(attr->nres.evcn);
  66         u32 asize;
  67         u16 run_off;
  68
  69         if (svcn >= evcn + 1 || run_is_mapped_full(run, svcn, evcn))
  70                 return 0;
  71
  72         if (vcn && (evcn < *vcn || *vcn < svcn))
  73                 return -EINVAL;
  74
  75         asize = le32_to_cpu(attr->size);
  76         run_off = le16_to_cpu(attr->nres.run_off);
  77
  78         if (run_off > asize)
  79                 return -EINVAL;
  80
  81         err = run_unpack_ex(run, ni->mi.sbi, ni->mi.rno, svcn, evcn,
  82                             vcn ? *vcn : svcn, Add2Ptr(attr, run_off),
  83                             asize - run_off);
  84         if (err < 0)
  85                 return err;
  86
  87         return 0;
  88 }
  89
  90 /*
  91  * run_deallocate_ex - Deallocate clusters.
  92  */
  93 static int run_deallocate_ex(struct ntfs_sb_info *sbi, struct runs_tree *run,
  94                              CLST vcn, CLST len, CLST *done, bool trim)
  95 {
  96         int err = 0;
  97         CLST vcn_next, vcn0 = vcn, lcn, clen, dn = 0;
  98         size_t idx;
  99
 100         if (!len)
 101                 goto out;
 102
 103         if (!run_lookup_entry(run, vcn, &lcn, &clen, &idx)) {
 104 failed:
 105                 run_truncate(run, vcn0);
 106                 err = -EINVAL;
 107                 goto out;
 108         }
 109
 110         for (;;) {
 111                 if (clen > len)
 112                         clen = len;
 113
 114                 if (!clen) {
 115                         err = -EINVAL;
 116                         goto out;
 117                 }
 118
 119                 if (lcn != SPARSE_LCN) {
 120                         if (sbi) {
 121                                 /* mark bitmap range [lcn + clen) as free and trim clusters. */
 122                                 mark_as_free_ex(sbi, lcn, clen, trim);
 123                         }
 124                         dn += clen;
 125                 }
 126
 127                 len -= clen;
 128                 if (!len)
 129                         break;
 130
 131                 vcn_next = vcn + clen;
 132                 if (!run_get_entry(run, ++idx, &vcn, &lcn, &clen) ||
 133                     vcn != vcn_next) {
 134                         /* Save memory - don't load entire run. */
 135                         goto failed;
 136                 }
 137         }
 138
 139 out:
 140         if (done)
 141                 *done += dn;
 142
 143         return err;
 144 }
 145
 146 /*
 147  * attr_allocate_clusters - Find free space, mark it as used and store in @run.
 148  */
 149 int attr_allocate_clusters(struct ntfs_sb_info *sbi, struct runs_tree *run,
 150                            CLST vcn, CLST lcn, CLST len, CLST *pre_alloc,
 151                            enum ALLOCATE_OPT opt, CLST *alen, const size_t fr,
 152                            CLST *new_lcn, CLST *new_len)
 153 {
 154         int err;
 155         CLST flen, vcn0 = vcn, pre = pre_alloc ? *pre_alloc : 0;
 156         size_t cnt = run->count;
 157
 158         for (;;) {
 159                 err = ntfs_look_for_free_space(sbi, lcn, len + pre, &lcn, &flen,
 160                                                opt);
 161
 162                 if (err == -ENOSPC && pre) {
 163                         pre = 0;
 164                         if (*pre_alloc)
 165                                 *pre_alloc = 0;
 166                         continue;
 167                 }
 168
 169                 if (err)
 170                         goto out;
 171
 172                 if (vcn == vcn0) {
 173                         /* Return the first fragment. */
 174                         if (new_lcn)
 175                                 *new_lcn = lcn;
 176                         if (new_len)
 177                                 *new_len = flen;
 178                 }
 179
 180                 /* Add new fragment into run storage. */
 181                 if (!run_add_entry(run, vcn, lcn, flen, opt & ALLOCATE_MFT)) {
 182                         /* Undo last 'ntfs_look_for_free_space' */
 183                         mark_as_free_ex(sbi, lcn, len, false);
 184                         err = -ENOMEM;
 185                         goto out;
 186                 }
 187
 188                 if (opt & ALLOCATE_ZERO) {
 189                         u8 shift = sbi->cluster_bits - SECTOR_SHIFT;
 190
 191                         err = blkdev_issue_zeroout(sbi->sb->s_bdev,
 192                                                    (sector_t)lcn << shift,
 193                                                    (sector_t)flen << shift,
 194                                                    GFP_NOFS, 0);
 195                         if (err)
 196                                 goto out;
 197                 }
 198
 199                 vcn += flen;
 200
 201                 if (flen >= len || (opt & ALLOCATE_MFT) ||
 202                     (fr && run->count - cnt >= fr)) {
 203                         *alen = vcn - vcn0;
 204                         return 0;
 205                 }
 206
 207                 len -= flen;
 208         }
 209
 210 out:
 211         /* Undo 'ntfs_look_for_free_space' */
 212         if (vcn - vcn0) {
 213                 run_deallocate_ex(sbi, run, vcn0, vcn - vcn0, NULL, false);
 214                 run_truncate(run, vcn0);
 215         }
 216
 217         return err;
 218 }
 219
 220 /*
 221  * attr_make_nonresident
 222  *
 223  * If page is not NULL - it is already contains resident data
 224  * and locked (called from ni_write_frame()).
 225  */
 226 int attr_make_nonresident(struct ntfs_inode *ni, struct ATTRIB *attr,
 227                           struct ATTR_LIST_ENTRY *le, struct mft_inode *mi,
 228                           u64 new_size, struct runs_tree *run,
 229                           struct ATTRIB **ins_attr, struct page *page)
 230 {
 231         struct ntfs_sb_info *sbi;
 232         struct ATTRIB *attr_s;
 233         struct MFT_REC *rec;
 234         u32 used, asize, rsize, aoff, align;
 235         bool is_data;
 236         CLST len, alen;
 237         char *next;
 238         int err;
 239
 240         if (attr->non_res) {
 241                 *ins_attr = attr;
 242                 return 0;
 243         }
 244
 245         sbi = mi->sbi;
 246         rec = mi->mrec;
 247         attr_s = NULL;
 248         used = le32_to_cpu(rec->used);
 249         asize = le32_to_cpu(attr->size);
 250         next = Add2Ptr(attr, asize);
 251         aoff = PtrOffset(rec, attr);
 252         rsize = le32_to_cpu(attr->res.data_size);
 253         is_data = attr->type == ATTR_DATA && !attr->name_len;
 254
 255         align = sbi->cluster_size;
 256         if (is_attr_compressed(attr))
 257                 align <<= COMPRESSION_UNIT;
 258         len = (rsize + align - 1) >> sbi->cluster_bits;
 259
 260         run_init(run);
 261
 262         /* Make a copy of original attribute. */
 263         attr_s = kmemdup(attr, asize, GFP_NOFS);
 264         if (!attr_s) {
 265                 err = -ENOMEM;
 266                 goto out;
 267         }
 268
 269         if (!len) {
 270                 /* Empty resident -> Empty nonresident. */
 271                 alen = 0;
 272         } else {
 273                 const char *data = resident_data(attr);
 274
 275                 err = attr_allocate_clusters(sbi, run, 0, 0, len, NULL,
 276                                              ALLOCATE_DEF, &alen, 0, NULL,
 277                                              NULL);
 278                 if (err)
 279                         goto out1;
 280
 281                 if (!rsize) {
 282                         /* Empty resident -> Non empty nonresident. */
 283                 } else if (!is_data) {
 284                         err = ntfs_sb_write_run(sbi, run, 0, data, rsize, 0);
 285                         if (err)
 286                                 goto out2;
 287                 } else if (!page) {
 288                         char *kaddr;
 289
 290                         page = grab_cache_page(ni->vfs_inode.i_mapping, 0);
 291                         if (!page) {
 292                                 err = -ENOMEM;
 293                                 goto out2;
 294                         }
 295                         kaddr = kmap_atomic(page);
 296                         memcpy(kaddr, data, rsize);
 297                         memset(kaddr + rsize, 0, PAGE_SIZE - rsize);
 298                         kunmap_atomic(kaddr);
 299                         flush_dcache_page(page);
 300                         SetPageUptodate(page);
 301                         set_page_dirty(page);
 302                         unlock_page(page);
 303                         put_page(page);
 304                 }
 305         }
 306
 307         /* Remove original attribute. */
 308         used -= asize;
 309         memmove(attr, Add2Ptr(attr, asize), used - aoff);
 310         rec->used = cpu_to_le32(used);
 311         mi->dirty = true;
 312         if (le)
 313                 al_remove_le(ni, le);
 314
 315         err = ni_insert_nonresident(ni, attr_s->type, attr_name(attr_s),
 316                                     attr_s->name_len, run, 0, alen,
 317                                     attr_s->flags, &attr, NULL, NULL);
 318         if (err)
 319                 goto out3;
 320
 321         kfree(attr_s);
 322         attr->nres.data_size = cpu_to_le64(rsize);
 323         attr->nres.valid_size = attr->nres.data_size;
 324
 325         *ins_attr = attr;
 326
 327         if (is_data)
 328                 ni->ni_flags &= ~NI_FLAG_RESIDENT;
 329
 330         /* Resident attribute becomes non resident. */
 331         return 0;
 332
 333 out3:
 334         attr = Add2Ptr(rec, aoff);
 335         memmove(next, attr, used - aoff);
 336         memcpy(attr, attr_s, asize);
 337         rec->used = cpu_to_le32(used + asize);
 338         mi->dirty = true;
 339 out2:
 340         /* Undo: do not trim new allocated clusters. */
 341         run_deallocate(sbi, run, false);
 342         run_close(run);
 343 out1:
 344         kfree(attr_s);
 345 out:
 346         return err;
 347 }
 348
 349 /*
 350  * attr_set_size_res - Helper for attr_set_size().
 351  */
 352 static int attr_set_size_res(struct ntfs_inode *ni, struct ATTRIB *attr,
 353                              struct ATTR_LIST_ENTRY *le, struct mft_inode *mi,
 354                              u64 new_size, struct runs_tree *run,
 355                              struct ATTRIB **ins_attr)
 356 {
 357         struct ntfs_sb_info *sbi = mi->sbi;
 358         struct MFT_REC *rec = mi->mrec;
 359         u32 used = le32_to_cpu(rec->used);
 360         u32 asize = le32_to_cpu(attr->size);
 361         u32 aoff = PtrOffset(rec, attr);
 362         u32 rsize = le32_to_cpu(attr->res.data_size);
 363         u32 tail = used - aoff - asize;
 364         char *next = Add2Ptr(attr, asize);
 365         s64 dsize = ALIGN(new_size, 8) - ALIGN(rsize, 8);
 366
 367         if (dsize < 0) {
 368                 memmove(next + dsize, next, tail);
 369         } else if (dsize > 0) {
 370                 if (used + dsize > sbi->max_bytes_per_attr)
 371                         return attr_make_nonresident(ni, attr, le, mi, new_size,
 372                                                      run, ins_attr, NULL);
 373
 374                 memmove(next + dsize, next, tail);
 375                 memset(next, 0, dsize);
 376         }
 377
 378         if (new_size > rsize)
 379                 memset(Add2Ptr(resident_data(attr), rsize), 0,
 380                        new_size - rsize);
 381
 382         rec->used = cpu_to_le32(used + dsize);
 383         attr->size = cpu_to_le32(asize + dsize);
 384         attr->res.data_size = cpu_to_le32(new_size);
 385         mi->dirty = true;
 386         *ins_attr = attr;
 387
 388         return 0;
 389 }
 390
 391 /*
 392  * attr_set_size - Change the size of attribute.
 393  *
 394  * Extend:
 395  *   - Sparse/compressed: No allocated clusters.
 396  *   - Normal: Append allocated and preallocated new clusters.
 397  * Shrink:
 398  *   - No deallocate if @keep_prealloc is set.
 399  */
 400 int attr_set_size(struct ntfs_inode *ni, enum ATTR_TYPE type,
 401                   const __le16 *name, u8 name_len, struct runs_tree *run,
 402                   u64 new_size, const u64 *new_valid, bool keep_prealloc,
 403                   struct ATTRIB **ret)
 404 {
 405         int err = 0;
 406         struct ntfs_sb_info *sbi = ni->mi.sbi;
 407         u8 cluster_bits = sbi->cluster_bits;
 408         bool is_mft = ni->mi.rno == MFT_REC_MFT && type == ATTR_DATA &&
 409                       !name_len;
 410         u64 old_valid, old_size, old_alloc, new_alloc, new_alloc_tmp;
 411         struct ATTRIB *attr = NULL, *attr_b;
 412         struct ATTR_LIST_ENTRY *le, *le_b;
 413         struct mft_inode *mi, *mi_b;
 414         CLST alen, vcn, lcn, new_alen, old_alen, svcn, evcn;
 415         CLST next_svcn, pre_alloc = -1, done = 0;
 416         bool is_ext, is_bad = false;
 417         bool dirty = false;
 418         u32 align;
 419         struct MFT_REC *rec;
 420
 421 again:
 422         alen = 0;
 423         le_b = NULL;
 424         attr_b = ni_find_attr(ni, NULL, &le_b, type, name, name_len, NULL,
 425                               &mi_b);
 426         if (!attr_b) {
 427                 err = -ENOENT;
 428                 goto bad_inode;
 429         }
 430
 431         if (!attr_b->non_res) {
 432                 err = attr_set_size_res(ni, attr_b, le_b, mi_b, new_size, run,
 433                                         &attr_b);
 434                 if (err)
 435                         return err;
 436
 437                 /* Return if file is still resident. */
 438                 if (!attr_b->non_res) {
 439                         dirty = true;
 440                         goto ok1;
 441                 }
 442
 443                 /* Layout of records may be changed, so do a full search. */
 444                 goto again;
 445         }
 446
 447         is_ext = is_attr_ext(attr_b);
 448         align = sbi->cluster_size;
 449         if (is_ext)
 450                 align <<= attr_b->nres.c_unit;
 451
 452         old_valid = le64_to_cpu(attr_b->nres.valid_size);
 453         old_size = le64_to_cpu(attr_b->nres.data_size);
 454         old_alloc = le64_to_cpu(attr_b->nres.alloc_size);
 455
 456 again_1:
 457         old_alen = old_alloc >> cluster_bits;
 458
 459         new_alloc = (new_size + align - 1) & ~(u64)(align - 1);
 460         new_alen = new_alloc >> cluster_bits;
 461
 462         if (keep_prealloc && new_size < old_size) {
 463                 attr_b->nres.data_size = cpu_to_le64(new_size);
 464                 mi_b->dirty = dirty = true;
 465                 goto ok;
 466         }
 467
 468         vcn = old_alen - 1;
 469
 470         svcn = le64_to_cpu(attr_b->nres.svcn);
 471         evcn = le64_to_cpu(attr_b->nres.evcn);
 472
 473         if (svcn <= vcn && vcn <= evcn) {
 474                 attr = attr_b;
 475                 le = le_b;
 476                 mi = mi_b;
 477         } else if (!le_b) {
 478                 err = -EINVAL;
 479                 goto bad_inode;
 480         } else {
 481                 le = le_b;
 482                 attr = ni_find_attr(ni, attr_b, &le, type, name, name_len, &vcn,
 483                                     &mi);
 484                 if (!attr) {
 485                         err = -EINVAL;
 486                         goto bad_inode;
 487                 }
 488
 489 next_le_1:
 490                 svcn = le64_to_cpu(attr->nres.svcn);
 491                 evcn = le64_to_cpu(attr->nres.evcn);
 492         }
 493         /*
 494          * Here we have:
 495          * attr,mi,le - last attribute segment (containing 'vcn').
 496          * attr_b,mi_b,le_b - base (primary) attribute segment.
 497          */
 498 next_le:
 499         rec = mi->mrec;
 500         err = attr_load_runs(attr, ni, run, NULL);
 501         if (err)
 502                 goto out;
 503
 504         if (new_size > old_size) {
 505                 CLST to_allocate;
 506                 size_t free;
 507
 508                 if (new_alloc <= old_alloc) {
 509                         attr_b->nres.data_size = cpu_to_le64(new_size);
 510                         mi_b->dirty = dirty = true;
 511                         goto ok;
 512                 }
 513
 514                 /*
 515                  * Add clusters. In simple case we have to:
 516                  *  - allocate space (vcn, lcn, len)
 517                  *  - update packed run in 'mi'
 518                  *  - update attr->nres.evcn
 519                  *  - update attr_b->nres.data_size/attr_b->nres.alloc_size
 520                  */
 521                 to_allocate = new_alen - old_alen;
 522 add_alloc_in_same_attr_seg:
 523                 lcn = 0;
 524                 if (is_mft) {
 525                         /* MFT allocates clusters from MFT zone. */
 526                         pre_alloc = 0;
 527                 } else if (is_ext) {
 528                         /* No preallocate for sparse/compress. */
 529                         pre_alloc = 0;
 530                 } else if (pre_alloc == -1) {
 531                         pre_alloc = 0;
 532                         if (type == ATTR_DATA && !name_len &&
 533                             sbi->options->prealloc) {
 534                                 pre_alloc = bytes_to_cluster(
 535                                                     sbi, get_pre_allocated(
 536                                                                  new_size)) -
 537                                             new_alen;
 538                         }
 539
 540                         /* Get the last LCN to allocate from. */
 541                         if (old_alen &&
 542                             !run_lookup_entry(run, vcn, &lcn, NULL, NULL)) {
 543                                 lcn = SPARSE_LCN;
 544                         }
 545
 546                         if (lcn == SPARSE_LCN)
 547                                 lcn = 0;
 548                         else if (lcn)
 549                                 lcn += 1;
 550
 551                         free = wnd_zeroes(&sbi->used.bitmap);
 552                         if (to_allocate > free) {
 553                                 err = -ENOSPC;
 554                                 goto out;
 555                         }
 556
 557                         if (pre_alloc && to_allocate + pre_alloc > free)
 558                                 pre_alloc = 0;
 559                 }
 560
 561                 vcn = old_alen;
 562
 563                 if (is_ext) {
 564                         if (!run_add_entry(run, vcn, SPARSE_LCN, to_allocate,
 565                                            false)) {
 566                                 err = -ENOMEM;
 567                                 goto out;
 568                         }
 569                         alen = to_allocate;
 570                 } else {
 571                         /* ~3 bytes per fragment. */
 572                         err = attr_allocate_clusters(
 573                                 sbi, run, vcn, lcn, to_allocate, &pre_alloc,
 574                                 is_mft ? ALLOCATE_MFT : ALLOCATE_DEF, &alen,
 575                                 is_mft ? 0 :
 576                                          (sbi->record_size -
 577                                           le32_to_cpu(rec->used) + 8) /
 578                                                          3 +
 579                                                  1,
 580                                 NULL, NULL);
 581                         if (err)
 582                                 goto out;
 583                 }
 584
 585                 done += alen;
 586                 vcn += alen;
 587                 if (to_allocate > alen)
 588                         to_allocate -= alen;
 589                 else
 590                         to_allocate = 0;
 591
 592 pack_runs:
 593                 err = mi_pack_runs(mi, attr, run, vcn - svcn);
 594                 if (err)
 595                         goto undo_1;
 596
 597                 next_svcn = le64_to_cpu(attr->nres.evcn) + 1;
 598                 new_alloc_tmp = (u64)next_svcn << cluster_bits;
 599                 attr_b->nres.alloc_size = cpu_to_le64(new_alloc_tmp);
 600                 mi_b->dirty = dirty = true;
 601
 602                 if (next_svcn >= vcn && !to_allocate) {
 603                         /* Normal way. Update attribute and exit. */
 604                         attr_b->nres.data_size = cpu_to_le64(new_size);
 605                         goto ok;
 606                 }
 607
 608                 /* At least two MFT to avoid recursive loop. */
 609                 if (is_mft && next_svcn == vcn &&
 610                     ((u64)done << sbi->cluster_bits) >= 2 * sbi->record_size) {
 611                         new_size = new_alloc_tmp;
 612                         attr_b->nres.data_size = attr_b->nres.alloc_size;
 613                         goto ok;
 614                 }
 615
 616                 if (le32_to_cpu(rec->used) < sbi->record_size) {
 617                         old_alen = next_svcn;
 618                         evcn = old_alen - 1;
 619                         goto add_alloc_in_same_attr_seg;
 620                 }
 621
 622                 attr_b->nres.data_size = attr_b->nres.alloc_size;
 623                 if (new_alloc_tmp < old_valid)
 624                         attr_b->nres.valid_size = attr_b->nres.data_size;
 625
 626                 if (type == ATTR_LIST) {
 627                         err = ni_expand_list(ni);
 628                         if (err)
 629                                 goto undo_2;
 630                         if (next_svcn < vcn)
 631                                 goto pack_runs;
 632
 633                         /* Layout of records is changed. */
 634                         goto again;
 635                 }
 636
 637                 if (!ni->attr_list.size) {
 638                         err = ni_create_attr_list(ni);
 639                         /* In case of error layout of records is not changed. */
 640                         if (err)
 641                                 goto undo_2;
 642                         /* Layout of records is changed. */
 643                 }
 644
 645                 if (next_svcn >= vcn) {
 646                         /* This is MFT data, repeat. */
 647                         goto again;
 648                 }
 649
 650                 /* Insert new attribute segment. */
 651                 err = ni_insert_nonresident(ni, type, name, name_len, run,
 652                                             next_svcn, vcn - next_svcn,
 653                                             attr_b->flags, &attr, &mi, NULL);
 654
 655                 /*
 656                  * Layout of records maybe changed.
 657                  * Find base attribute to update.
 658                  */
 659                 le_b = NULL;
 660                 attr_b = ni_find_attr(ni, NULL, &le_b, type, name, name_len,
 661                                       NULL, &mi_b);
 662                 if (!attr_b) {
 663                         err = -EINVAL;
 664                         goto bad_inode;
 665                 }
 666
 667                 if (err) {
 668                         /* ni_insert_nonresident failed. */
 669                         attr = NULL;
 670                         goto undo_2;
 671                 }
 672
 673                 if (!is_mft)
 674                         run_truncate_head(run, evcn + 1);
 675
 676                 svcn = le64_to_cpu(attr->nres.svcn);
 677                 evcn = le64_to_cpu(attr->nres.evcn);
 678
 679                 /*
 680                  * Attribute is in consistency state.
 681                  * Save this point to restore to if next steps fail.
 682                  */
 683                 old_valid = old_size = old_alloc = (u64)vcn << cluster_bits;
 684                 attr_b->nres.valid_size = attr_b->nres.data_size =
 685                         attr_b->nres.alloc_size = cpu_to_le64(old_size);
 686                 mi_b->dirty = dirty = true;
 687                 goto again_1;
 688         }
 689
 690         if (new_size != old_size ||
 691             (new_alloc != old_alloc && !keep_prealloc)) {
 692                 /*
 693                  * Truncate clusters. In simple case we have to:
 694                  *  - update packed run in 'mi'
 695                  *  - update attr->nres.evcn
 696                  *  - update attr_b->nres.data_size/attr_b->nres.alloc_size
 697                  *  - mark and trim clusters as free (vcn, lcn, len)
 698                  */
 699                 CLST dlen = 0;
 700
 701                 vcn = max(svcn, new_alen);
 702                 new_alloc_tmp = (u64)vcn << cluster_bits;
 703
 704                 if (vcn > svcn) {
 705                         err = mi_pack_runs(mi, attr, run, vcn - svcn);
 706                         if (err)
 707                                 goto out;
 708                 } else if (le && le->vcn) {
 709                         u16 le_sz = le16_to_cpu(le->size);
 710
 711                         /*
 712                          * NOTE: List entries for one attribute are always
 713                          * the same size. We deal with last entry (vcn==0)
 714                          * and it is not first in entries array
 715                          * (list entry for std attribute always first).
 716                          * So it is safe to step back.
 717                          */
 718                         mi_remove_attr(NULL, mi, attr);
 719
 720                         if (!al_remove_le(ni, le)) {
 721                                 err = -EINVAL;
 722                                 goto bad_inode;
 723                         }
 724
 725                         le = (struct ATTR_LIST_ENTRY *)((u8 *)le - le_sz);
 726                 } else {
 727                         attr->nres.evcn = cpu_to_le64((u64)vcn - 1);
 728                         mi->dirty = true;
 729                 }
 730
 731                 attr_b->nres.alloc_size = cpu_to_le64(new_alloc_tmp);
 732
 733                 if (vcn == new_alen) {
 734                         attr_b->nres.data_size = cpu_to_le64(new_size);
 735                         if (new_size < old_valid)
 736                                 attr_b->nres.valid_size =
 737                                         attr_b->nres.data_size;
 738                 } else {
 739                         if (new_alloc_tmp <=
 740                             le64_to_cpu(attr_b->nres.data_size))
 741                                 attr_b->nres.data_size =
 742                                         attr_b->nres.alloc_size;
 743                         if (new_alloc_tmp <
 744                             le64_to_cpu(attr_b->nres.valid_size))
 745                                 attr_b->nres.valid_size =
 746                                         attr_b->nres.alloc_size;
 747                 }
 748                 mi_b->dirty = dirty = true;
 749
 750                 err = run_deallocate_ex(sbi, run, vcn, evcn - vcn + 1, &dlen,
 751                                         true);
 752                 if (err)
 753                         goto out;
 754
 755                 if (is_ext) {
 756                         /* dlen - really deallocated clusters. */
 757                         le64_sub_cpu(&attr_b->nres.total_size,
 758                                      ((u64)dlen << cluster_bits));
 759                 }
 760
 761                 run_truncate(run, vcn);
 762
 763                 if (new_alloc_tmp <= new_alloc)
 764                         goto ok;
 765
 766                 old_size = new_alloc_tmp;
 767                 vcn = svcn - 1;
 768
 769                 if (le == le_b) {
 770                         attr = attr_b;
 771                         mi = mi_b;
 772                         evcn = svcn - 1;
 773                         svcn = 0;
 774                         goto next_le;
 775                 }
 776
 777                 if (le->type != type || le->name_len != name_len ||
 778                     memcmp(le_name(le), name, name_len * sizeof(short))) {
 779                         err = -EINVAL;
 780                         goto bad_inode;
 781                 }
 782
 783                 err = ni_load_mi(ni, le, &mi);
 784                 if (err)
 785                         goto out;
 786
 787                 attr = mi_find_attr(mi, NULL, type, name, name_len, &le->id);
 788                 if (!attr) {
 789                         err = -EINVAL;
 790                         goto bad_inode;
 791                 }
 792                 goto next_le_1;
 793         }
 794
 795 ok:
 796         if (new_valid) {
 797                 __le64 valid = cpu_to_le64(min(*new_valid, new_size));
 798
 799                 if (attr_b->nres.valid_size != valid) {
 800                         attr_b->nres.valid_size = valid;
 801                         mi_b->dirty = true;
 802                 }
 803         }
 804
 805 ok1:
 806         if (ret)
 807                 *ret = attr_b;
 808
 809         if (((type == ATTR_DATA && !name_len) ||
 810              (type == ATTR_ALLOC && name == I30_NAME))) {
 811                 /* Update inode_set_bytes. */
 812                 if (attr_b->non_res) {
 813                         new_alloc = le64_to_cpu(attr_b->nres.alloc_size);
 814                         if (inode_get_bytes(&ni->vfs_inode) != new_alloc) {
 815                                 inode_set_bytes(&ni->vfs_inode, new_alloc);
 816                                 dirty = true;
 817                         }
 818                 }
 819
 820                 /* Don't forget to update duplicate information in parent. */
 821                 if (dirty) {
 822                         ni->ni_flags |= NI_FLAG_UPDATE_PARENT;
 823                         mark_inode_dirty(&ni->vfs_inode);
 824                 }
 825         }
 826
 827         return 0;
 828
 829 undo_2:
 830         vcn -= alen;
 831         attr_b->nres.data_size = cpu_to_le64(old_size);
 832         attr_b->nres.valid_size = cpu_to_le64(old_valid);
 833         attr_b->nres.alloc_size = cpu_to_le64(old_alloc);
 834
 835         /* Restore 'attr' and 'mi'. */
 836         if (attr)
 837                 goto restore_run;
 838
 839         if (le64_to_cpu(attr_b->nres.svcn) <= svcn &&
 840             svcn <= le64_to_cpu(attr_b->nres.evcn)) {
 841                 attr = attr_b;
 842                 le = le_b;
 843                 mi = mi_b;
 844         } else if (!le_b) {
 845                 err = -EINVAL;
 846                 goto bad_inode;
 847         } else {
 848                 le = le_b;
 849                 attr = ni_find_attr(ni, attr_b, &le, type, name, name_len,
 850                                     &svcn, &mi);
 851                 if (!attr)
 852                         goto bad_inode;
 853         }
 854
 855 restore_run:
 856         if (mi_pack_runs(mi, attr, run, evcn - svcn + 1))
 857                 is_bad = true;
 858
 859 undo_1:
 860         run_deallocate_ex(sbi, run, vcn, alen, NULL, false);
 861
 862         run_truncate(run, vcn);
 863 out:
 864         if (is_bad) {
 865 bad_inode:
 866                 _ntfs_bad_inode(&ni->vfs_inode);
 867         }
 868         return err;
 869 }
 870
 871 /*
 872  * attr_data_get_block - Returns 'lcn' and 'len' for given 'vcn'.
 873  *
 874  * @new == NULL means just to get current mapping for 'vcn'
 875  * @new != NULL means allocate real cluster if 'vcn' maps to hole
 876  * @zero - zeroout new allocated clusters
 877  *
 878  *  NOTE:
 879  *  - @new != NULL is called only for sparsed or compressed attributes.
 880  *  - new allocated clusters are zeroed via blkdev_issue_zeroout.
 881  */
 882 int attr_data_get_block(struct ntfs_inode *ni, CLST vcn, CLST clen, CLST *lcn,
 883                         CLST *len, bool *new, bool zero)
 884 {
 885         int err = 0;
 886         struct runs_tree *run = &ni->file.run;
 887         struct ntfs_sb_info *sbi;
 888         u8 cluster_bits;
 889         struct ATTRIB *attr, *attr_b;
 890         struct ATTR_LIST_ENTRY *le, *le_b;
 891         struct mft_inode *mi, *mi_b;
 892         CLST hint, svcn, to_alloc, evcn1, next_svcn, asize, end, vcn0, alen;
 893         CLST alloc, evcn;
 894         unsigned fr;
 895         u64 total_size, total_size0;
 896         int step = 0;
 897
 898         if (new)
 899                 *new = false;
 900
 901         /* Try to find in cache. */
 902         down_read(&ni->file.run_lock);
 903         if (!run_lookup_entry(run, vcn, lcn, len, NULL))
 904                 *len = 0;
 905         up_read(&ni->file.run_lock);
 906
 907         if (*len && (*lcn != SPARSE_LCN || !new))
 908                 return 0; /* Fast normal way without allocation. */
 909
 910         /* No cluster in cache or we need to allocate cluster in hole. */
 911         sbi = ni->mi.sbi;
 912         cluster_bits = sbi->cluster_bits;
 913
 914         ni_lock(ni);
 915         down_write(&ni->file.run_lock);
 916
 917         /* Repeat the code above (under write lock). */
 918         if (!run_lookup_entry(run, vcn, lcn, len, NULL))
 919                 *len = 0;
 920
 921         if (*len) {
 922                 if (*lcn != SPARSE_LCN || !new)
 923                         goto out; /* normal way without allocation. */
 924                 if (clen > *len)
 925                         clen = *len;
 926         }
 927
 928         le_b = NULL;
 929         attr_b = ni_find_attr(ni, NULL, &le_b, ATTR_DATA, NULL, 0, NULL, &mi_b);
 930         if (!attr_b) {
 931                 err = -ENOENT;
 932                 goto out;
 933         }
 934
 935         if (!attr_b->non_res) {
 936                 *lcn = RESIDENT_LCN;
 937                 *len = 1;
 938                 goto out;
 939         }
 940
 941         asize = le64_to_cpu(attr_b->nres.alloc_size) >> cluster_bits;
 942         if (vcn >= asize) {
 943                 if (new) {
 944                         err = -EINVAL;
 945                 } else {
 946                         *len = 1;
 947                         *lcn = SPARSE_LCN;
 948                 }
 949                 goto out;
 950         }
 951
 952         svcn = le64_to_cpu(attr_b->nres.svcn);
 953         evcn1 = le64_to_cpu(attr_b->nres.evcn) + 1;
 954
 955         attr = attr_b;
 956         le = le_b;
 957         mi = mi_b;
 958
 959         if (le_b && (vcn < svcn || evcn1 <= vcn)) {
 960                 attr = ni_find_attr(ni, attr_b, &le, ATTR_DATA, NULL, 0, &vcn,
 961                                     &mi);
 962                 if (!attr) {
 963                         err = -EINVAL;
 964                         goto out;
 965                 }
 966                 svcn = le64_to_cpu(attr->nres.svcn);
 967                 evcn1 = le64_to_cpu(attr->nres.evcn) + 1;
 968         }
 969
 970         /* Load in cache actual information. */
 971         err = attr_load_runs(attr, ni, run, NULL);
 972         if (err)
 973                 goto out;
 974
 975         if (!*len) {
 976                 if (run_lookup_entry(run, vcn, lcn, len, NULL)) {
 977                         if (*lcn != SPARSE_LCN || !new)
 978                                 goto ok; /* Slow normal way without allocation. */
 979
 980                         if (clen > *len)
 981                                 clen = *len;
 982                 } else if (!new) {
 983                         /* Here we may return -ENOENT.
 984                          * In any case caller gets zero length. */
 985                         goto ok;
 986                 }
 987         }
 988
 989         if (!is_attr_ext(attr_b)) {
 990                 /* The code below only for sparsed or compressed attributes. */
 991                 err = -EINVAL;
 992                 goto out;
 993         }
 994
 995         vcn0 = vcn;
 996         to_alloc = clen;
 997         fr = (sbi->record_size - le32_to_cpu(mi->mrec->used) + 8) / 3 + 1;
 998         /* Allocate frame aligned clusters.
 999          * ntfs.sys usually uses 16 clusters per frame for sparsed or compressed.
1000          * ntfs3 uses 1 cluster per frame for new created sparsed files. */
1001         if (attr_b->nres.c_unit) {
1002                 CLST clst_per_frame = 1u << attr_b->nres.c_unit;
1003                 CLST cmask = ~(clst_per_frame - 1);
1004
1005                 /* Get frame aligned vcn and to_alloc. */
1006                 vcn = vcn0 & cmask;
1007                 to_alloc = ((vcn0 + clen + clst_per_frame - 1) & cmask) - vcn;
1008                 if (fr < clst_per_frame)
1009                         fr = clst_per_frame;
1010                 zero = true;
1011
1012                 /* Check if 'vcn' and 'vcn0' in different attribute segments. */
1013                 if (vcn < svcn || evcn1 <= vcn) {
1014                         /* Load attribute for truncated vcn. */
1015                         attr = ni_find_attr(ni, attr_b, &le, ATTR_DATA, NULL, 0,
1016                                             &vcn, &mi);
1017                         if (!attr) {
1018                                 err = -EINVAL;
1019                                 goto out;
1020                         }
1021                         svcn = le64_to_cpu(attr->nres.svcn);
1022                         evcn1 = le64_to_cpu(attr->nres.evcn) + 1;
1023                         err = attr_load_runs(attr, ni, run, NULL);
1024                         if (err)
1025                                 goto out;
1026                 }
1027         }
1028
1029         if (vcn + to_alloc > asize)
1030                 to_alloc = asize - vcn;
1031
1032         /* Get the last LCN to allocate from. */
1033         hint = 0;
1034
1035         if (vcn > evcn1) {
1036                 if (!run_add_entry(run, evcn1, SPARSE_LCN, vcn - evcn1,
1037                                    false)) {
1038                         err = -ENOMEM;
1039                         goto out;
1040                 }
1041         } else if (vcn && !run_lookup_entry(run, vcn - 1, &hint, NULL, NULL)) {
1042                 hint = -1;
1043         }
1044
1045         /* Allocate and zeroout new clusters. */
1046         err = attr_allocate_clusters(sbi, run, vcn, hint + 1, to_alloc, NULL,
1047                                      zero ? ALLOCATE_ZERO : ALLOCATE_DEF, &alen,
1048                                      fr, lcn, len);
1049         if (err)
1050                 goto out;
1051         *new = true;
1052         step = 1;
1053
1054         end = vcn + alen;
1055         /* Save 'total_size0' to restore if error. */
1056         total_size0 = le64_to_cpu(attr_b->nres.total_size);
1057         total_size = total_size0 + ((u64)alen << cluster_bits);
1058
1059         if (vcn != vcn0) {
1060                 if (!run_lookup_entry(run, vcn0, lcn, len, NULL)) {
1061                         err = -EINVAL;
1062                         goto out;
1063                 }
1064                 if (*lcn == SPARSE_LCN) {
1065                         /* Internal error. Should not happened. */
1066                         WARN_ON(1);
1067                         err = -EINVAL;
1068                         goto out;
1069                 }
1070                 /* Check case when vcn0 + len overlaps new allocated clusters. */
1071                 if (vcn0 + *len > end)
1072                         *len = end - vcn0;
1073         }
1074
1075 repack:
1076         err = mi_pack_runs(mi, attr, run, max(end, evcn1) - svcn);
1077         if (err)
1078                 goto out;
1079
1080         attr_b->nres.total_size = cpu_to_le64(total_size);
1081         inode_set_bytes(&ni->vfs_inode, total_size);
1082         ni->ni_flags |= NI_FLAG_UPDATE_PARENT;
1083
1084         mi_b->dirty = true;
1085         mark_inode_dirty(&ni->vfs_inode);
1086
1087         /* Stored [vcn : next_svcn) from [vcn : end). */
1088         next_svcn = le64_to_cpu(attr->nres.evcn) + 1;
1089
1090         if (end <= evcn1) {
1091                 if (next_svcn == evcn1) {
1092                         /* Normal way. Update attribute and exit. */
1093                         goto ok;
1094                 }
1095                 /* Add new segment [next_svcn : evcn1 - next_svcn). */
1096                 if (!ni->attr_list.size) {
1097                         err = ni_create_attr_list(ni);
1098                         if (err)
1099                                 goto undo1;
1100                         /* Layout of records is changed. */
1101                         le_b = NULL;
1102                         attr_b = ni_find_attr(ni, NULL, &le_b, ATTR_DATA, NULL,
1103                                               0, NULL, &mi_b);
1104                         if (!attr_b) {
1105                                 err = -ENOENT;
1106                                 goto out;
1107                         }
1108
1109                         attr = attr_b;
1110                         le = le_b;
1111                         mi = mi_b;
1112                         goto repack;
1113                 }
1114         }
1115
1116         /*
1117          * The code below may require additional cluster (to extend attribute list)
1118          * and / or one MFT record
1119          * It is too complex to undo operations if -ENOSPC occurs deep inside
1120          * in 'ni_insert_nonresident'.
1121          * Return in advance -ENOSPC here if there are no free cluster and no free MFT.
1122          */
1123         if (!ntfs_check_for_free_space(sbi, 1, 1)) {
1124                 /* Undo step 1. */
1125                 err = -ENOSPC;
1126                 goto undo1;
1127         }
1128
1129         step = 2;
1130         svcn = evcn1;
1131
1132         /* Estimate next attribute. */
1133         attr = ni_find_attr(ni, attr, &le, ATTR_DATA, NULL, 0, &svcn, &mi);
1134
1135         if (!attr) {
1136                 /* Insert new attribute segment. */
1137                 goto ins_ext;
1138         }
1139
1140         /* Try to update existed attribute segment. */
1141         alloc = bytes_to_cluster(sbi, le64_to_cpu(attr_b->nres.alloc_size));
1142         evcn = le64_to_cpu(attr->nres.evcn);
1143
1144         if (end < next_svcn)
1145                 end = next_svcn;
1146         while (end > evcn) {
1147                 /* Remove segment [svcn : evcn). */
1148                 mi_remove_attr(NULL, mi, attr);
1149
1150                 if (!al_remove_le(ni, le)) {
1151                         err = -EINVAL;
1152                         goto out;
1153                 }
1154
1155                 if (evcn + 1 >= alloc) {
1156                         /* Last attribute segment. */
1157                         evcn1 = evcn + 1;
1158                         goto ins_ext;
1159                 }
1160
1161                 if (ni_load_mi(ni, le, &mi)) {
1162                         attr = NULL;
1163                         goto out;
1164                 }
1165
1166                 attr = mi_find_attr(mi, NULL, ATTR_DATA, NULL, 0, &le->id);
1167                 if (!attr) {
1168                         err = -EINVAL;
1169                         goto out;
1170                 }
1171                 svcn = le64_to_cpu(attr->nres.svcn);
1172                 evcn = le64_to_cpu(attr->nres.evcn);
1173         }
1174
1175         if (end < svcn)
1176                 end = svcn;
1177
1178         err = attr_load_runs(attr, ni, run, &end);
1179         if (err)
1180                 goto out;
1181
1182         evcn1 = evcn + 1;
1183         attr->nres.svcn = cpu_to_le64(next_svcn);
1184         err = mi_pack_runs(mi, attr, run, evcn1 - next_svcn);
1185         if (err)
1186                 goto out;
1187
1188         le->vcn = cpu_to_le64(next_svcn);
1189         ni->attr_list.dirty = true;
1190         mi->dirty = true;
1191         next_svcn = le64_to_cpu(attr->nres.evcn) + 1;
1192
1193 ins_ext:
1194         if (evcn1 > next_svcn) {
1195                 err = ni_insert_nonresident(ni, ATTR_DATA, NULL, 0, run,
1196                                             next_svcn, evcn1 - next_svcn,
1197                                             attr_b->flags, &attr, &mi, NULL);
1198                 if (err)
1199                         goto out;
1200         }
1201 ok:
1202         run_truncate_around(run, vcn);
1203 out:
1204         if (err && step > 1) {
1205                 /* Too complex to restore. */
1206                 _ntfs_bad_inode(&ni->vfs_inode);
1207         }
1208         up_write(&ni->file.run_lock);
1209         ni_unlock(ni);
1210
1211         return err;
1212
1213 undo1:
1214         /* Undo step1. */
1215         attr_b->nres.total_size = cpu_to_le64(total_size0);
1216         inode_set_bytes(&ni->vfs_inode, total_size0);
1217
1218         if (run_deallocate_ex(sbi, run, vcn, alen, NULL, false) ||
1219             !run_add_entry(run, vcn, SPARSE_LCN, alen, false) ||
1220             mi_pack_runs(mi, attr, run, max(end, evcn1) - svcn)) {
1221                 _ntfs_bad_inode(&ni->vfs_inode);
1222         }
1223         goto out;
1224 }
1225
1226 int attr_data_read_resident(struct ntfs_inode *ni, struct page *page)
1227 {
1228         u64 vbo;
1229         struct ATTRIB *attr;
1230         u32 data_size;
1231
1232         attr = ni_find_attr(ni, NULL, NULL, ATTR_DATA, NULL, 0, NULL, NULL);
1233         if (!attr)
1234                 return -EINVAL;
1235
1236         if (attr->non_res)
1237                 return E_NTFS_NONRESIDENT;
1238
1239         vbo = page->index << PAGE_SHIFT;
1240         data_size = le32_to_cpu(attr->res.data_size);
1241         if (vbo < data_size) {
1242                 const char *data = resident_data(attr);
1243                 char *kaddr = kmap_atomic(page);
1244                 u32 use = data_size - vbo;
1245
1246                 if (use > PAGE_SIZE)
1247                         use = PAGE_SIZE;
1248
1249                 memcpy(kaddr, data + vbo, use);
1250                 memset(kaddr + use, 0, PAGE_SIZE - use);
1251                 kunmap_atomic(kaddr);
1252                 flush_dcache_page(page);
1253                 SetPageUptodate(page);
1254         } else if (!PageUptodate(page)) {
1255                 zero_user_segment(page, 0, PAGE_SIZE);
1256                 SetPageUptodate(page);
1257         }
1258
1259         return 0;
1260 }
1261
1262 int attr_data_write_resident(struct ntfs_inode *ni, struct page *page)
1263 {
1264         u64 vbo;
1265         struct mft_inode *mi;
1266         struct ATTRIB *attr;
1267         u32 data_size;
1268
1269         attr = ni_find_attr(ni, NULL, NULL, ATTR_DATA, NULL, 0, NULL, &mi);
1270         if (!attr)
1271                 return -EINVAL;
1272
1273         if (attr->non_res) {
1274                 /* Return special error code to check this case. */
1275                 return E_NTFS_NONRESIDENT;
1276         }
1277
1278         vbo = page->index << PAGE_SHIFT;
1279         data_size = le32_to_cpu(attr->res.data_size);
1280         if (vbo < data_size) {
1281                 char *data = resident_data(attr);
1282                 char *kaddr = kmap_atomic(page);
1283                 u32 use = data_size - vbo;
1284
1285                 if (use > PAGE_SIZE)
1286                         use = PAGE_SIZE;
1287                 memcpy(data + vbo, kaddr, use);
1288                 kunmap_atomic(kaddr);
1289                 mi->dirty = true;
1290         }
1291         ni->i_valid = data_size;
1292
1293         return 0;
1294 }
1295
1296 /*
1297  * attr_load_runs_vcn - Load runs with VCN.
1298  */
1299 int attr_load_runs_vcn(struct ntfs_inode *ni, enum ATTR_TYPE type,
1300                        const __le16 *name, u8 name_len, struct runs_tree *run,
1301                        CLST vcn)
1302 {
1303         struct ATTRIB *attr;
1304         int err;
1305         CLST svcn, evcn;
1306         u16 ro;
1307
1308         if (!ni) {
1309                 /* Is record corrupted? */
1310                 return -ENOENT;
1311         }
1312
1313         attr = ni_find_attr(ni, NULL, NULL, type, name, name_len, &vcn, NULL);
1314         if (!attr) {
1315                 /* Is record corrupted? */
1316                 return -ENOENT;
1317         }
1318
1319         svcn = le64_to_cpu(attr->nres.svcn);
1320         evcn = le64_to_cpu(attr->nres.evcn);
1321
1322         if (evcn < vcn || vcn < svcn) {
1323                 /* Is record corrupted? */
1324                 return -EINVAL;
1325         }
1326
1327         ro = le16_to_cpu(attr->nres.run_off);
1328
1329         if (ro > le32_to_cpu(attr->size))
1330                 return -EINVAL;
1331
1332         err = run_unpack_ex(run, ni->mi.sbi, ni->mi.rno, svcn, evcn, svcn,
1333                             Add2Ptr(attr, ro), le32_to_cpu(attr->size) - ro);
1334         if (err < 0)
1335                 return err;
1336         return 0;
1337 }
1338
1339 /*
1340  * attr_load_runs_range - Load runs for given range [from to).
1341  */
1342 int attr_load_runs_range(struct ntfs_inode *ni, enum ATTR_TYPE type,
1343                          const __le16 *name, u8 name_len, struct runs_tree *run,
1344                          u64 from, u64 to)
1345 {
1346         struct ntfs_sb_info *sbi = ni->mi.sbi;
1347         u8 cluster_bits = sbi->cluster_bits;
1348         CLST vcn;
1349         CLST vcn_last = (to - 1) >> cluster_bits;
1350         CLST lcn, clen;
1351         int err;
1352
1353         for (vcn = from >> cluster_bits; vcn <= vcn_last; vcn += clen) {
1354                 if (!run_lookup_entry(run, vcn, &lcn, &clen, NULL)) {
1355                         err = attr_load_runs_vcn(ni, type, name, name_len, run,
1356                                                  vcn);
1357                         if (err)
1358                                 return err;
1359                         clen = 0; /* Next run_lookup_entry(vcn) must be success. */
1360                 }
1361         }
1362
1363         return 0;
1364 }
1365
1366 #ifdef CONFIG_NTFS3_LZX_XPRESS
1367 /*
1368  * attr_wof_frame_info
1369  *
1370  * Read header of Xpress/LZX file to get info about frame.
1371  */
1372 int attr_wof_frame_info(struct ntfs_inode *ni, struct ATTRIB *attr,
1373                         struct runs_tree *run, u64 frame, u64 frames,
1374                         u8 frame_bits, u32 *ondisk_size, u64 *vbo_data)
1375 {
1376         struct ntfs_sb_info *sbi = ni->mi.sbi;
1377         u64 vbo[2], off[2], wof_size;
1378         u32 voff;
1379         u8 bytes_per_off;
1380         char *addr;
1381         struct page *page;
1382         int i, err;
1383         __le32 *off32;
1384         __le64 *off64;
1385
1386         if (ni->vfs_inode.i_size < 0x100000000ull) {
1387                 /* File starts with array of 32 bit offsets. */
1388                 bytes_per_off = sizeof(__le32);
1389                 vbo[1] = frame << 2;
1390                 *vbo_data = frames << 2;
1391         } else {
1392                 /* File starts with array of 64 bit offsets. */
1393                 bytes_per_off = sizeof(__le64);
1394                 vbo[1] = frame << 3;
1395                 *vbo_data = frames << 3;
1396         }
1397
1398         /*
1399          * Read 4/8 bytes at [vbo - 4(8)] == offset where compressed frame starts.
1400          * Read 4/8 bytes at [vbo] == offset where compressed frame ends.
1401          */
1402         if (!attr->non_res) {
1403                 if (vbo[1] + bytes_per_off > le32_to_cpu(attr->res.data_size)) {
1404                         ntfs_inode_err(&ni->vfs_inode, "is corrupted");
1405                         return -EINVAL;
1406                 }
1407                 addr = resident_data(attr);
1408
1409                 if (bytes_per_off == sizeof(__le32)) {
1410                         off32 = Add2Ptr(addr, vbo[1]);
1411                         off[0] = vbo[1] ? le32_to_cpu(off32[-1]) : 0;
1412                         off[1] = le32_to_cpu(off32[0]);
1413                 } else {
1414                         off64 = Add2Ptr(addr, vbo[1]);
1415                         off[0] = vbo[1] ? le64_to_cpu(off64[-1]) : 0;
1416                         off[1] = le64_to_cpu(off64[0]);
1417                 }
1418
1419                 *vbo_data += off[0];
1420                 *ondisk_size = off[1] - off[0];
1421                 return 0;
1422         }
1423
1424         wof_size = le64_to_cpu(attr->nres.data_size);
1425         down_write(&ni->file.run_lock);
1426         page = ni->file.offs_page;
1427         if (!page) {
1428                 page = alloc_page(GFP_KERNEL);
1429                 if (!page) {
1430                         err = -ENOMEM;
1431                         goto out;
1432                 }
1433                 page->index = -1;
1434                 ni->file.offs_page = page;
1435         }
1436         lock_page(page);
1437         addr = page_address(page);
1438
1439         if (vbo[1]) {
1440                 voff = vbo[1] & (PAGE_SIZE - 1);
1441                 vbo[0] = vbo[1] - bytes_per_off;
1442                 i = 0;
1443         } else {
1444                 voff = 0;
1445                 vbo[0] = 0;
1446                 off[0] = 0;
1447                 i = 1;
1448         }
1449
1450         do {
1451                 pgoff_t index = vbo[i] >> PAGE_SHIFT;
1452
1453                 if (index != page->index) {
1454                         u64 from = vbo[i] & ~(u64)(PAGE_SIZE - 1);
1455                         u64 to = min(from + PAGE_SIZE, wof_size);
1456
1457                         err = attr_load_runs_range(ni, ATTR_DATA, WOF_NAME,
1458                                                    ARRAY_SIZE(WOF_NAME), run,
1459                                                    from, to);
1460                         if (err)
1461                                 goto out1;
1462
1463                         err = ntfs_bio_pages(sbi, run, &page, 1, from,
1464                                              to - from, REQ_OP_READ);
1465                         if (err) {
1466                                 page->index = -1;
1467                                 goto out1;
1468                         }
1469                         page->index = index;
1470                 }
1471
1472                 if (i) {
1473                         if (bytes_per_off == sizeof(__le32)) {
1474                                 off32 = Add2Ptr(addr, voff);
1475                                 off[1] = le32_to_cpu(*off32);
1476                         } else {
1477                                 off64 = Add2Ptr(addr, voff);
1478                                 off[1] = le64_to_cpu(*off64);
1479                         }
1480                 } else if (!voff) {
1481                         if (bytes_per_off == sizeof(__le32)) {
1482                                 off32 = Add2Ptr(addr, PAGE_SIZE - sizeof(u32));
1483                                 off[0] = le32_to_cpu(*off32);
1484                         } else {
1485                                 off64 = Add2Ptr(addr, PAGE_SIZE - sizeof(u64));
1486                                 off[0] = le64_to_cpu(*off64);
1487                         }
1488                 } else {
1489                         /* Two values in one page. */
1490                         if (bytes_per_off == sizeof(__le32)) {
1491                                 off32 = Add2Ptr(addr, voff);
1492                                 off[0] = le32_to_cpu(off32[-1]);
1493                                 off[1] = le32_to_cpu(off32[0]);
1494                         } else {
1495                                 off64 = Add2Ptr(addr, voff);
1496                                 off[0] = le64_to_cpu(off64[-1]);
1497                                 off[1] = le64_to_cpu(off64[0]);
1498                         }
1499                         break;
1500                 }
1501         } while (++i < 2);
1502
1503         *vbo_data += off[0];
1504         *ondisk_size = off[1] - off[0];
1505
1506 out1:
1507         unlock_page(page);
1508 out:
1509         up_write(&ni->file.run_lock);
1510         return err;
1511 }
1512 #endif
1513
1514 /*
1515  * attr_is_frame_compressed - Used to detect compressed frame.
1516  */
1517 int attr_is_frame_compressed(struct ntfs_inode *ni, struct ATTRIB *attr,
1518                              CLST frame, CLST *clst_data)
1519 {
1520         int err;
1521         u32 clst_frame;
1522         CLST clen, lcn, vcn, alen, slen, vcn_next;
1523         size_t idx;
1524         struct runs_tree *run;
1525
1526         *clst_data = 0;
1527
1528         if (!is_attr_compressed(attr))
1529                 return 0;
1530
1531         if (!attr->non_res)
1532                 return 0;
1533
1534         clst_frame = 1u << attr->nres.c_unit;
1535         vcn = frame * clst_frame;
1536         run = &ni->file.run;
1537
1538         if (!run_lookup_entry(run, vcn, &lcn, &clen, &idx)) {
1539                 err = attr_load_runs_vcn(ni, attr->type, attr_name(attr),
1540                                          attr->name_len, run, vcn);
1541                 if (err)
1542                         return err;
1543
1544                 if (!run_lookup_entry(run, vcn, &lcn, &clen, &idx))
1545                         return -EINVAL;
1546         }
1547
1548         if (lcn == SPARSE_LCN) {
1549                 /* Sparsed frame. */
1550                 return 0;
1551         }
1552
1553         if (clen >= clst_frame) {
1554                 /*
1555                  * The frame is not compressed 'cause
1556                  * it does not contain any sparse clusters.
1557                  */
1558                 *clst_data = clst_frame;
1559                 return 0;
1560         }
1561
1562         alen = bytes_to_cluster(ni->mi.sbi, le64_to_cpu(attr->nres.alloc_size));
1563         slen = 0;
1564         *clst_data = clen;
1565
1566         /*
1567          * The frame is compressed if *clst_data + slen >= clst_frame.
1568          * Check next fragments.
1569          */
1570         while ((vcn += clen) < alen) {
1571                 vcn_next = vcn;
1572
1573                 if (!run_get_entry(run, ++idx, &vcn, &lcn, &clen) ||
1574                     vcn_next != vcn) {
1575                         err = attr_load_runs_vcn(ni, attr->type,
1576                                                  attr_name(attr),
1577                                                  attr->name_len, run, vcn_next);
1578                         if (err)
1579                                 return err;
1580                         vcn = vcn_next;
1581
1582                         if (!run_lookup_entry(run, vcn, &lcn, &clen, &idx))
1583                                 return -EINVAL;
1584                 }
1585
1586                 if (lcn == SPARSE_LCN) {
1587                         slen += clen;
1588                 } else {
1589                         if (slen) {
1590                                 /*
1591                                  * Data_clusters + sparse_clusters =
1592                                  * not enough for frame.
1593                                  */
1594                                 return -EINVAL;
1595                         }
1596                         *clst_data += clen;
1597                 }
1598
1599                 if (*clst_data + slen >= clst_frame) {
1600                         if (!slen) {
1601                                 /*
1602                                  * There is no sparsed clusters in this frame
1603                                  * so it is not compressed.
1604                                  */
1605                                 *clst_data = clst_frame;
1606                         } else {
1607                                 /* Frame is compressed. */
1608                         }
1609                         break;
1610                 }
1611         }
1612
1613         return 0;
1614 }
1615
1616 /*
1617  * attr_allocate_frame - Allocate/free clusters for @frame.
1618  *
1619  * Assumed: down_write(&ni->file.run_lock);
1620  */
1621 int attr_allocate_frame(struct ntfs_inode *ni, CLST frame, size_t compr_size,
1622                         u64 new_valid)
1623 {
1624         int err = 0;
1625         struct runs_tree *run = &ni->file.run;
1626         struct ntfs_sb_info *sbi = ni->mi.sbi;
1627         struct ATTRIB *attr = NULL, *attr_b;
1628         struct ATTR_LIST_ENTRY *le, *le_b;
1629         struct mft_inode *mi, *mi_b;
1630         CLST svcn, evcn1, next_svcn, len;
1631         CLST vcn, end, clst_data;
1632         u64 total_size, valid_size, data_size;
1633
1634         le_b = NULL;
1635         attr_b = ni_find_attr(ni, NULL, &le_b, ATTR_DATA, NULL, 0, NULL, &mi_b);
1636         if (!attr_b)
1637                 return -ENOENT;
1638
1639         if (!is_attr_ext(attr_b))
1640                 return -EINVAL;
1641
1642         vcn = frame << NTFS_LZNT_CUNIT;
1643         total_size = le64_to_cpu(attr_b->nres.total_size);
1644
1645         svcn = le64_to_cpu(attr_b->nres.svcn);
1646         evcn1 = le64_to_cpu(attr_b->nres.evcn) + 1;
1647         data_size = le64_to_cpu(attr_b->nres.data_size);
1648
1649         if (svcn <= vcn && vcn < evcn1) {
1650                 attr = attr_b;
1651                 le = le_b;
1652                 mi = mi_b;
1653         } else if (!le_b) {
1654                 err = -EINVAL;
1655                 goto out;
1656         } else {
1657                 le = le_b;
1658                 attr = ni_find_attr(ni, attr_b, &le, ATTR_DATA, NULL, 0, &vcn,
1659                                     &mi);
1660                 if (!attr) {
1661                         err = -EINVAL;
1662                         goto out;
1663                 }
1664                 svcn = le64_to_cpu(attr->nres.svcn);
1665                 evcn1 = le64_to_cpu(attr->nres.evcn) + 1;
1666         }
1667
1668         err = attr_load_runs(attr, ni, run, NULL);
1669         if (err)
1670                 goto out;
1671
1672         err = attr_is_frame_compressed(ni, attr_b, frame, &clst_data);
1673         if (err)
1674                 goto out;
1675
1676         total_size -= (u64)clst_data << sbi->cluster_bits;
1677
1678         len = bytes_to_cluster(sbi, compr_size);
1679
1680         if (len == clst_data)
1681                 goto out;
1682
1683         if (len < clst_data) {
1684                 err = run_deallocate_ex(sbi, run, vcn + len, clst_data - len,
1685                                         NULL, true);
1686                 if (err)
1687                         goto out;
1688
1689                 if (!run_add_entry(run, vcn + len, SPARSE_LCN, clst_data - len,
1690                                    false)) {
1691                         err = -ENOMEM;
1692                         goto out;
1693                 }
1694                 end = vcn + clst_data;
1695                 /* Run contains updated range [vcn + len : end). */
1696         } else {
1697                 CLST alen, hint = 0;
1698                 /* Get the last LCN to allocate from. */
1699                 if (vcn + clst_data &&
1700                     !run_lookup_entry(run, vcn + clst_data - 1, &hint, NULL,
1701                                       NULL)) {
1702                         hint = -1;
1703                 }
1704
1705                 err = attr_allocate_clusters(sbi, run, vcn + clst_data,
1706                                              hint + 1, len - clst_data, NULL,
1707                                              ALLOCATE_DEF, &alen, 0, NULL,
1708                                              NULL);
1709                 if (err)
1710                         goto out;
1711
1712                 end = vcn + len;
1713                 /* Run contains updated range [vcn + clst_data : end). */
1714         }
1715
1716         total_size += (u64)len << sbi->cluster_bits;
1717
1718 repack:
1719         err = mi_pack_runs(mi, attr, run, max(end, evcn1) - svcn);
1720         if (err)
1721                 goto out;
1722
1723         attr_b->nres.total_size = cpu_to_le64(total_size);
1724         inode_set_bytes(&ni->vfs_inode, total_size);
1725
1726         mi_b->dirty = true;
1727         mark_inode_dirty(&ni->vfs_inode);
1728
1729         /* Stored [vcn : next_svcn) from [vcn : end). */
1730         next_svcn = le64_to_cpu(attr->nres.evcn) + 1;
1731
1732         if (end <= evcn1) {
1733                 if (next_svcn == evcn1) {
1734                         /* Normal way. Update attribute and exit. */
1735                         goto ok;
1736                 }
1737                 /* Add new segment [next_svcn : evcn1 - next_svcn). */
1738                 if (!ni->attr_list.size) {
1739                         err = ni_create_attr_list(ni);
1740                         if (err)
1741                                 goto out;
1742                         /* Layout of records is changed. */
1743                         le_b = NULL;
1744                         attr_b = ni_find_attr(ni, NULL, &le_b, ATTR_DATA, NULL,
1745                                               0, NULL, &mi_b);
1746                         if (!attr_b) {
1747                                 err = -ENOENT;
1748                                 goto out;
1749                         }
1750
1751                         attr = attr_b;
1752                         le = le_b;
1753                         mi = mi_b;
1754                         goto repack;
1755                 }
1756         }
1757
1758         svcn = evcn1;
1759
1760         /* Estimate next attribute. */
1761         attr = ni_find_attr(ni, attr, &le, ATTR_DATA, NULL, 0, &svcn, &mi);
1762
1763         if (attr) {
1764                 CLST alloc = bytes_to_cluster(
1765                         sbi, le64_to_cpu(attr_b->nres.alloc_size));
1766                 CLST evcn = le64_to_cpu(attr->nres.evcn);
1767
1768                 if (end < next_svcn)
1769                         end = next_svcn;
1770                 while (end > evcn) {
1771                         /* Remove segment [svcn : evcn). */
1772                         mi_remove_attr(NULL, mi, attr);
1773
1774                         if (!al_remove_le(ni, le)) {
1775                                 err = -EINVAL;
1776                                 goto out;
1777                         }
1778
1779                         if (evcn + 1 >= alloc) {
1780                                 /* Last attribute segment. */
1781                                 evcn1 = evcn + 1;
1782                                 goto ins_ext;
1783                         }
1784
1785                         if (ni_load_mi(ni, le, &mi)) {
1786                                 attr = NULL;
1787                                 goto out;
1788                         }
1789
1790                         attr = mi_find_attr(mi, NULL, ATTR_DATA, NULL, 0,
1791                                             &le->id);
1792                         if (!attr) {
1793                                 err = -EINVAL;
1794                                 goto out;
1795                         }
1796                         svcn = le64_to_cpu(attr->nres.svcn);
1797                         evcn = le64_to_cpu(attr->nres.evcn);
1798                 }
1799
1800                 if (end < svcn)
1801                         end = svcn;
1802
1803                 err = attr_load_runs(attr, ni, run, &end);
1804                 if (err)
1805                         goto out;
1806
1807                 evcn1 = evcn + 1;
1808                 attr->nres.svcn = cpu_to_le64(next_svcn);
1809                 err = mi_pack_runs(mi, attr, run, evcn1 - next_svcn);
1810                 if (err)
1811                         goto out;
1812
1813                 le->vcn = cpu_to_le64(next_svcn);
1814                 ni->attr_list.dirty = true;
1815                 mi->dirty = true;
1816
1817                 next_svcn = le64_to_cpu(attr->nres.evcn) + 1;
1818         }
1819 ins_ext:
1820         if (evcn1 > next_svcn) {
1821                 err = ni_insert_nonresident(ni, ATTR_DATA, NULL, 0, run,
1822                                             next_svcn, evcn1 - next_svcn,
1823                                             attr_b->flags, &attr, &mi, NULL);
1824                 if (err)
1825                         goto out;
1826         }
1827 ok:
1828         run_truncate_around(run, vcn);
1829 out:
1830         if (attr_b) {
1831                 if (new_valid > data_size)
1832                         new_valid = data_size;
1833
1834                 valid_size = le64_to_cpu(attr_b->nres.valid_size);
1835                 if (new_valid != valid_size) {
1836                         attr_b->nres.valid_size = cpu_to_le64(valid_size);
1837                         mi_b->dirty = true;
1838                 }
1839         }
1840
1841         return err;
1842 }
1843
1844 /*
1845  * attr_collapse_range - Collapse range in file.
1846  */
1847 int attr_collapse_range(struct ntfs_inode *ni, u64 vbo, u64 bytes)
1848 {
1849         int err = 0;
1850         struct runs_tree *run = &ni->file.run;
1851         struct ntfs_sb_info *sbi = ni->mi.sbi;
1852         struct ATTRIB *attr = NULL, *attr_b;
1853         struct ATTR_LIST_ENTRY *le, *le_b;
1854         struct mft_inode *mi, *mi_b;
1855         CLST svcn, evcn1, len, dealloc, alen;
1856         CLST vcn, end;
1857         u64 valid_size, data_size, alloc_size, total_size;
1858         u32 mask;
1859         __le16 a_flags;
1860
1861         if (!bytes)
1862                 return 0;
1863
1864         le_b = NULL;
1865         attr_b = ni_find_attr(ni, NULL, &le_b, ATTR_DATA, NULL, 0, NULL, &mi_b);
1866         if (!attr_b)
1867                 return -ENOENT;
1868
1869         if (!attr_b->non_res) {
1870                 /* Attribute is resident. Nothing to do? */
1871                 return 0;
1872         }
1873
1874         data_size = le64_to_cpu(attr_b->nres.data_size);
1875         alloc_size = le64_to_cpu(attr_b->nres.alloc_size);
1876         a_flags = attr_b->flags;
1877
1878         if (is_attr_ext(attr_b)) {
1879                 total_size = le64_to_cpu(attr_b->nres.total_size);
1880                 mask = (sbi->cluster_size << attr_b->nres.c_unit) - 1;
1881         } else {
1882                 total_size = alloc_size;
1883                 mask = sbi->cluster_mask;
1884         }
1885
1886         if ((vbo & mask) || (bytes & mask)) {
1887                 /* Allow to collapse only cluster aligned ranges. */
1888                 return -EINVAL;
1889         }
1890
1891         if (vbo > data_size)
1892                 return -EINVAL;
1893
1894         down_write(&ni->file.run_lock);
1895
1896         if (vbo + bytes >= data_size) {
1897                 u64 new_valid = min(ni->i_valid, vbo);
1898
1899                 /* Simple truncate file at 'vbo'. */
1900                 truncate_setsize(&ni->vfs_inode, vbo);
1901                 err = attr_set_size(ni, ATTR_DATA, NULL, 0, &ni->file.run, vbo,
1902                                     &new_valid, true, NULL);
1903
1904                 if (!err && new_valid < ni->i_valid)
1905                         ni->i_valid = new_valid;
1906
1907                 goto out;
1908         }
1909
1910         /*
1911          * Enumerate all attribute segments and collapse.
1912          */
1913         alen = alloc_size >> sbi->cluster_bits;
1914         vcn = vbo >> sbi->cluster_bits;
1915         len = bytes >> sbi->cluster_bits;
1916         end = vcn + len;
1917         dealloc = 0;
1918
1919         svcn = le64_to_cpu(attr_b->nres.svcn);
1920         evcn1 = le64_to_cpu(attr_b->nres.evcn) + 1;
1921
1922         if (svcn <= vcn && vcn < evcn1) {
1923                 attr = attr_b;
1924                 le = le_b;
1925                 mi = mi_b;
1926         } else if (!le_b) {
1927                 err = -EINVAL;
1928                 goto out;
1929         } else {
1930                 le = le_b;
1931                 attr = ni_find_attr(ni, attr_b, &le, ATTR_DATA, NULL, 0, &vcn,
1932                                     &mi);
1933                 if (!attr) {
1934                         err = -EINVAL;
1935                         goto out;
1936                 }
1937
1938                 svcn = le64_to_cpu(attr->nres.svcn);
1939                 evcn1 = le64_to_cpu(attr->nres.evcn) + 1;
1940         }
1941
1942         for (;;) {
1943                 if (svcn >= end) {
1944                         /* Shift VCN- */
1945                         attr->nres.svcn = cpu_to_le64(svcn - len);
1946                         attr->nres.evcn = cpu_to_le64(evcn1 - 1 - len);
1947                         if (le) {
1948                                 le->vcn = attr->nres.svcn;
1949                                 ni->attr_list.dirty = true;
1950                         }
1951                         mi->dirty = true;
1952                 } else if (svcn < vcn || end < evcn1) {
1953                         CLST vcn1, eat, next_svcn;
1954
1955                         /* Collapse a part of this attribute segment. */
1956                         err = attr_load_runs(attr, ni, run, &svcn);
1957                         if (err)
1958                                 goto out;
1959                         vcn1 = max(vcn, svcn);
1960                         eat = min(end, evcn1) - vcn1;
1961
1962                         err = run_deallocate_ex(sbi, run, vcn1, eat, &dealloc,
1963                                                 true);
1964                         if (err)
1965                                 goto out;
1966
1967                         if (!run_collapse_range(run, vcn1, eat)) {
1968                                 err = -ENOMEM;
1969                                 goto out;
1970                         }
1971
1972                         if (svcn >= vcn) {
1973                                 /* Shift VCN */
1974                                 attr->nres.svcn = cpu_to_le64(vcn);
1975                                 if (le) {
1976                                         le->vcn = attr->nres.svcn;
1977                                         ni->attr_list.dirty = true;
1978                                 }
1979                         }
1980
1981                         err = mi_pack_runs(mi, attr, run, evcn1 - svcn - eat);
1982                         if (err)
1983                                 goto out;
1984
1985                         next_svcn = le64_to_cpu(attr->nres.evcn) + 1;
1986                         if (next_svcn + eat < evcn1) {
1987                                 err = ni_insert_nonresident(
1988                                         ni, ATTR_DATA, NULL, 0, run, next_svcn,
1989                                         evcn1 - eat - next_svcn, a_flags, &attr,
1990                                         &mi, &le);
1991                                 if (err)
1992                                         goto out;
1993
1994                                 /* Layout of records maybe changed. */
1995                                 attr_b = NULL;
1996                         }
1997
1998                         /* Free all allocated memory. */
1999                         run_truncate(run, 0);
2000                 } else {
2001                         u16 le_sz;
2002                         u16 roff = le16_to_cpu(attr->nres.run_off);
2003
2004                         if (roff > le32_to_cpu(attr->size)) {
2005                                 err = -EINVAL;
2006                                 goto out;
2007                         }
2008
2009                         run_unpack_ex(RUN_DEALLOCATE, sbi, ni->mi.rno, svcn,
2010                                       evcn1 - 1, svcn, Add2Ptr(attr, roff),
2011                                       le32_to_cpu(attr->size) - roff);
2012
2013                         /* Delete this attribute segment. */
2014                         mi_remove_attr(NULL, mi, attr);
2015                         if (!le)
2016                                 break;
2017
2018                         le_sz = le16_to_cpu(le->size);
2019                         if (!al_remove_le(ni, le)) {
2020                                 err = -EINVAL;
2021                                 goto out;
2022                         }
2023
2024                         if (evcn1 >= alen)
2025                                 break;
2026
2027                         if (!svcn) {
2028                                 /* Load next record that contains this attribute. */
2029                                 if (ni_load_mi(ni, le, &mi)) {
2030                                         err = -EINVAL;
2031                                         goto out;
2032                                 }
2033
2034                                 /* Look for required attribute. */
2035                                 attr = mi_find_attr(mi, NULL, ATTR_DATA, NULL,
2036                                                     0, &le->id);
2037                                 if (!attr) {
2038                                         err = -EINVAL;
2039                                         goto out;
2040                                 }
2041                                 goto next_attr;
2042                         }
2043                         le = (struct ATTR_LIST_ENTRY *)((u8 *)le - le_sz);
2044                 }
2045
2046                 if (evcn1 >= alen)
2047                         break;
2048
2049                 attr = ni_enum_attr_ex(ni, attr, &le, &mi);
2050                 if (!attr) {
2051                         err = -EINVAL;
2052                         goto out;
2053                 }
2054
2055 next_attr:
2056                 svcn = le64_to_cpu(attr->nres.svcn);
2057                 evcn1 = le64_to_cpu(attr->nres.evcn) + 1;
2058         }
2059
2060         if (!attr_b) {
2061                 le_b = NULL;
2062                 attr_b = ni_find_attr(ni, NULL, &le_b, ATTR_DATA, NULL, 0, NULL,
2063                                       &mi_b);
2064                 if (!attr_b) {
2065                         err = -ENOENT;
2066                         goto out;
2067                 }
2068         }
2069
2070         data_size -= bytes;
2071         valid_size = ni->i_valid;
2072         if (vbo + bytes <= valid_size)
2073                 valid_size -= bytes;
2074         else if (vbo < valid_size)
2075                 valid_size = vbo;
2076
2077         attr_b->nres.alloc_size = cpu_to_le64(alloc_size - bytes);
2078         attr_b->nres.data_size = cpu_to_le64(data_size);
2079         attr_b->nres.valid_size = cpu_to_le64(min(valid_size, data_size));
2080         total_size -= (u64)dealloc << sbi->cluster_bits;
2081         if (is_attr_ext(attr_b))
2082                 attr_b->nres.total_size = cpu_to_le64(total_size);
2083         mi_b->dirty = true;
2084
2085         /* Update inode size. */
2086         ni->i_valid = valid_size;
2087         i_size_write(&ni->vfs_inode, data_size);
2088         inode_set_bytes(&ni->vfs_inode, total_size);
2089         ni->ni_flags |= NI_FLAG_UPDATE_PARENT;
2090         mark_inode_dirty(&ni->vfs_inode);
2091
2092 out:
2093         up_write(&ni->file.run_lock);
2094         if (err)
2095                 _ntfs_bad_inode(&ni->vfs_inode);
2096
2097         return err;
2098 }
2099
2100 /*
2101  * attr_punch_hole
2102  *
2103  * Not for normal files.
2104  */
2105 int attr_punch_hole(struct ntfs_inode *ni, u64 vbo, u64 bytes, u32 *frame_size)
2106 {
2107         int err = 0;
2108         struct runs_tree *run = &ni->file.run;
2109         struct ntfs_sb_info *sbi = ni->mi.sbi;
2110         struct ATTRIB *attr = NULL, *attr_b;
2111         struct ATTR_LIST_ENTRY *le, *le_b;
2112         struct mft_inode *mi, *mi_b;
2113         CLST svcn, evcn1, vcn, len, end, alen, hole, next_svcn;
2114         u64 total_size, alloc_size;
2115         u32 mask;
2116         __le16 a_flags;
2117         struct runs_tree run2;
2118
2119         if (!bytes)
2120                 return 0;
2121
2122         le_b = NULL;
2123         attr_b = ni_find_attr(ni, NULL, &le_b, ATTR_DATA, NULL, 0, NULL, &mi_b);
2124         if (!attr_b)
2125                 return -ENOENT;
2126
2127         if (!attr_b->non_res) {
2128                 u32 data_size = le32_to_cpu(attr_b->res.data_size);
2129                 u32 from, to;
2130
2131                 if (vbo > data_size)
2132                         return 0;
2133
2134                 from = vbo;
2135                 to = min_t(u64, vbo + bytes, data_size);
2136                 memset(Add2Ptr(resident_data(attr_b), from), 0, to - from);
2137                 return 0;
2138         }
2139
2140         if (!is_attr_ext(attr_b))
2141                 return -EOPNOTSUPP;
2142
2143         alloc_size = le64_to_cpu(attr_b->nres.alloc_size);
2144         total_size = le64_to_cpu(attr_b->nres.total_size);
2145
2146         if (vbo >= alloc_size) {
2147                 /* NOTE: It is allowed. */
2148                 return 0;
2149         }
2150
2151         mask = (sbi->cluster_size << attr_b->nres.c_unit) - 1;
2152
2153         bytes += vbo;
2154         if (bytes > alloc_size)
2155                 bytes = alloc_size;
2156         bytes -= vbo;
2157
2158         if ((vbo & mask) || (bytes & mask)) {
2159                 /* We have to zero a range(s). */
2160                 if (frame_size == NULL) {
2161                         /* Caller insists range is aligned. */
2162                         return -EINVAL;
2163                 }
2164                 *frame_size = mask + 1;
2165                 return E_NTFS_NOTALIGNED;
2166         }
2167
2168         down_write(&ni->file.run_lock);
2169         run_init(&run2);
2170         run_truncate(run, 0);
2171
2172         /*
2173          * Enumerate all attribute segments and punch hole where necessary.
2174          */
2175         alen = alloc_size >> sbi->cluster_bits;
2176         vcn = vbo >> sbi->cluster_bits;
2177         len = bytes >> sbi->cluster_bits;
2178         end = vcn + len;
2179         hole = 0;
2180
2181         svcn = le64_to_cpu(attr_b->nres.svcn);
2182         evcn1 = le64_to_cpu(attr_b->nres.evcn) + 1;
2183         a_flags = attr_b->flags;
2184
2185         if (svcn <= vcn && vcn < evcn1) {
2186                 attr = attr_b;
2187                 le = le_b;
2188                 mi = mi_b;
2189         } else if (!le_b) {
2190                 err = -EINVAL;
2191                 goto bad_inode;
2192         } else {
2193                 le = le_b;
2194                 attr = ni_find_attr(ni, attr_b, &le, ATTR_DATA, NULL, 0, &vcn,
2195                                     &mi);
2196                 if (!attr) {
2197                         err = -EINVAL;
2198                         goto bad_inode;
2199                 }
2200
2201                 svcn = le64_to_cpu(attr->nres.svcn);
2202                 evcn1 = le64_to_cpu(attr->nres.evcn) + 1;
2203         }
2204
2205         while (svcn < end) {
2206                 CLST vcn1, zero, hole2 = hole;
2207
2208                 err = attr_load_runs(attr, ni, run, &svcn);
2209                 if (err)
2210                         goto done;
2211                 vcn1 = max(vcn, svcn);
2212                 zero = min(end, evcn1) - vcn1;
2213
2214                 /*
2215                  * Check range [vcn1 + zero).
2216                  * Calculate how many clusters there are.
2217                  * Don't do any destructive actions.
2218                  */
2219                 err = run_deallocate_ex(NULL, run, vcn1, zero, &hole2, false);
2220                 if (err)
2221                         goto done;
2222
2223                 /* Check if required range is already hole. */
2224                 if (hole2 == hole)
2225                         goto next_attr;
2226
2227                 /* Make a clone of run to undo. */
2228                 err = run_clone(run, &run2);
2229                 if (err)
2230                         goto done;
2231
2232                 /* Make a hole range (sparse) [vcn1 + zero). */
2233                 if (!run_add_entry(run, vcn1, SPARSE_LCN, zero, false)) {
2234                         err = -ENOMEM;
2235                         goto done;
2236                 }
2237
2238                 /* Update run in attribute segment. */
2239                 err = mi_pack_runs(mi, attr, run, evcn1 - svcn);
2240                 if (err)
2241                         goto done;
2242                 next_svcn = le64_to_cpu(attr->nres.evcn) + 1;
2243                 if (next_svcn < evcn1) {
2244                         /* Insert new attribute segment. */
2245                         err = ni_insert_nonresident(ni, ATTR_DATA, NULL, 0, run,
2246                                                     next_svcn,
2247                                                     evcn1 - next_svcn, a_flags,
2248                                                     &attr, &mi, &le);
2249                         if (err)
2250                                 goto undo_punch;
2251
2252                         /* Layout of records maybe changed. */
2253                         attr_b = NULL;
2254                 }
2255
2256                 /* Real deallocate. Should not fail. */
2257                 run_deallocate_ex(sbi, &run2, vcn1, zero, &hole, true);
2258
2259 next_attr:
2260                 /* Free all allocated memory. */
2261                 run_truncate(run, 0);
2262
2263                 if (evcn1 >= alen)
2264                         break;
2265
2266                 /* Get next attribute segment. */
2267                 attr = ni_enum_attr_ex(ni, attr, &le, &mi);
2268                 if (!attr) {
2269                         err = -EINVAL;
2270                         goto bad_inode;
2271                 }
2272
2273                 svcn = le64_to_cpu(attr->nres.svcn);
2274                 evcn1 = le64_to_cpu(attr->nres.evcn) + 1;
2275         }
2276
2277 done:
2278         if (!hole)
2279                 goto out;
2280
2281         if (!attr_b) {
2282                 attr_b = ni_find_attr(ni, NULL, NULL, ATTR_DATA, NULL, 0, NULL,
2283                                       &mi_b);
2284                 if (!attr_b) {
2285                         err = -EINVAL;
2286                         goto bad_inode;
2287                 }
2288         }
2289
2290         total_size -= (u64)hole << sbi->cluster_bits;
2291         attr_b->nres.total_size = cpu_to_le64(total_size);
2292         mi_b->dirty = true;
2293
2294         /* Update inode size. */
2295         inode_set_bytes(&ni->vfs_inode, total_size);
2296         ni->ni_flags |= NI_FLAG_UPDATE_PARENT;
2297         mark_inode_dirty(&ni->vfs_inode);
2298
2299 out:
2300         run_close(&run2);
2301         up_write(&ni->file.run_lock);
2302         return err;
2303
2304 bad_inode:
2305         _ntfs_bad_inode(&ni->vfs_inode);
2306         goto out;
2307
2308 undo_punch:
2309         /*
2310          * Restore packed runs.
2311          * 'mi_pack_runs' should not fail, cause we restore original.
2312          */
2313         if (mi_pack_runs(mi, attr, &run2, evcn1 - svcn))
2314                 goto bad_inode;
2315
2316         goto done;
2317 }
2318
2319 /*
2320  * attr_insert_range - Insert range (hole) in file.
2321  * Not for normal files.
2322  */
2323 int attr_insert_range(struct ntfs_inode *ni, u64 vbo, u64 bytes)
2324 {
2325         int err = 0;
2326         struct runs_tree *run = &ni->file.run;
2327         struct ntfs_sb_info *sbi = ni->mi.sbi;
2328         struct ATTRIB *attr = NULL, *attr_b;
2329         struct ATTR_LIST_ENTRY *le, *le_b;
2330         struct mft_inode *mi, *mi_b;
2331         CLST vcn, svcn, evcn1, len, next_svcn;
2332         u64 data_size, alloc_size;
2333         u32 mask;
2334         __le16 a_flags;
2335
2336         if (!bytes)
2337                 return 0;
2338
2339         le_b = NULL;
2340         attr_b = ni_find_attr(ni, NULL, &le_b, ATTR_DATA, NULL, 0, NULL, &mi_b);
2341         if (!attr_b)
2342                 return -ENOENT;
2343
2344         if (!is_attr_ext(attr_b)) {
2345                 /* It was checked above. See fallocate. */
2346                 return -EOPNOTSUPP;
2347         }
2348
2349         if (!attr_b->non_res) {
2350                 data_size = le32_to_cpu(attr_b->res.data_size);
2351                 alloc_size = data_size;
2352                 mask = sbi->cluster_mask; /* cluster_size - 1 */
2353         } else {
2354                 data_size = le64_to_cpu(attr_b->nres.data_size);
2355                 alloc_size = le64_to_cpu(attr_b->nres.alloc_size);
2356                 mask = (sbi->cluster_size << attr_b->nres.c_unit) - 1;
2357         }
2358
2359         if (vbo > data_size) {
2360                 /* Insert range after the file size is not allowed. */
2361                 return -EINVAL;
2362         }
2363
2364         if ((vbo & mask) || (bytes & mask)) {
2365                 /* Allow to insert only frame aligned ranges. */
2366                 return -EINVAL;
2367         }
2368
2369         /*
2370          * valid_size <= data_size <= alloc_size
2371          * Check alloc_size for maximum possible.
2372          */
2373         if (bytes > sbi->maxbytes_sparse - alloc_size)
2374                 return -EFBIG;
2375
2376         vcn = vbo >> sbi->cluster_bits;
2377         len = bytes >> sbi->cluster_bits;
2378
2379         down_write(&ni->file.run_lock);
2380
2381         if (!attr_b->non_res) {
2382                 err = attr_set_size(ni, ATTR_DATA, NULL, 0, run,
2383                                     data_size + bytes, NULL, false, NULL);
2384
2385                 le_b = NULL;
2386                 attr_b = ni_find_attr(ni, NULL, &le_b, ATTR_DATA, NULL, 0, NULL,
2387                                       &mi_b);
2388                 if (!attr_b) {
2389                         err = -EINVAL;
2390                         goto bad_inode;
2391                 }
2392
2393                 if (err)
2394                         goto out;
2395
2396                 if (!attr_b->non_res) {
2397                         /* Still resident. */
2398                         char *data = Add2Ptr(attr_b,
2399                                              le16_to_cpu(attr_b->res.data_off));
2400
2401                         memmove(data + bytes, data, bytes);
2402                         memset(data, 0, bytes);
2403                         goto done;
2404                 }
2405
2406                 /* Resident files becomes nonresident. */
2407                 data_size = le64_to_cpu(attr_b->nres.data_size);
2408                 alloc_size = le64_to_cpu(attr_b->nres.alloc_size);
2409         }
2410
2411         /*
2412          * Enumerate all attribute segments and shift start vcn.
2413          */
2414         a_flags = attr_b->flags;
2415         svcn = le64_to_cpu(attr_b->nres.svcn);
2416         evcn1 = le64_to_cpu(attr_b->nres.evcn) + 1;
2417
2418         if (svcn <= vcn && vcn < evcn1) {
2419                 attr = attr_b;
2420                 le = le_b;
2421                 mi = mi_b;
2422         } else if (!le_b) {
2423                 err = -EINVAL;
2424                 goto bad_inode;
2425         } else {
2426                 le = le_b;
2427                 attr = ni_find_attr(ni, attr_b, &le, ATTR_DATA, NULL, 0, &vcn,
2428                                     &mi);
2429                 if (!attr) {
2430                         err = -EINVAL;
2431                         goto bad_inode;
2432                 }
2433
2434                 svcn = le64_to_cpu(attr->nres.svcn);
2435                 evcn1 = le64_to_cpu(attr->nres.evcn) + 1;
2436         }
2437
2438         run_truncate(run, 0); /* clear cached values. */
2439         err = attr_load_runs(attr, ni, run, NULL);
2440         if (err)
2441                 goto out;
2442
2443         if (!run_insert_range(run, vcn, len)) {
2444                 err = -ENOMEM;
2445                 goto out;
2446         }
2447
2448         /* Try to pack in current record as much as possible. */
2449         err = mi_pack_runs(mi, attr, run, evcn1 + len - svcn);
2450         if (err)
2451                 goto out;
2452
2453         next_svcn = le64_to_cpu(attr->nres.evcn) + 1;
2454
2455         while ((attr = ni_enum_attr_ex(ni, attr, &le, &mi)) &&
2456                attr->type == ATTR_DATA && !attr->name_len) {
2457                 le64_add_cpu(&attr->nres.svcn, len);
2458                 le64_add_cpu(&attr->nres.evcn, len);
2459                 if (le) {
2460                         le->vcn = attr->nres.svcn;
2461                         ni->attr_list.dirty = true;
2462                 }
2463                 mi->dirty = true;
2464         }
2465
2466         if (next_svcn < evcn1 + len) {
2467                 err = ni_insert_nonresident(ni, ATTR_DATA, NULL, 0, run,
2468                                             next_svcn, evcn1 + len - next_svcn,
2469                                             a_flags, NULL, NULL, NULL);
2470
2471                 le_b = NULL;
2472                 attr_b = ni_find_attr(ni, NULL, &le_b, ATTR_DATA, NULL, 0, NULL,
2473                                       &mi_b);
2474                 if (!attr_b) {
2475                         err = -EINVAL;
2476                         goto bad_inode;
2477                 }
2478
2479                 if (err) {
2480                         /* ni_insert_nonresident failed. Try to undo. */
2481                         goto undo_insert_range;
2482                 }
2483         }
2484
2485         /*
2486          * Update primary attribute segment.
2487          */
2488         if (vbo <= ni->i_valid)
2489                 ni->i_valid += bytes;
2490
2491         attr_b->nres.data_size = cpu_to_le64(data_size + bytes);
2492         attr_b->nres.alloc_size = cpu_to_le64(alloc_size + bytes);
2493
2494         /* ni->valid may be not equal valid_size (temporary). */
2495         if (ni->i_valid > data_size + bytes)
2496                 attr_b->nres.valid_size = attr_b->nres.data_size;
2497         else
2498                 attr_b->nres.valid_size = cpu_to_le64(ni->i_valid);
2499         mi_b->dirty = true;
2500
2501 done:
2502         i_size_write(&ni->vfs_inode, ni->vfs_inode.i_size + bytes);
2503         ni->ni_flags |= NI_FLAG_UPDATE_PARENT;
2504         mark_inode_dirty(&ni->vfs_inode);
2505
2506 out:
2507         run_truncate(run, 0); /* clear cached values. */
2508
2509         up_write(&ni->file.run_lock);
2510
2511         return err;
2512
2513 bad_inode:
2514         _ntfs_bad_inode(&ni->vfs_inode);
2515         goto out;
2516
2517 undo_insert_range:
2518         svcn = le64_to_cpu(attr_b->nres.svcn);
2519         evcn1 = le64_to_cpu(attr_b->nres.evcn) + 1;
2520
2521         if (svcn <= vcn && vcn < evcn1) {
2522                 attr = attr_b;
2523                 le = le_b;
2524                 mi = mi_b;
2525         } else if (!le_b) {
2526                 goto bad_inode;
2527         } else {
2528                 le = le_b;
2529                 attr = ni_find_attr(ni, attr_b, &le, ATTR_DATA, NULL, 0, &vcn,
2530                                     &mi);
2531                 if (!attr) {
2532                         goto bad_inode;
2533                 }
2534
2535                 svcn = le64_to_cpu(attr->nres.svcn);
2536                 evcn1 = le64_to_cpu(attr->nres.evcn) + 1;
2537         }
2538
2539         if (attr_load_runs(attr, ni, run, NULL))
2540                 goto bad_inode;
2541
2542         if (!run_collapse_range(run, vcn, len))
2543                 goto bad_inode;
2544
2545         if (mi_pack_runs(mi, attr, run, evcn1 + len - svcn))
2546                 goto bad_inode;
2547
2548         while ((attr = ni_enum_attr_ex(ni, attr, &le, &mi)) &&
2549                attr->type == ATTR_DATA && !attr->name_len) {
2550                 le64_sub_cpu(&attr->nres.svcn, len);
2551                 le64_sub_cpu(&attr->nres.evcn, len);
2552                 if (le) {
2553                         le->vcn = attr->nres.svcn;
2554                         ni->attr_list.dirty = true;
2555                 }
2556                 mi->dirty = true;
2557         }
2558
2559         goto out;
2560 }
2561
2562 /*
2563  * attr_force_nonresident
2564  *
2565  * Convert default data attribute into non resident form.
2566  */
2567 int attr_force_nonresident(struct ntfs_inode *ni)
2568 {
2569         int err;
2570         struct ATTRIB *attr;
2571         struct ATTR_LIST_ENTRY *le = NULL;
2572         struct mft_inode *mi;
2573
2574         attr = ni_find_attr(ni, NULL, &le, ATTR_DATA, NULL, 0, NULL, &mi);
2575         if (!attr) {
2576                 ntfs_bad_inode(&ni->vfs_inode, "no data attribute");
2577                 return -ENOENT;
2578         }
2579
2580         if (attr->non_res) {
2581                 /* Already non resident. */
2582                 return 0;
2583         }
2584
2585         down_write(&ni->file.run_lock);
2586         err = attr_make_nonresident(ni, attr, le, mi,
2587                                     le32_to_cpu(attr->res.data_size),
2588                                     &ni->file.run, &attr, NULL);
2589         up_write(&ni->file.run_lock);
2590
2591         return err;
2592 }