Loading...
Note: File does not exist in v4.6.
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
34static 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 */
60static 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 */
93static 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)) {
104failed:
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
139out:
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 */
149int 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
210out:
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 */
226int 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
333out3:
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;
339out2:
340 /* Undo: do not trim new allocated clusters. */
341 run_deallocate(sbi, run, false);
342 run_close(run);
343out1:
344 kfree(attr_s);
345out:
346 return err;
347}
348
349/*
350 * attr_set_size_res - Helper for attr_set_size().
351 */
352static 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 */
400int 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
421again:
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
456again_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
489next_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 */
498next_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;
522add_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
592pack_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
795ok:
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
805ok1:
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
829undo_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
855restore_run:
856 if (mi_pack_runs(mi, attr, run, evcn - svcn + 1))
857 is_bad = true;
858
859undo_1:
860 run_deallocate_ex(sbi, run, vcn, alen, NULL, false);
861
862 run_truncate(run, vcn);
863out:
864 if (is_bad) {
865bad_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 */
882int 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
1075repack:
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
1193ins_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 }
1201ok:
1202 run_truncate_around(run, vcn);
1203out:
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
1213undo1:
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
1226int 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
1262int 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 */
1299int 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 */
1342int 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 */
1372int 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
1506out1:
1507 unlock_page(page);
1508out:
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 */
1517int 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 */
1621int 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
1718repack:
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 }
1819ins_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 }
1827ok:
1828 run_truncate_around(run, vcn);
1829out:
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 */
1847int 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
2055next_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
2092out:
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 */
2105int 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
2259next_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
2277done:
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
2299out:
2300 run_close(&run2);
2301 up_write(&ni->file.run_lock);
2302 return err;
2303
2304bad_inode:
2305 _ntfs_bad_inode(&ni->vfs_inode);
2306 goto out;
2307
2308undo_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 */
2323int 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
2501done:
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
2506out:
2507 run_truncate(run, 0); /* clear cached values. */
2508
2509 up_write(&ni->file.run_lock);
2510
2511 return err;
2512
2513bad_inode:
2514 _ntfs_bad_inode(&ni->vfs_inode);
2515 goto out;
2516
2517undo_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}