[linux-block.git] / fs / ntfs3 / attrlist.c

// SPDX-License-Identifier: GPL-2.0
/*
 *
 * Copyright (C) 2019-2021 Paragon Software GmbH, All rights reserved.
 *
 */

#include <linux/fs.h>

#include "debug.h"
#include "ntfs.h"
#include "ntfs_fs.h"

/*
 * al_is_valid_le
 *
 * Return: True if @le is valid.
 */
static inline bool al_is_valid_le(const struct ntfs_inode *ni,
				  struct ATTR_LIST_ENTRY *le)
{
	if (!le || !ni->attr_list.le || !ni->attr_list.size)
		return false;

	return PtrOffset(ni->attr_list.le, le) + le16_to_cpu(le->size) <=
	       ni->attr_list.size;
}

void al_destroy(struct ntfs_inode *ni)
{
	run_close(&ni->attr_list.run);
	kfree(ni->attr_list.le);
	ni->attr_list.le = NULL;
	ni->attr_list.size = 0;
	ni->attr_list.dirty = false;
}

/*
 * ntfs_load_attr_list
 *
 * This method makes sure that the ATTRIB list, if present,
 * has been properly set up.
 */
int ntfs_load_attr_list(struct ntfs_inode *ni, struct ATTRIB *attr)
{
	int err;
	size_t lsize;
	void *le = NULL;

	if (ni->attr_list.size)
		return 0;

	if (!attr->non_res) {
		lsize = le32_to_cpu(attr->res.data_size);
		le = kmalloc(al_aligned(lsize), GFP_NOFS);
		if (!le) {
			err = -ENOMEM;
			goto out;
		}
		memcpy(le, resident_data(attr), lsize);
	} else if (attr->nres.svcn) {
		err = -EINVAL;
		goto out;
	} else {
		u16 run_off = le16_to_cpu(attr->nres.run_off);

		lsize = le64_to_cpu(attr->nres.data_size);

		run_init(&ni->attr_list.run);

		err = run_unpack_ex(&ni->attr_list.run, ni->mi.sbi, ni->mi.rno,
				    0, le64_to_cpu(attr->nres.evcn), 0,
				    Add2Ptr(attr, run_off),
				    le32_to_cpu(attr->size) - run_off);
		if (err < 0)
			goto out;

		le = kmalloc(al_aligned(lsize), GFP_NOFS);
		if (!le) {
			err = -ENOMEM;
			goto out;
		}

		err = ntfs_read_run_nb(ni->mi.sbi, &ni->attr_list.run, 0, le,
				       lsize, NULL);
		if (err)
			goto out;
	}

	ni->attr_list.size = lsize;
	ni->attr_list.le = le;

	return 0;

out:
	ni->attr_list.le = le;
	al_destroy(ni);

	return err;
}

/*
 * al_enumerate
 *
 * Return:
 * * The next list le.
 * * If @le is NULL then return the first le.
 */
struct ATTR_LIST_ENTRY *al_enumerate(struct ntfs_inode *ni,
				     struct ATTR_LIST_ENTRY *le)
{
	size_t off;
	u16 sz;

	if (!le) {
		le = ni->attr_list.le;
	} else {
		sz = le16_to_cpu(le->size);
		if (sz < sizeof(struct ATTR_LIST_ENTRY)) {
			/* Impossible 'cause we should not return such le. */
			return NULL;
		}
		le = Add2Ptr(le, sz);
	}

	/* Check boundary. */
	off = PtrOffset(ni->attr_list.le, le);
	if (off + sizeof(struct ATTR_LIST_ENTRY) > ni->attr_list.size) {
		/* The regular end of list. */
		return NULL;
	}

	sz = le16_to_cpu(le->size);

	/* Check le for errors. */
	if (sz < sizeof(struct ATTR_LIST_ENTRY) ||
	    off + sz > ni->attr_list.size ||
	    sz < le->name_off + le->name_len * sizeof(short)) {
		return NULL;
	}

	return le;
}

/*
 * al_find_le
 *
 * Find the first le in the list which matches type, name and VCN.
 *
 * Return: NULL if not found.
 */
struct ATTR_LIST_ENTRY *al_find_le(struct ntfs_inode *ni,
				   struct ATTR_LIST_ENTRY *le,
				   const struct ATTRIB *attr)
{
	CLST svcn = attr_svcn(attr);

	return al_find_ex(ni, le, attr->type, attr_name(attr), attr->name_len,
			  &svcn);
}

/*
 * al_find_ex
 *
 * Find the first le in the list which matches type, name and VCN.
 *
 * Return: NULL if not found.
 */
struct ATTR_LIST_ENTRY *al_find_ex(struct ntfs_inode *ni,
				   struct ATTR_LIST_ENTRY *le,
				   enum ATTR_TYPE type, const __le16 *name,
				   u8 name_len, const CLST *vcn)
{
	struct ATTR_LIST_ENTRY *ret = NULL;
	u32 type_in = le32_to_cpu(type);

	while ((le = al_enumerate(ni, le))) {
		u64 le_vcn;
		int diff = le32_to_cpu(le->type) - type_in;

		/* List entries are sorted by type, name and VCN. */
		if (diff < 0)
			continue;

		if (diff > 0)
			return ret;

		if (le->name_len != name_len)
			continue;

		le_vcn = le64_to_cpu(le->vcn);
		if (!le_vcn) {
			/*
			 * Compare entry names only for entry with vcn == 0.
			 */
			diff = ntfs_cmp_names(le_name(le), name_len, name,
					      name_len, ni->mi.sbi->upcase,
					      true);
			if (diff < 0)
				continue;

			if (diff > 0)
				return ret;
		}

		if (!vcn)
			return le;

		if (*vcn == le_vcn)
			return le;

		if (*vcn < le_vcn)
			return ret;

		ret = le;
	}

	return ret;
}

/*
 * al_find_le_to_insert
 *
 * Find the first list entry which matches type, name and VCN.
 */
static struct ATTR_LIST_ENTRY *al_find_le_to_insert(struct ntfs_inode *ni,
						    enum ATTR_TYPE type,
						    const __le16 *name,
						    u8 name_len, CLST vcn)
{
	struct ATTR_LIST_ENTRY *le = NULL, *prev;
	u32 type_in = le32_to_cpu(type);

	/* List entries are sorted by type, name and VCN. */
	while ((le = al_enumerate(ni, prev = le))) {
		int diff = le32_to_cpu(le->type) - type_in;

		if (diff < 0)
			continue;

		if (diff > 0)
			return le;

		if (!le->vcn) {
			/*
			 * Compare entry names only for entry with vcn == 0.
			 */
			diff = ntfs_cmp_names(le_name(le), le->name_len, name,
					      name_len, ni->mi.sbi->upcase,
					      true);
			if (diff < 0)
				continue;

			if (diff > 0)
				return le;
		}

		if (le64_to_cpu(le->vcn) >= vcn)
			return le;
	}

	return prev ? Add2Ptr(prev, le16_to_cpu(prev->size)) : ni->attr_list.le;
}

/*
 * al_add_le
 *
 * Add an "attribute list entry" to the list.
 */
int al_add_le(struct ntfs_inode *ni, enum ATTR_TYPE type, const __le16 *name,
	      u8 name_len, CLST svcn, __le16 id, const struct MFT_REF *ref,
	      struct ATTR_LIST_ENTRY **new_le)
{
	int err;
	struct ATTRIB *attr;
	struct ATTR_LIST_ENTRY *le;
	size_t off;
	u16 sz;
	size_t asize, new_asize, old_size;
	u64 new_size;
	typeof(ni->attr_list) *al = &ni->attr_list;

	/*
	 * Compute the size of the new 'le'
	 */
	sz = le_size(name_len);
	old_size = al->size;
	new_size = old_size + sz;
	asize = al_aligned(old_size);
	new_asize = al_aligned(new_size);

	/* Scan forward to the point at which the new 'le' should be inserted. */
	le = al_find_le_to_insert(ni, type, name, name_len, svcn);
	off = PtrOffset(al->le, le);

	if (new_size > asize) {
		void *ptr = kmalloc(new_asize, GFP_NOFS);

		if (!ptr)
			return -ENOMEM;

		memcpy(ptr, al->le, off);
		memcpy(Add2Ptr(ptr, off + sz), le, old_size - off);
		le = Add2Ptr(ptr, off);
		kfree(al->le);
		al->le = ptr;
	} else {
		memmove(Add2Ptr(le, sz), le, old_size - off);
	}
	*new_le = le;

	al->size = new_size;

	le->type = type;
	le->size = cpu_to_le16(sz);
	le->name_len = name_len;
	le->name_off = offsetof(struct ATTR_LIST_ENTRY, name);
	le->vcn = cpu_to_le64(svcn);
	le->ref = *ref;
	le->id = id;
	memcpy(le->name, name, sizeof(short) * name_len);

	err = attr_set_size(ni, ATTR_LIST, NULL, 0, &al->run, new_size,
			    &new_size, true, &attr);
	if (err) {
		/* Undo memmove above. */
		memmove(le, Add2Ptr(le, sz), old_size - off);
		al->size = old_size;
		return err;
	}

	al->dirty = true;

	if (attr && attr->non_res) {
		err = ntfs_sb_write_run(ni->mi.sbi, &al->run, 0, al->le,
					al->size, 0);
		if (err)
			return err;
		al->dirty = false;
	}

	return 0;
}

/*
 * al_remove_le - Remove @le from attribute list.
 */
bool al_remove_le(struct ntfs_inode *ni, struct ATTR_LIST_ENTRY *le)
{
	u16 size;
	size_t off;
	typeof(ni->attr_list) *al = &ni->attr_list;

	if (!al_is_valid_le(ni, le))
		return false;

	/* Save on stack the size of 'le' */
	size = le16_to_cpu(le->size);
	off = PtrOffset(al->le, le);

	memmove(le, Add2Ptr(le, size), al->size - (off + size));

	al->size -= size;
	al->dirty = true;

	return true;
}

/*
 * al_delete_le - Delete first le from the list which matches its parameters.
 */
bool al_delete_le(struct ntfs_inode *ni, enum ATTR_TYPE type, CLST vcn,
		  const __le16 *name, size_t name_len,
		  const struct MFT_REF *ref)
{
	u16 size;
	struct ATTR_LIST_ENTRY *le;
	size_t off;
	typeof(ni->attr_list) *al = &ni->attr_list;

	/* Scan forward to the first le that matches the input. */
	le = al_find_ex(ni, NULL, type, name, name_len, &vcn);
	if (!le)
		return false;

	off = PtrOffset(al->le, le);

next:
	if (off >= al->size)
		return false;
	if (le->type != type)
		return false;
	if (le->name_len != name_len)
		return false;
	if (name_len && ntfs_cmp_names(le_name(le), name_len, name, name_len,
				       ni->mi.sbi->upcase, true))
		return false;
	if (le64_to_cpu(le->vcn) != vcn)
		return false;

	/*
	 * The caller specified a segment reference, so we have to
	 * scan through the matching entries until we find that segment
	 * reference or we run of matching entries.
	 */
	if (ref && memcmp(ref, &le->ref, sizeof(*ref))) {
		off += le16_to_cpu(le->size);
		le = Add2Ptr(al->le, off);
		goto next;
	}

	/* Save on stack the size of 'le'. */
	size = le16_to_cpu(le->size);
	/* Delete the le. */
	memmove(le, Add2Ptr(le, size), al->size - (off + size));

	al->size -= size;
	al->dirty = true;

	return true;
}

int al_update(struct ntfs_inode *ni, int sync)
{
	int err;
	struct ATTRIB *attr;
	typeof(ni->attr_list) *al = &ni->attr_list;

	if (!al->dirty || !al->size)
		return 0;

	/*
	 * Attribute list increased on demand in al_add_le.
	 * Attribute list decreased here.
	 */
	err = attr_set_size(ni, ATTR_LIST, NULL, 0, &al->run, al->size, NULL,
			    false, &attr);
	if (err)
		goto out;

	if (!attr->non_res) {
		memcpy(resident_data(attr), al->le, al->size);
	} else {
		err = ntfs_sb_write_run(ni->mi.sbi, &al->run, 0, al->le,
					al->size, sync);
		if (err)
			goto out;

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

	ni->mi.dirty = true;
	al->dirty = false;

out:
	return err;
}
Commit	Line	Data
be71b5cb KK	1	// SPDX-License-Identifier: GPL-2.0
	2	/*
	3	*
	4	* Copyright (C) 2019-2021 Paragon Software GmbH, All rights reserved.
	5	*
	6	*/
	7
be71b5cb	8	#include <linux/fs.h>
be71b5cb KK	9
	10	#include "debug.h"
	11	#include "ntfs.h"
	12	#include "ntfs_fs.h"
	13
e8b8e97f KA	14	/*
	15	* al_is_valid_le
	16	*
	17	* Return: True if @le is valid.
	18	*/
be71b5cb KK	19	static inline bool al_is_valid_le(const struct ntfs_inode *ni,
	20	struct ATTR_LIST_ENTRY *le)
	21	{
	22	if (!le \|\| !ni->attr_list.le \|\| !ni->attr_list.size)
	23	return false;
	24
	25	return PtrOffset(ni->attr_list.le, le) + le16_to_cpu(le->size) <=
	26	ni->attr_list.size;
	27	}
	28
	29	void al_destroy(struct ntfs_inode *ni)
	30	{
	31	run_close(&ni->attr_list.run);
195c52bd	32	kfree(ni->attr_list.le);
be71b5cb KK	33	ni->attr_list.le = NULL;
	34	ni->attr_list.size = 0;
	35	ni->attr_list.dirty = false;
	36	}
	37
	38	/*
	39	* ntfs_load_attr_list
	40	*
	41	* This method makes sure that the ATTRIB list, if present,
	42	* has been properly set up.
	43	*/
	44	int ntfs_load_attr_list(struct ntfs_inode ni, struct ATTRIB attr)
	45	{
	46	int err;
	47	size_t lsize;
	48	void *le = NULL;
	49
	50	if (ni->attr_list.size)
	51	return 0;
	52
	53	if (!attr->non_res) {
	54	lsize = le32_to_cpu(attr->res.data_size);
195c52bd	55	le = kmalloc(al_aligned(lsize), GFP_NOFS);
be71b5cb KK	56	if (!le) {
	57	err = -ENOMEM;
	58	goto out;
	59	}
	60	memcpy(le, resident_data(attr), lsize);
	61	} else if (attr->nres.svcn) {
	62	err = -EINVAL;
	63	goto out;
	64	} else {
	65	u16 run_off = le16_to_cpu(attr->nres.run_off);
	66
	67	lsize = le64_to_cpu(attr->nres.data_size);
	68
	69	run_init(&ni->attr_list.run);
	70
	71	err = run_unpack_ex(&ni->attr_list.run, ni->mi.sbi, ni->mi.rno,
	72	0, le64_to_cpu(attr->nres.evcn), 0,
	73	Add2Ptr(attr, run_off),
	74	le32_to_cpu(attr->size) - run_off);
	75	if (err < 0)
	76	goto out;
	77
195c52bd	78	le = kmalloc(al_aligned(lsize), GFP_NOFS);
be71b5cb KK	79	if (!le) {
	80	err = -ENOMEM;
	81	goto out;
	82	}
	83
	84	err = ntfs_read_run_nb(ni->mi.sbi, &ni->attr_list.run, 0, le,
	85	lsize, NULL);
	86	if (err)
	87	goto out;
	88	}
	89
	90	ni->attr_list.size = lsize;
	91	ni->attr_list.le = le;
	92
	93	return 0;
	94
	95	out:
	96	ni->attr_list.le = le;
	97	al_destroy(ni);
	98
	99	return err;
	100	}
	101
	102	/*
	103	* al_enumerate
	104	*
e8b8e97f KA	105	* Return:
	106	* * The next list le.
	107	* * If @le is NULL then return the first le.
be71b5cb KK	108	*/
	109	struct ATTR_LIST_ENTRY al_enumerate(struct ntfs_inode ni,
	110	struct ATTR_LIST_ENTRY *le)
	111	{
	112	size_t off;
	113	u16 sz;
	114
	115	if (!le) {
	116	le = ni->attr_list.le;
	117	} else {
	118	sz = le16_to_cpu(le->size);
	119	if (sz < sizeof(struct ATTR_LIST_ENTRY)) {
e8b8e97f	120	/* Impossible 'cause we should not return such le. */
be71b5cb KK	121	return NULL;
	122	}
	123	le = Add2Ptr(le, sz);
	124	}
	125
e8b8e97f	126	/* Check boundary. */
be71b5cb KK	127	off = PtrOffset(ni->attr_list.le, le);
be71b5cb KK	128	if (off + sizeof(struct ATTR_LIST_ENTRY) > ni->attr_list.size) {
e8b8e97f	129	/* The regular end of list. */
be71b5cb KK	130	return NULL;
	131	}
	132
	133	sz = le16_to_cpu(le->size);
	134
e8b8e97f	135	/* Check le for errors. */
be71b5cb KK	136	if (sz < sizeof(struct ATTR_LIST_ENTRY) \|\|
	137	off + sz > ni->attr_list.size \|\|
	138	sz < le->name_off + le->name_len * sizeof(short)) {
	139	return NULL;
	140	}
	141
	142	return le;
	143	}
	144
	145	/*
	146	* al_find_le
	147	*
e8b8e97f KA	148	* Find the first le in the list which matches type, name and VCN.
	149	*
	150	* Return: NULL if not found.
be71b5cb KK	151	*/
	152	struct ATTR_LIST_ENTRY al_find_le(struct ntfs_inode ni,
	153	struct ATTR_LIST_ENTRY *le,
	154	const struct ATTRIB *attr)
	155	{
	156	CLST svcn = attr_svcn(attr);
	157
	158	return al_find_ex(ni, le, attr->type, attr_name(attr), attr->name_len,
	159	&svcn);
	160	}
	161
	162	/*
	163	* al_find_ex
	164	*
e8b8e97f KA	165	* Find the first le in the list which matches type, name and VCN.
	166	*
	167	* Return: NULL if not found.
be71b5cb KK	168	*/
	169	struct ATTR_LIST_ENTRY al_find_ex(struct ntfs_inode ni,
	170	struct ATTR_LIST_ENTRY *le,
	171	enum ATTR_TYPE type, const __le16 *name,
	172	u8 name_len, const CLST *vcn)
	173	{
	174	struct ATTR_LIST_ENTRY *ret = NULL;
	175	u32 type_in = le32_to_cpu(type);
	176
	177	while ((le = al_enumerate(ni, le))) {
	178	u64 le_vcn;
	179	int diff = le32_to_cpu(le->type) - type_in;
	180
e8b8e97f	181	/* List entries are sorted by type, name and VCN. */
be71b5cb KK	182	if (diff < 0)
	183	continue;
	184
	185	if (diff > 0)
	186	return ret;
	187
	188	if (le->name_len != name_len)
	189	continue;
	190
	191	le_vcn = le64_to_cpu(le->vcn);
	192	if (!le_vcn) {
	193	/*
e8b8e97f	194	* Compare entry names only for entry with vcn == 0.
be71b5cb KK	195	*/
	196	diff = ntfs_cmp_names(le_name(le), name_len, name,
	197	name_len, ni->mi.sbi->upcase,
	198	true);
	199	if (diff < 0)
	200	continue;
	201
	202	if (diff > 0)
	203	return ret;
	204	}
	205
	206	if (!vcn)
	207	return le;
	208
	209	if (*vcn == le_vcn)
	210	return le;
	211
	212	if (*vcn < le_vcn)
	213	return ret;
	214
	215	ret = le;
	216	}
	217
	218	return ret;
	219	}
	220
	221	/*
	222	* al_find_le_to_insert
	223	*
e8b8e97f	224	* Find the first list entry which matches type, name and VCN.
be71b5cb KK	225	*/
	226	static struct ATTR_LIST_ENTRY al_find_le_to_insert(struct ntfs_inode ni,
	227	enum ATTR_TYPE type,
	228	const __le16 *name,
	229	u8 name_len, CLST vcn)
	230	{
	231	struct ATTR_LIST_ENTRY le = NULL, prev;
	232	u32 type_in = le32_to_cpu(type);
	233
e8b8e97f	234	/* List entries are sorted by type, name and VCN. */
be71b5cb KK	235	while ((le = al_enumerate(ni, prev = le))) {
	236	int diff = le32_to_cpu(le->type) - type_in;
	237
	238	if (diff < 0)
	239	continue;
	240
	241	if (diff > 0)
	242	return le;
	243
	244	if (!le->vcn) {
	245	/*
e8b8e97f	246	* Compare entry names only for entry with vcn == 0.
be71b5cb KK	247	*/
	248	diff = ntfs_cmp_names(le_name(le), le->name_len, name,
	249	name_len, ni->mi.sbi->upcase,
	250	true);
	251	if (diff < 0)
	252	continue;
	253
	254	if (diff > 0)
	255	return le;
	256	}
	257
	258	if (le64_to_cpu(le->vcn) >= vcn)
	259	return le;
	260	}
	261
	262	return prev ? Add2Ptr(prev, le16_to_cpu(prev->size)) : ni->attr_list.le;
	263	}
	264
	265	/*
	266	* al_add_le
	267	*
e8b8e97f	268	* Add an "attribute list entry" to the list.
be71b5cb KK	269	*/
	270	int al_add_le(struct ntfs_inode ni, enum ATTR_TYPE type, const __le16 name,
	271	u8 name_len, CLST svcn, __le16 id, const struct MFT_REF *ref,
	272	struct ATTR_LIST_ENTRY **new_le)
	273	{
	274	int err;
	275	struct ATTRIB *attr;
	276	struct ATTR_LIST_ENTRY *le;
	277	size_t off;
	278	u16 sz;
78ab59fe	279	size_t asize, new_asize, old_size;
be71b5cb KK	280	u64 new_size;
	281	typeof(ni->attr_list) *al = &ni->attr_list;
	282
	283	/*
	284	* Compute the size of the new 'le'
	285	*/
	286	sz = le_size(name_len);
78ab59fe KK	287	old_size = al->size;
	288	new_size = old_size + sz;
	289	asize = al_aligned(old_size);
be71b5cb KK	290	new_asize = al_aligned(new_size);
	291
	292	/* Scan forward to the point at which the new 'le' should be inserted. */
	293	le = al_find_le_to_insert(ni, type, name, name_len, svcn);
	294	off = PtrOffset(al->le, le);
	295
	296	if (new_size > asize) {
195c52bd	297	void *ptr = kmalloc(new_asize, GFP_NOFS);
be71b5cb KK	298
	299	if (!ptr)
	300	return -ENOMEM;
	301
	302	memcpy(ptr, al->le, off);
78ab59fe	303	memcpy(Add2Ptr(ptr, off + sz), le, old_size - off);
be71b5cb	304	le = Add2Ptr(ptr, off);
195c52bd	305	kfree(al->le);
be71b5cb KK	306	al->le = ptr;
be71b5cb KK	307	} else {
78ab59fe	308	memmove(Add2Ptr(le, sz), le, old_size - off);
be71b5cb	309	}
78ab59fe	310	*new_le = le;
be71b5cb KK	311
	312	al->size = new_size;
	313
	314	le->type = type;
	315	le->size = cpu_to_le16(sz);
	316	le->name_len = name_len;
	317	le->name_off = offsetof(struct ATTR_LIST_ENTRY, name);
	318	le->vcn = cpu_to_le64(svcn);
	319	le->ref = *ref;
	320	le->id = id;
	321	memcpy(le->name, name, sizeof(short) * name_len);
	322
be71b5cb KK	323	err = attr_set_size(ni, ATTR_LIST, NULL, 0, &al->run, new_size,
be71b5cb KK	324	&new_size, true, &attr);
78ab59fe KK	325	if (err) {
	326	/* Undo memmove above. */
	327	memmove(le, Add2Ptr(le, sz), old_size - off);
	328	al->size = old_size;
be71b5cb	329	return err;
78ab59fe KK	330	}
	331
	332	al->dirty = true;
be71b5cb KK	333
	334	if (attr && attr->non_res) {
	335	err = ntfs_sb_write_run(ni->mi.sbi, &al->run, 0, al->le,
63544672	336	al->size, 0);
be71b5cb KK	337	if (err)
be71b5cb KK	338	return err;
78ab59fe	339	al->dirty = false;
be71b5cb KK	340	}
be71b5cb KK	341
be71b5cb KK	342	return 0;
	343	}
	344
	345	/*
e8b8e97f	346	* al_remove_le - Remove @le from attribute list.
be71b5cb KK	347	*/
	348	bool al_remove_le(struct ntfs_inode ni, struct ATTR_LIST_ENTRY le)
	349	{
	350	u16 size;
	351	size_t off;
	352	typeof(ni->attr_list) *al = &ni->attr_list;
	353
	354	if (!al_is_valid_le(ni, le))
	355	return false;
	356
	357	/* Save on stack the size of 'le' */
	358	size = le16_to_cpu(le->size);
	359	off = PtrOffset(al->le, le);
	360
	361	memmove(le, Add2Ptr(le, size), al->size - (off + size));
	362
	363	al->size -= size;
	364	al->dirty = true;
	365
	366	return true;
	367	}
	368
	369	/*
e8b8e97f	370	* al_delete_le - Delete first le from the list which matches its parameters.
be71b5cb KK	371	*/
	372	bool al_delete_le(struct ntfs_inode *ni, enum ATTR_TYPE type, CLST vcn,
	373	const __le16 *name, size_t name_len,
	374	const struct MFT_REF *ref)
	375	{
	376	u16 size;
	377	struct ATTR_LIST_ENTRY *le;
	378	size_t off;
	379	typeof(ni->attr_list) *al = &ni->attr_list;
	380
e8b8e97f	381	/* Scan forward to the first le that matches the input. */
be71b5cb KK	382	le = al_find_ex(ni, NULL, type, name, name_len, &vcn);
	383	if (!le)
	384	return false;
	385
	386	off = PtrOffset(al->le, le);
	387
	388	next:
	389	if (off >= al->size)
	390	return false;
	391	if (le->type != type)
	392	return false;
	393	if (le->name_len != name_len)
	394	return false;
	395	if (name_len && ntfs_cmp_names(le_name(le), name_len, name, name_len,
	396	ni->mi.sbi->upcase, true))
	397	return false;
	398	if (le64_to_cpu(le->vcn) != vcn)
	399	return false;
	400
	401	/*
	402	* The caller specified a segment reference, so we have to
	403	* scan through the matching entries until we find that segment
	404	* reference or we run of matching entries.
	405	*/
	406	if (ref && memcmp(ref, &le->ref, sizeof(*ref))) {
	407	off += le16_to_cpu(le->size);
	408	le = Add2Ptr(al->le, off);
	409	goto next;
	410	}
	411
e8b8e97f	412	/* Save on stack the size of 'le'. */
be71b5cb	413	size = le16_to_cpu(le->size);
e8b8e97f	414	/* Delete the le. */
be71b5cb KK	415	memmove(le, Add2Ptr(le, size), al->size - (off + size));
	416
	417	al->size -= size;
	418	al->dirty = true;
	419
	420	return true;
	421	}
	422
63544672	423	int al_update(struct ntfs_inode *ni, int sync)
be71b5cb KK	424	{
	425	int err;
	426	struct ATTRIB *attr;
	427	typeof(ni->attr_list) *al = &ni->attr_list;
	428
	429	if (!al->dirty \|\| !al->size)
	430	return 0;
	431
	432	/*
e8b8e97f KA	433	* Attribute list increased on demand in al_add_le.
e8b8e97f KA	434	* Attribute list decreased here.
be71b5cb KK	435	*/
	436	err = attr_set_size(ni, ATTR_LIST, NULL, 0, &al->run, al->size, NULL,
	437	false, &attr);
	438	if (err)
	439	goto out;
	440
	441	if (!attr->non_res) {
	442	memcpy(resident_data(attr), al->le, al->size);
	443	} else {
	444	err = ntfs_sb_write_run(ni->mi.sbi, &al->run, 0, al->le,
63544672	445	al->size, sync);
be71b5cb KK	446	if (err)
	447	goto out;
	448
	449	attr->nres.valid_size = attr->nres.data_size;
	450	}
	451
	452	ni->mi.dirty = true;
	453	al->dirty = false;
	454
	455	out:
	456	return err;
	457	}