From be71b5cba2e6485e8959da7a9f9a44461a1bb074 Mon Sep 17 00:00:00 2001

From: Konstantin Komarov <almaz.alexandrovich@paragon-software.com>

Date: Fri, 13 Aug 2021 17:21:30 +0300

Subject: [Backport be71b5cba2e6] src: Add attrib operations

This adds attrib operations

Signed-off-by: Konstantin Komarov <almaz.alexandrovich@paragon-software.com>

---

 src/attrib.c   | 2096 +++++++++++++++++++++++++++++++++++++++++++

 src/attrlist.c |  456 ++++++++++

 src/xattr.c    | 1128 +++++++++++++++++++++++

 3 files changed, 3680 insertions(+)

 create mode 100644 src/attrib.c

 create mode 100644 src/attrlist.c

 create mode 100644 src/xattr.c

diff --git a/src/attrib.c b/src/attrib.c

new file mode 100644

index 0000000000000000000000000000000000000000..046dc57f75f2169b47e7078c251f26b05ec69b42

--- /dev/null

+++ b/src/attrib.c

@@ -0,0 +1,2096 @@

+// SPDX-License-Identifier: GPL-2.0

+/*

+ *

+ * Copyright (C) 2019-2021 Paragon Software GmbH, All rights reserved.

+ *

+ * TODO: merge attr_set_size/attr_data_get_block/attr_allocate_frame?

+ */

+

+#include <linux/blkdev.h>

+#include <linux/buffer_head.h>

+#include <linux/fs.h>

+#include <linux/hash.h>

+#include <linux/nls.h>

+#include <linux/ratelimit.h>

+#include <linux/slab.h>

+

+#include "debug.h"

+#include "ntfs.h"

+#include "ntfs_fs.h"

+

+/*

+ * You can set external NTFS_MIN_LOG2_OF_CLUMP/NTFS_MAX_LOG2_OF_CLUMP to manage

+ * preallocate algorithm

+ */

+#ifndef NTFS_MIN_LOG2_OF_CLUMP

+#define NTFS_MIN_LOG2_OF_CLUMP 16

+#endif

+

+#ifndef NTFS_MAX_LOG2_OF_CLUMP

+#define NTFS_MAX_LOG2_OF_CLUMP 26

+#endif

+

+// 16M

+#define NTFS_CLUMP_MIN (1 << (NTFS_MIN_LOG2_OF_CLUMP + 8))

+// 16G

+#define NTFS_CLUMP_MAX (1ull << (NTFS_MAX_LOG2_OF_CLUMP + 8))

+

+/*

+ * get_pre_allocated

+ *

+ */

+static inline u64 get_pre_allocated(u64 size)

+{

+	u32 clump;

+	u8 align_shift;

+	u64 ret;

+

+	if (size <= NTFS_CLUMP_MIN) {

+		clump = 1 << NTFS_MIN_LOG2_OF_CLUMP;

+		align_shift = NTFS_MIN_LOG2_OF_CLUMP;

+	} else if (size >= NTFS_CLUMP_MAX) {

+		clump = 1 << NTFS_MAX_LOG2_OF_CLUMP;

+		align_shift = NTFS_MAX_LOG2_OF_CLUMP;

+	} else {

+		align_shift = NTFS_MIN_LOG2_OF_CLUMP - 1 +

+			      __ffs(size >> (8 + NTFS_MIN_LOG2_OF_CLUMP));

+		clump = 1u << align_shift;

+	}

+

+	ret = (((size + clump - 1) >> align_shift)) << align_shift;

+

+	return ret;

+}

+

+/*

+ * attr_must_be_resident

+ *

+ * returns true if attribute must be resident

+ */

+static inline bool attr_must_be_resident(struct ntfs_sb_info *sbi,

+					 enum ATTR_TYPE type)

+{

+	const struct ATTR_DEF_ENTRY *de;

+

+	switch (type) {

+	case ATTR_STD:

+	case ATTR_NAME:

+	case ATTR_ID:

+	case ATTR_LABEL:

+	case ATTR_VOL_INFO:

+	case ATTR_ROOT:

+	case ATTR_EA_INFO:

+		return true;

+	default:

+		de = ntfs_query_def(sbi, type);

+		if (de && (de->flags & NTFS_ATTR_MUST_BE_RESIDENT))

+			return true;

+		return false;

+	}

+}

+

+/*

+ * attr_load_runs

+ *

+ * load all runs stored in 'attr'

+ */

+int attr_load_runs(struct ATTRIB *attr, struct ntfs_inode *ni,

+		   struct runs_tree *run, const CLST *vcn)

+{

+	int err;

+	CLST svcn = le64_to_cpu(attr->nres.svcn);

+	CLST evcn = le64_to_cpu(attr->nres.evcn);

+	u32 asize;

+	u16 run_off;

+

+	if (svcn >= evcn + 1 || run_is_mapped_full(run, svcn, evcn))

+		return 0;

+

+	if (vcn && (evcn < *vcn || *vcn < svcn))

+		return -EINVAL;

+

+	asize = le32_to_cpu(attr->size);

+	run_off = le16_to_cpu(attr->nres.run_off);

+	err = run_unpack_ex(run, ni->mi.sbi, ni->mi.rno, svcn, evcn,

+			    vcn ? *vcn : svcn, Add2Ptr(attr, run_off),

+			    asize - run_off);

+	if (err < 0)

+		return err;

+

+	return 0;

+}

+

+/*

+ * int run_deallocate_ex

+ *

+ * Deallocate clusters

+ */

+static int run_deallocate_ex(struct ntfs_sb_info *sbi, struct runs_tree *run,

+			     CLST vcn, CLST len, CLST *done, bool trim)

+{

+	int err = 0;

+	CLST vcn_next, vcn0 = vcn, lcn, clen, dn = 0;

+	size_t idx;

+

+	if (!len)

+		goto out;

+

+	if (!run_lookup_entry(run, vcn, &lcn, &clen, &idx)) {

+failed:

+		run_truncate(run, vcn0);

+		err = -EINVAL;

+		goto out;

+	}

+

+	for (;;) {

+		if (clen > len)

+			clen = len;

+

+		if (!clen) {

+			err = -EINVAL;

+			goto out;

+		}

+

+		if (lcn != SPARSE_LCN) {

+			mark_as_free_ex(sbi, lcn, clen, trim);

+			dn += clen;

+		}

+

+		len -= clen;

+		if (!len)

+			break;

+

+		vcn_next = vcn + clen;

+		if (!run_get_entry(run, ++idx, &vcn, &lcn, &clen) ||

+		    vcn != vcn_next) {

+			// save memory - don't load entire run

+			goto failed;

+		}

+	}

+

+out:

+	if (done)

+		*done += dn;

+

+	return err;

+}

+

+/*

+ * attr_allocate_clusters

+ *

+ * find free space, mark it as used and store in 'run'

+ */

+int attr_allocate_clusters(struct ntfs_sb_info *sbi, struct runs_tree *run,

+			   CLST vcn, CLST lcn, CLST len, CLST *pre_alloc,

+			   enum ALLOCATE_OPT opt, CLST *alen, const size_t fr,

+			   CLST *new_lcn)

+{

+	int err;

+	CLST flen, vcn0 = vcn, pre = pre_alloc ? *pre_alloc : 0;

+	struct wnd_bitmap *wnd = &sbi->used.bitmap;

+	size_t cnt = run->count;

+

+	for (;;) {

+		err = ntfs_look_for_free_space(sbi, lcn, len + pre, &lcn, &flen,

+					       opt);

+

+		if (err == -ENOSPC && pre) {

+			pre = 0;

+			if (*pre_alloc)

+				*pre_alloc = 0;

+			continue;

+		}

+

+		if (err)

+			goto out;

+

+		if (new_lcn && vcn == vcn0)

+			*new_lcn = lcn;

+

+		/* Add new fragment into run storage */

+		if (!run_add_entry(run, vcn, lcn, flen, opt == ALLOCATE_MFT)) {

+			down_write_nested(&wnd->rw_lock, BITMAP_MUTEX_CLUSTERS);

+			wnd_set_free(wnd, lcn, flen);

+			up_write(&wnd->rw_lock);

+			err = -ENOMEM;

+			goto out;

+		}

+

+		vcn += flen;

+

+		if (flen >= len || opt == ALLOCATE_MFT ||

+		    (fr && run->count - cnt >= fr)) {

+			*alen = vcn - vcn0;

+			return 0;

+		}

+

+		len -= flen;

+	}

+

+out:

+	/* undo */

+	run_deallocate_ex(sbi, run, vcn0, vcn - vcn0, NULL, false);

+	run_truncate(run, vcn0);

+

+	return err;

+}

+

+/*

+ * if page is not NULL - it is already contains resident data

+ * and locked (called from ni_write_frame)

+ */

+int attr_make_nonresident(struct ntfs_inode *ni, struct ATTRIB *attr,

+			  struct ATTR_LIST_ENTRY *le, struct mft_inode *mi,

+			  u64 new_size, struct runs_tree *run,

+			  struct ATTRIB **ins_attr, struct page *page)

+{

+	struct ntfs_sb_info *sbi;

+	struct ATTRIB *attr_s;

+	struct MFT_REC *rec;

+	u32 used, asize, rsize, aoff, align;

+	bool is_data;

+	CLST len, alen;

+	char *next;

+	int err;

+

+	if (attr->non_res) {

+		*ins_attr = attr;

+		return 0;

+	}

+

+	sbi = mi->sbi;

+	rec = mi->mrec;

+	attr_s = NULL;

+	used = le32_to_cpu(rec->used);

+	asize = le32_to_cpu(attr->size);

+	next = Add2Ptr(attr, asize);

+	aoff = PtrOffset(rec, attr);

+	rsize = le32_to_cpu(attr->res.data_size);

+	is_data = attr->type == ATTR_DATA && !attr->name_len;

+

+	align = sbi->cluster_size;

+	if (is_attr_compressed(attr))

+		align <<= COMPRESSION_UNIT;

+	len = (rsize + align - 1) >> sbi->cluster_bits;

+

+	run_init(run);

+

+	/* make a copy of original attribute */

+	attr_s = ntfs_memdup(attr, asize);

+	if (!attr_s) {

+		err = -ENOMEM;

+		goto out;

+	}

+

+	if (!len) {

+		/* empty resident -> empty nonresident */

+		alen = 0;

+	} else {

+		const char *data = resident_data(attr);

+

+		err = attr_allocate_clusters(sbi, run, 0, 0, len, NULL,

+					     ALLOCATE_DEF, &alen, 0, NULL);

+		if (err)

+			goto out1;

+

+		if (!rsize) {

+			/* empty resident -> non empty nonresident */

+		} else if (!is_data) {

+			err = ntfs_sb_write_run(sbi, run, 0, data, rsize);

+			if (err)

+				goto out2;

+		} else if (!page) {

+			char *kaddr;

+

+			page = grab_cache_page(ni->vfs_inode.i_mapping, 0);

+			if (!page) {

+				err = -ENOMEM;

+				goto out2;

+			}

+			kaddr = kmap_atomic(page);

+			memcpy(kaddr, data, rsize);

+			memset(kaddr + rsize, 0, PAGE_SIZE - rsize);

+			kunmap_atomic(kaddr);

+			flush_dcache_page(page);

+			SetPageUptodate(page);

+			set_page_dirty(page);

+			unlock_page(page);

+			put_page(page);

+		}

+	}

+

+	/* remove original attribute */

+	used -= asize;

+	memmove(attr, Add2Ptr(attr, asize), used - aoff);

+	rec->used = cpu_to_le32(used);

+	mi->dirty = true;

+	if (le)

+		al_remove_le(ni, le);

+

+	err = ni_insert_nonresident(ni, attr_s->type, attr_name(attr_s),

+				    attr_s->name_len, run, 0, alen,

+				    attr_s->flags, &attr, NULL);

+	if (err)

+		goto out3;

+

+	ntfs_free(attr_s);

+	attr->nres.data_size = cpu_to_le64(rsize);

+	attr->nres.valid_size = attr->nres.data_size;

+

+	*ins_attr = attr;

+

+	if (is_data)

+		ni->ni_flags &= ~NI_FLAG_RESIDENT;

+

+	/* Resident attribute becomes non resident */

+	return 0;

+

+out3:

+	attr = Add2Ptr(rec, aoff);

+	memmove(next, attr, used - aoff);

+	memcpy(attr, attr_s, asize);

+	rec->used = cpu_to_le32(used + asize);

+	mi->dirty = true;

+out2:

+	/* undo: do not trim new allocated clusters */

+	run_deallocate(sbi, run, false);

+	run_close(run);

+out1:

+	ntfs_free(attr_s);

+	/*reinsert le*/

+out:

+	return err;

+}

+

+/*

+ * attr_set_size_res

+ *

+ * helper for attr_set_size

+ */

+static int attr_set_size_res(struct ntfs_inode *ni, struct ATTRIB *attr,

+			     struct ATTR_LIST_ENTRY *le, struct mft_inode *mi,

+			     u64 new_size, struct runs_tree *run,

+			     struct ATTRIB **ins_attr)

+{

+	struct ntfs_sb_info *sbi = mi->sbi;

+	struct MFT_REC *rec = mi->mrec;

+	u32 used = le32_to_cpu(rec->used);

+	u32 asize = le32_to_cpu(attr->size);

+	u32 aoff = PtrOffset(rec, attr);

+	u32 rsize = le32_to_cpu(attr->res.data_size);

+	u32 tail = used - aoff - asize;

+	char *next = Add2Ptr(attr, asize);

+	s64 dsize = QuadAlign(new_size) - QuadAlign(rsize);

+

+	if (dsize < 0) {

+		memmove(next + dsize, next, tail);

+	} else if (dsize > 0) {

+		if (used + dsize > sbi->max_bytes_per_attr)

+			return attr_make_nonresident(ni, attr, le, mi, new_size,

+						     run, ins_attr, NULL);

+

+		memmove(next + dsize, next, tail);

+		memset(next, 0, dsize);

+	}

+

+	if (new_size > rsize)

+		memset(Add2Ptr(resident_data(attr), rsize), 0,

+		       new_size - rsize);

+

+	rec->used = cpu_to_le32(used + dsize);

+	attr->size = cpu_to_le32(asize + dsize);

+	attr->res.data_size = cpu_to_le32(new_size);

+	mi->dirty = true;

+	*ins_attr = attr;

+

+	return 0;

+}

+

+/*

+ * attr_set_size

+ *

+ * change the size of attribute

+ * Extend:

+ *   - sparse/compressed: no allocated clusters

+ *   - normal: append allocated and preallocated new clusters

+ * Shrink:

+ *   - no deallocate if keep_prealloc is set

+ */

+int attr_set_size(struct ntfs_inode *ni, enum ATTR_TYPE type,

+		  const __le16 *name, u8 name_len, struct runs_tree *run,

+		  u64 new_size, const u64 *new_valid, bool keep_prealloc,

+		  struct ATTRIB **ret)

+{

+	int err = 0;

+	struct ntfs_sb_info *sbi = ni->mi.sbi;

+	u8 cluster_bits = sbi->cluster_bits;

+	bool is_mft =

+		ni->mi.rno == MFT_REC_MFT && type == ATTR_DATA && !name_len;

+	u64 old_valid, old_size, old_alloc, new_alloc, new_alloc_tmp;

+	struct ATTRIB *attr = NULL, *attr_b;

+	struct ATTR_LIST_ENTRY *le, *le_b;

+	struct mft_inode *mi, *mi_b;

+	CLST alen, vcn, lcn, new_alen, old_alen, svcn, evcn;

+	CLST next_svcn, pre_alloc = -1, done = 0;

+	bool is_ext;

+	u32 align;

+	struct MFT_REC *rec;

+

+again:

+	le_b = NULL;

+	attr_b = ni_find_attr(ni, NULL, &le_b, type, name, name_len, NULL,

+			      &mi_b);

+	if (!attr_b) {

+		err = -ENOENT;

+		goto out;

+	}

+

+	if (!attr_b->non_res) {

+		err = attr_set_size_res(ni, attr_b, le_b, mi_b, new_size, run,

+					&attr_b);

+		if (err || !attr_b->non_res)

+			goto out;

+

+		/* layout of records may be changed, so do a full search */

+		goto again;

+	}

+

+	is_ext = is_attr_ext(attr_b);

+

+again_1:

+	align = sbi->cluster_size;

+

+	if (is_ext) {

+		align <<= attr_b->nres.c_unit;

+		if (is_attr_sparsed(attr_b))

+			keep_prealloc = false;

+	}

+

+	old_valid = le64_to_cpu(attr_b->nres.valid_size);

+	old_size = le64_to_cpu(attr_b->nres.data_size);

+	old_alloc = le64_to_cpu(attr_b->nres.alloc_size);

+	old_alen = old_alloc >> cluster_bits;

+

+	new_alloc = (new_size + align - 1) & ~(u64)(align - 1);

+	new_alen = new_alloc >> cluster_bits;

+

+	if (keep_prealloc && is_ext)

+		keep_prealloc = false;

+

+	if (keep_prealloc && new_size < old_size) {

+		attr_b->nres.data_size = cpu_to_le64(new_size);

+		mi_b->dirty = true;

+		goto ok;

+	}

+

+	vcn = old_alen - 1;

+

+	svcn = le64_to_cpu(attr_b->nres.svcn);

+	evcn = le64_to_cpu(attr_b->nres.evcn);

+

+	if (svcn <= vcn && vcn <= evcn) {

+		attr = attr_b;

+		le = le_b;

+		mi = mi_b;

+	} else if (!le_b) {

+		err = -EINVAL;

+		goto out;

+	} else {

+		le = le_b;

+		attr = ni_find_attr(ni, attr_b, &le, type, name, name_len, &vcn,

+				    &mi);

+		if (!attr) {

+			err = -EINVAL;

+			goto out;

+		}

+

+next_le_1:

+		svcn = le64_to_cpu(attr->nres.svcn);

+		evcn = le64_to_cpu(attr->nres.evcn);

+	}

+

+next_le:

+	rec = mi->mrec;

+

+	err = attr_load_runs(attr, ni, run, NULL);

+	if (err)

+		goto out;

+

+	if (new_size > old_size) {

+		CLST to_allocate;

+		size_t free;

+

+		if (new_alloc <= old_alloc) {

+			attr_b->nres.data_size = cpu_to_le64(new_size);

+			mi_b->dirty = true;

+			goto ok;

+		}

+

+		to_allocate = new_alen - old_alen;

+add_alloc_in_same_attr_seg:

+		lcn = 0;

+		if (is_mft) {

+			/* mft allocates clusters from mftzone */

+			pre_alloc = 0;

+		} else if (is_ext) {

+			/* no preallocate for sparse/compress */

+			pre_alloc = 0;

+		} else if (pre_alloc == -1) {

+			pre_alloc = 0;

+			if (type == ATTR_DATA && !name_len &&

+			    sbi->options.prealloc) {

+				CLST new_alen2 = bytes_to_cluster(

+					sbi, get_pre_allocated(new_size));

+				pre_alloc = new_alen2 - new_alen;

+			}

+

+			/* Get the last lcn to allocate from */

+			if (old_alen &&

+			    !run_lookup_entry(run, vcn, &lcn, NULL, NULL)) {

+				lcn = SPARSE_LCN;

+			}

+

+			if (lcn == SPARSE_LCN)

+				lcn = 0;

+			else if (lcn)

+				lcn += 1;

+

+			free = wnd_zeroes(&sbi->used.bitmap);

+			if (to_allocate > free) {

+				err = -ENOSPC;

+				goto out;

+			}

+

+			if (pre_alloc && to_allocate + pre_alloc > free)

+				pre_alloc = 0;

+		}

+

+		vcn = old_alen;

+

+		if (is_ext) {

+			if (!run_add_entry(run, vcn, SPARSE_LCN, to_allocate,

+					   false)) {

+				err = -ENOMEM;

+				goto out;

+			}

+			alen = to_allocate;

+		} else {

+			/* ~3 bytes per fragment */

+			err = attr_allocate_clusters(

+				sbi, run, vcn, lcn, to_allocate, &pre_alloc,

+				is_mft ? ALLOCATE_MFT : 0, &alen,

+				is_mft ? 0

+				       : (sbi->record_size -

+					  le32_to_cpu(rec->used) + 8) /

+							 3 +

+						 1,

+				NULL);

+			if (err)

+				goto out;

+		}

+

+		done += alen;

+		vcn += alen;

+		if (to_allocate > alen)

+			to_allocate -= alen;

+		else

+			to_allocate = 0;

+

+pack_runs:

+		err = mi_pack_runs(mi, attr, run, vcn - svcn);

+		if (err)

+			goto out;

+

+		next_svcn = le64_to_cpu(attr->nres.evcn) + 1;

+		new_alloc_tmp = (u64)next_svcn << cluster_bits;

+		attr_b->nres.alloc_size = cpu_to_le64(new_alloc_tmp);

+		mi_b->dirty = true;

+

+		if (next_svcn >= vcn && !to_allocate) {

+			/* Normal way. update attribute and exit */

+			attr_b->nres.data_size = cpu_to_le64(new_size);

+			goto ok;

+		}

+

+		/* at least two mft to avoid recursive loop*/

+		if (is_mft && next_svcn == vcn &&

+		    ((u64)done << sbi->cluster_bits) >= 2 * sbi->record_size) {

+			new_size = new_alloc_tmp;

+			attr_b->nres.data_size = attr_b->nres.alloc_size;

+			goto ok;

+		}

+

+		if (le32_to_cpu(rec->used) < sbi->record_size) {

+			old_alen = next_svcn;

+			evcn = old_alen - 1;

+			goto add_alloc_in_same_attr_seg;

+		}

+

+		attr_b->nres.data_size = attr_b->nres.alloc_size;

+		if (new_alloc_tmp < old_valid)

+			attr_b->nres.valid_size = attr_b->nres.data_size;

+

+		if (type == ATTR_LIST) {

+			err = ni_expand_list(ni);

+			if (err)

+				goto out;

+			if (next_svcn < vcn)

+				goto pack_runs;

+

+			/* layout of records is changed */

+			goto again;

+		}

+

+		if (!ni->attr_list.size) {

+			err = ni_create_attr_list(ni);

+			if (err)

+				goto out;

+			/* layout of records is changed */

+		}

+

+		if (next_svcn >= vcn) {

+			/* this is mft data, repeat */

+			goto again;

+		}

+

+		/* insert new attribute segment */

+		err = ni_insert_nonresident(ni, type, name, name_len, run,

+					    next_svcn, vcn - next_svcn,

+					    attr_b->flags, &attr, &mi);

+		if (err)

+			goto out;

+

+		if (!is_mft)

+			run_truncate_head(run, evcn + 1);

+

+		svcn = le64_to_cpu(attr->nres.svcn);

+		evcn = le64_to_cpu(attr->nres.evcn);

+

+		le_b = NULL;

+		/* layout of records maybe changed */

+		/* find base attribute to update*/

+		attr_b = ni_find_attr(ni, NULL, &le_b, type, name, name_len,

+				      NULL, &mi_b);

+		if (!attr_b) {

+			err = -ENOENT;

+			goto out;

+		}

+

+		attr_b->nres.alloc_size = cpu_to_le64((u64)vcn << cluster_bits);

+		attr_b->nres.data_size = attr_b->nres.alloc_size;

+		attr_b->nres.valid_size = attr_b->nres.alloc_size;

+		mi_b->dirty = true;

+		goto again_1;

+	}

+

+	if (new_size != old_size ||

+	    (new_alloc != old_alloc && !keep_prealloc)) {

+		vcn = max(svcn, new_alen);

+		new_alloc_tmp = (u64)vcn << cluster_bits;

+

+		alen = 0;

+		err = run_deallocate_ex(sbi, run, vcn, evcn - vcn + 1, &alen,

+					true);

+		if (err)

+			goto out;

+

+		run_truncate(run, vcn);

+

+		if (vcn > svcn) {

+			err = mi_pack_runs(mi, attr, run, vcn - svcn);

+			if (err)

+				goto out;

+		} else if (le && le->vcn) {

+			u16 le_sz = le16_to_cpu(le->size);

+

+			/*

+			 * NOTE: list entries for one attribute are always

+			 * the same size. We deal with last entry (vcn==0)

+			 * and it is not first in entries array

+			 * (list entry for std attribute always first)

+			 * So it is safe to step back

+			 */

+			mi_remove_attr(mi, attr);

+

+			if (!al_remove_le(ni, le)) {

+				err = -EINVAL;

+				goto out;

+			}

+

+			le = (struct ATTR_LIST_ENTRY *)((u8 *)le - le_sz);

+		} else {

+			attr->nres.evcn = cpu_to_le64((u64)vcn - 1);

+			mi->dirty = true;

+		}

+

+		attr_b->nres.alloc_size = cpu_to_le64(new_alloc_tmp);

+

+		if (vcn == new_alen) {

+			attr_b->nres.data_size = cpu_to_le64(new_size);

+			if (new_size < old_valid)

+				attr_b->nres.valid_size =

+					attr_b->nres.data_size;

+		} else {

+			if (new_alloc_tmp <=

+			    le64_to_cpu(attr_b->nres.data_size))

+				attr_b->nres.data_size =

+					attr_b->nres.alloc_size;

+			if (new_alloc_tmp <

+			    le64_to_cpu(attr_b->nres.valid_size))

+				attr_b->nres.valid_size =

+					attr_b->nres.alloc_size;

+		}

+

+		if (is_ext)

+			le64_sub_cpu(&attr_b->nres.total_size,

+				     ((u64)alen << cluster_bits));

+

+		mi_b->dirty = true;

+

+		if (new_alloc_tmp <= new_alloc)

+			goto ok;

+

+		old_size = new_alloc_tmp;

+		vcn = svcn - 1;

+

+		if (le == le_b) {

+			attr = attr_b;

+			mi = mi_b;

+			evcn = svcn - 1;

+			svcn = 0;

+			goto next_le;

+		}

+

+		if (le->type != type || le->name_len != name_len ||

+		    memcmp(le_name(le), name, name_len * sizeof(short))) {

+			err = -EINVAL;

+			goto out;

+		}

+

+		err = ni_load_mi(ni, le, &mi);

+		if (err)

+			goto out;

+

+		attr = mi_find_attr(mi, NULL, type, name, name_len, &le->id);

+		if (!attr) {

+			err = -EINVAL;

+			goto out;

+		}

+		goto next_le_1;

+	}

+

+ok:

+	if (new_valid) {

+		__le64 valid = cpu_to_le64(min(*new_valid, new_size));

+

+		if (attr_b->nres.valid_size != valid) {

+			attr_b->nres.valid_size = valid;

+			mi_b->dirty = true;

+		}

+	}

+

+out:

+	if (!err && attr_b && ret)

+		*ret = attr_b;

+

+	/* update inode_set_bytes*/

+	if (!err && ((type == ATTR_DATA && !name_len) ||

+		     (type == ATTR_ALLOC && name == I30_NAME))) {

+		bool dirty = false;

+

+		if (ni->vfs_inode.i_size != new_size) {

+			ni->vfs_inode.i_size = new_size;

+			dirty = true;

+		}

+

+		if (attr_b && attr_b->non_res) {

+			new_alloc = le64_to_cpu(attr_b->nres.alloc_size);

+			if (inode_get_bytes(&ni->vfs_inode) != new_alloc) {

+				inode_set_bytes(&ni->vfs_inode, new_alloc);

+				dirty = true;

+			}

+		}

+

+		if (dirty) {

+			ni->ni_flags |= NI_FLAG_UPDATE_PARENT;

+			mark_inode_dirty(&ni->vfs_inode);

+		}

+	}

+

+	return err;

+}

+

+int attr_data_get_block(struct ntfs_inode *ni, CLST vcn, CLST clen, CLST *lcn,

+			CLST *len, bool *new)

+{

+	int err = 0;

+	struct runs_tree *run = &ni->file.run;

+	struct ntfs_sb_info *sbi;

+	u8 cluster_bits;

+	struct ATTRIB *attr = NULL, *attr_b;

+	struct ATTR_LIST_ENTRY *le, *le_b;

+	struct mft_inode *mi, *mi_b;

+	CLST hint, svcn, to_alloc, evcn1, next_svcn, asize, end;

+	u64 total_size;

+	u32 clst_per_frame;

+	bool ok;

+

+	if (new)

+		*new = false;

+

+	down_read(&ni->file.run_lock);

+	ok = run_lookup_entry(run, vcn, lcn, len, NULL);

+	up_read(&ni->file.run_lock);

+

+	if (ok && (*lcn != SPARSE_LCN || !new)) {

+		/* normal way */

+		return 0;

+	}

+

+	if (!clen)

+		clen = 1;

+

+	if (ok && clen > *len)

+		clen = *len;

+

+	sbi = ni->mi.sbi;

+	cluster_bits = sbi->cluster_bits;