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, sbi: ni->mi.sbi, ino: ni->mi.rno, svcn, evcn,
82	vcn: vcn ? *vcn : svcn, Add2Ptr(attr, run_off),
83	run_buf_size: 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: &lcn, len: &clen, index: &idx)) {
104	failed:
105	run_truncate(run, vcn: 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, len: 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, index: ++idx, vcn: &vcn, lcn: &lcn, len: &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: len + pre, new_lcn: &lcn, new_len: &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, len: flen, is_mft: opt & ALLOCATE_MFT)) {
182	/* Undo last 'ntfs_look_for_free_space' */
183	mark_as_free_ex(sbi, lcn, len, trim: 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(bdev: sbi->sb->s_bdev,
192	sector: (sector_t)lcn << shift,
193	nr_sects: (sector_t)flen << shift,
194	GFP_NOFS, flags: 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, vcn: vcn0, len: vcn - vcn0, NULL, trim: false);
214	run_truncate(run, vcn: 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(p: attr, size: 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, vcn: 0, lcn: 0, len, NULL,
276	opt: ALLOCATE_DEF, alen: &alen, fr: 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, vbo: 0, buf: data, bytes: rsize, sync: 0);
285	if (err)
286	goto out2;
287	} else if (!page) {
288	char *kaddr;
289
290	page = grab_cache_page(mapping: ni->vfs_inode.i_mapping, index: 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, type: attr_s->type, name: attr_name(attr: attr_s),
316	name_len: attr_s->name_len, run, svcn: 0, len: alen,
317	flags: attr_s->flags, new_attr: &attr, NULL, NULL);
318	if (err)
319	goto out3;
320
321	kfree(objp: 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, trim: false);
342	run_close(run);
343	out1:
344	kfree(objp: 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, entry_o: &le_b, type, name, name_len, NULL,
425	mi: &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: attr_b, le: le_b, mi: mi_b, new_size, run,
433	ins_attr: &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: 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: attr_b, entry_o: &le, type, name, name_len, vcn: &vcn,
483	mi: &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, size: get_pre_allocated(
536	size: 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: &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(wnd: &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, len: to_allocate,
565	is_mft: 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, len: to_allocate, pre_alloc: &pre_alloc,
574	opt: is_mft ? ALLOCATE_MFT : ALLOCATE_DEF, alen: &alen,
575	fr: 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, len: 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	svcn: next_svcn, len: vcn - next_svcn,
653	flags: attr_b->flags, new_attr: &attr, mi: &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, entry_o: &le_b, type, name, name_len,
661	NULL, mi: &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, vcn: 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, len: 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, len: evcn - vcn + 1, done: &dlen,
751	trim: true);
752	if (err)
753	goto out;
754
755	if (is_ext) {
756	/* dlen - really deallocated clusters. */
757	le64_sub_cpu(var: &attr_b->nres.total_size,
758	val: ((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(p: le_name(le), q: name, size: name_len * sizeof(short))) {
779	err = -EINVAL;
780	goto bad_inode;
781	}
782
783	err = ni_load_mi(ni, le, mi: &mi);
784	if (err)
785	goto out;
786
787	attr = mi_find_attr(mi, NULL, type, name, name_len, id: &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(inode: &ni->vfs_inode) != new_alloc) {
815	inode_set_bytes(inode: &ni->vfs_inode, bytes: 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(inode: &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: attr_b, entry_o: &le, type, name, name_len,
850	vcn: &svcn, mi: &mi);
851	if (!attr)
852	goto bad_inode;
853	}
854
855	restore_run:
856	if (mi_pack_runs(mi, attr, run, len: evcn - svcn + 1))
857	is_bad = true;
858
859	undo_1:
860	run_deallocate_ex(sbi, run, vcn, len: alen, NULL, trim: 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(sem: &ni->file.run_lock);
903	if (!run_lookup_entry(run, vcn, lcn, len, NULL))
904	*len = 0;
905	up_read(sem: &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(sem: &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, entry_o: &le_b, type: ATTR_DATA, NULL, name_len: 0, NULL, mi: &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: attr_b, entry_o: &le, type: ATTR_DATA, NULL, name_len: 0, vcn: &vcn,
961	mi: &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: 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: attr_b, entry_o: &le, type: ATTR_DATA, NULL, name_len: 0,
1016	vcn: &vcn, mi: &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, vcn: evcn1, SPARSE_LCN, len: vcn - evcn1,
1037	is_mft: false)) {
1038	err = -ENOMEM;
1039	goto out;
1040	}
1041	} else if (vcn && !run_lookup_entry(run, vcn: vcn - 1, lcn: &hint, NULL, NULL)) {
1042	hint = -1;
1043	}
1044
1045	/* Allocate and zeroout new clusters. */
1046	err = attr_allocate_clusters(sbi, run, vcn, lcn: hint + 1, len: to_alloc, NULL,
1047	opt: zero ? ALLOCATE_ZERO : ALLOCATE_DEF, alen: &alen,
1048	fr, new_lcn: lcn, new_len: 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, vcn: 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(inode: &ni->vfs_inode, bytes: total_size);
1082	ni->ni_flags |= NI_FLAG_UPDATE_PARENT;
1083
1084	mi_b->dirty = true;
1085	mark_inode_dirty(inode: &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, entry_o: &le_b, type: ATTR_DATA, NULL,
1103	name_len: 0, NULL, mi: &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, clen: 1, mlen: 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, entry_o: &le, type: ATTR_DATA, NULL, name_len: 0, vcn: &svcn, mi: &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: &mi)) {
1162	attr = NULL;
1163	goto out;
1164	}
1165
1166	attr = mi_find_attr(mi, NULL, type: ATTR_DATA, NULL, name_len: 0, id: &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, vcn: &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, len: 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, type: ATTR_DATA, NULL, name_len: 0, run,
1196	svcn: next_svcn, len: evcn1 - next_svcn,
1197	flags: attr_b->flags, new_attr: &attr, mi: &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(sem: &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(inode: &ni->vfs_inode, bytes: total_size0);
1217
1218	if (run_deallocate_ex(sbi, run, vcn, len: alen, NULL, trim: false) ||
1219	!run_add_entry(run, vcn, SPARSE_LCN, len: alen, is_mft: 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, type: ATTR_DATA, NULL, name_len: 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, start: 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, type: ATTR_DATA, NULL, name_len: 0, NULL, mi: &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: &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, sbi: ni->mi.sbi, ino: ni->mi.rno, svcn, evcn, vcn: 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: &lcn, len: &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(sem: &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, type: ATTR_DATA, name: 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, pages: &page, nr_pages: 1, vbo: from,
1464	bytes: to - from, op: 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(sem: &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: &lcn, len: &clen, index: &idx)) {
1539	err = attr_load_runs_vcn(ni, type: attr->type, name: attr_name(attr),
1540	name_len: attr->name_len, run, vcn);
1541	if (err)
1542	return err;
1543
1544	if (!run_lookup_entry(run, vcn, lcn: &lcn, len: &clen, index: &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(sbi: 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, index: ++idx, vcn: &vcn, lcn: &lcn, len: &clen) ||
1574	vcn_next != vcn) {
1575	err = attr_load_runs_vcn(ni, type: attr->type,
1576	name: attr_name(attr),
1577	name_len: attr->name_len, run, vcn: vcn_next);
1578	if (err)
1579	return err;
1580	vcn = vcn_next;
1581
1582	if (!run_lookup_entry(run, vcn, lcn: &lcn, len: &clen, index: &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, entry_o: &le_b, type: ATTR_DATA, NULL, name_len: 0, NULL, mi: &mi_b);
1636	if (!attr_b)
1637	return -ENOENT;
1638
1639	if (!is_attr_ext(attr: 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: attr_b, entry_o: &le, type: ATTR_DATA, NULL, name_len: 0, vcn: &vcn,
1659	mi: &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: attr_b, frame, clst_data: &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, size: 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: vcn + len, len: clst_data - len,
1685	NULL, trim: true);
1686	if (err)
1687	goto out;
1688
1689	if (!run_add_entry(run, vcn: vcn + len, SPARSE_LCN, len: clst_data - len,
1690	is_mft: 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: vcn + clst_data - 1, lcn: &hint, NULL,
1701	NULL)) {
1702	hint = -1;
1703	}
1704
1705	err = attr_allocate_clusters(sbi, run, vcn: vcn + clst_data,
1706	lcn: hint + 1, len: len - clst_data, NULL,
1707	opt: ALLOCATE_DEF, alen: &alen, fr: 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(inode: &ni->vfs_inode, bytes: total_size);
1725
1726	mi_b->dirty = true;
1727	mark_inode_dirty(inode: &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, entry_o: &le_b, type: ATTR_DATA, NULL,
1745	name_len: 0, NULL, mi: &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, entry_o: &le, type: ATTR_DATA, NULL, name_len: 0, vcn: &svcn, mi: &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: &mi)) {
1786	attr = NULL;
1787	goto out;
1788	}
1789
1790	attr = mi_find_attr(mi, NULL, type: ATTR_DATA, NULL, name_len: 0,
1791	id: &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, vcn: &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, len: 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, type: ATTR_DATA, NULL, name_len: 0, run,
1822	svcn: next_svcn, len: evcn1 - next_svcn,
1823	flags: attr_b->flags, new_attr: &attr, mi: &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, entry_o: &le_b, type: ATTR_DATA, NULL, name_len: 0, NULL, mi: &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: 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(sem: &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(inode: &ni->vfs_inode, newsize: vbo);
1901	err = attr_set_size(ni, type: ATTR_DATA, NULL, name_len: 0, run: &ni->file.run, new_size: vbo,
1902	new_valid: &new_valid, keep_prealloc: 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: attr_b, entry_o: &le, type: ATTR_DATA, NULL, name_len: 0, vcn: &vcn,
1932	mi: &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, vcn: &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, vcn: vcn1, len: eat, done: &dealloc,
1963	trim: true);
1964	if (err)
1965	goto out;
1966
1967	if (!run_collapse_range(run, vcn: vcn1, len: 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, len: 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, type: ATTR_DATA, NULL, name_len: 0, run, svcn: next_svcn,
1989	len: evcn1 - eat - next_svcn, flags: a_flags, new_attr: &attr,
1990	mi: &mi, le: &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, vcn: 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, ino: ni->mi.rno, svcn,
2010	evcn: evcn1 - 1, vcn: 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: &mi)) {
2030	err = -EINVAL;
2031	goto out;
2032	}
2033
2034	/* Look for required attribute. */
2035	attr = mi_find_attr(mi, NULL, type: ATTR_DATA, NULL,
2036	name_len: 0, id: &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: &le, mi: &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, entry_o: &le_b, type: ATTR_DATA, NULL, name_len: 0, NULL,
2063	mi: &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: 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(inode: &ni->vfs_inode, i_size: data_size);
2088	inode_set_bytes(inode: &ni->vfs_inode, bytes: total_size);
2089	ni->ni_flags |= NI_FLAG_UPDATE_PARENT;
2090	mark_inode_dirty(inode: &ni->vfs_inode);
2091
2092	out:
2093	up_write(sem: &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, entry_o: &le_b, type: ATTR_DATA, NULL, name_len: 0, NULL, mi: &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: 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(sem: &ni->file.run_lock);
2169	run_init(run: &run2);
2170	run_truncate(run, vcn: 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: attr_b, entry_o: &le, type: ATTR_DATA, NULL, name_len: 0, vcn: &vcn,
2195	mi: &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, vcn: &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, vcn: vcn1, len: zero, done: &hole2, trim: 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, new_run: &run2);
2229	if (err)
2230	goto done;
2231
2232	/* Make a hole range (sparse) [vcn1 + zero). */
2233	if (!run_add_entry(run, vcn: vcn1, SPARSE_LCN, len: zero, is_mft: false)) {
2234	err = -ENOMEM;
2235	goto done;
2236	}
2237
2238	/* Update run in attribute segment. */
2239	err = mi_pack_runs(mi, attr, run, len: 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, type: ATTR_DATA, NULL, name_len: 0, run,
2246	svcn: next_svcn,
2247	len: evcn1 - next_svcn, flags: a_flags,
2248	new_attr: &attr, mi: &mi, le: &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, run: &run2, vcn: vcn1, len: zero, done: &hole, trim: true);
2258
2259	next_attr:
2260	/* Free all allocated memory. */
2261	run_truncate(run, vcn: 0);
2262
2263	if (evcn1 >= alen)
2264	break;
2265
2266	/* Get next attribute segment. */
2267	attr = ni_enum_attr_ex(ni, attr, le: &le, mi: &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, type: ATTR_DATA, NULL, name_len: 0, NULL,
2283	mi: &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(inode: &ni->vfs_inode, bytes: total_size);
2296	ni->ni_flags |= NI_FLAG_UPDATE_PARENT;
2297	mark_inode_dirty(inode: &ni->vfs_inode);
2298
2299	out:
2300	run_close(run: &run2);
2301	up_write(sem: &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, run: &run2, len: 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, entry_o: &le_b, type: ATTR_DATA, NULL, name_len: 0, NULL, mi: &mi_b);
2341	if (!attr_b)
2342	return -ENOENT;
2343
2344	if (!is_attr_ext(attr: 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(sem: &ni->file.run_lock);
2380
2381	if (!attr_b->non_res) {
2382	err = attr_set_size(ni, type: ATTR_DATA, NULL, name_len: 0, run,
2383	new_size: data_size + bytes, NULL, keep_prealloc: false, NULL);
2384
2385	le_b = NULL;
2386	attr_b = ni_find_attr(ni, NULL, entry_o: &le_b, type: ATTR_DATA, NULL, name_len: 0, NULL,
2387	mi: &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: attr_b, entry_o: &le, type: ATTR_DATA, NULL, name_len: 0, vcn: &vcn,
2428	mi: &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, vcn: 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, len: 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: &le, mi: &mi)) &&
2456	attr->type == ATTR_DATA && !attr->name_len) {
2457	le64_add_cpu(var: &attr->nres.svcn, val: len);
2458	le64_add_cpu(var: &attr->nres.evcn, val: 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, type: ATTR_DATA, NULL, name_len: 0, run,
2468	svcn: next_svcn, len: evcn1 + len - next_svcn,
2469	flags: a_flags, NULL, NULL, NULL);
2470
2471	le_b = NULL;
2472	attr_b = ni_find_attr(ni, NULL, entry_o: &le_b, type: ATTR_DATA, NULL, name_len: 0, NULL,
2473	mi: &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(inode: &ni->vfs_inode, i_size: ni->vfs_inode.i_size + bytes);
2503	ni->ni_flags |= NI_FLAG_UPDATE_PARENT;
2504	mark_inode_dirty(inode: &ni->vfs_inode);
2505
2506	out:
2507	run_truncate(run, vcn: 0); /* clear cached values. */
2508
2509	up_write(sem: &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: attr_b, entry_o: &le, type: ATTR_DATA, NULL, name_len: 0, vcn: &vcn,
2530	mi: &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, len: evcn1 + len - svcn))
2546	goto bad_inode;
2547
2548	while ((attr = ni_enum_attr_ex(ni, attr, le: &le, mi: &mi)) &&
2549	attr->type == ATTR_DATA && !attr->name_len) {
2550	le64_sub_cpu(var: &attr->nres.svcn, val: len);
2551	le64_sub_cpu(var: &attr->nres.evcn, val: 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