Re: [PATCH] fs/ntfs3: Rework file operations

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 




On 01.09.2021 00:54, Kari Argillander wrote:
> First of this commit is already in ntfs3/master without review. Please
> do not do that. We are middle of merge window and new this kind of patch
> is in.
> 
> This patch does also lot of refactoring, dead code removel, maybe some
> bug fixes and who knows what else. One patch should address only one
> thing.  I did not review whole thing but some comments there.  I also
> feel like this is kinda impossible to review because so much happening.
> This is over 2000 lines long patch.  Do you want to review this kind of
> patches yourself? I cc also fsdevel, maybe someone can help us little
> bit.
> 

Ntfs3 had data corruption. This commit is the result of 
reworking related functions. It's a pity, that this version 
wasn't in initial ntfs3 patches, because this commit basically
rewrites a significant part of driver.

>From now on our commits will follow path 
"devel branch => lkml => wait for feedback => master branch"

There are no plans of further refactoring of existing codebase
that can lead to another huge commit.

Thanks for review.

> Partial review starts here:
> 
> sfr@xxxxxxxxxxxxxxxx
> ^^
> There is this same cc. Accident?
> 
> Subject: [PATCH] fs/ntfs3: Rework file operations
> 
> ^^ Not very informative commit header
> 
> Maybe better should be:
> Change rename logic to add new name and then remove old one 
> 
> 
> Please also use at least checkpatch. It found three warnings with this
> patch.
> 
> On Tue, Aug 31, 2021 at 07:34:28PM +0300, Konstantin Komarov wrote:
>> Rename now works "Add new name and remove old name".
>> "Remove old name and add new name" may result in bad inode
>> if we can't add new name and then can't restore (add) old name.
> 
> Also little hard to read commit message. Let me help a little bit. 
> Maybe something like (not checked your patch yet):
> 
> Current rename logic is that we first remove old name and then add new
> name.  This can result bad inode if there is situation that when we add
> new name and it fails we have no option to return old one.
> 
> Change behavier so that we first try to add new name and only after that
> we delete old one.
> 
>>
>> Signed-off-by: Konstantin Komarov <almaz.alexandrovich@xxxxxxxxxxxxxxxxxxxx>
>> ---
>>  fs/ntfs3/attrib.c   |  17 +--
>>  fs/ntfs3/attrlist.c |  26 ++--
>>  fs/ntfs3/frecord.c  | 342 ++++++++++++++++++++++++++++++++++++--------
>>  fs/ntfs3/fsntfs.c   |  87 +++++------
>>  fs/ntfs3/index.c    |  45 +++---
>>  fs/ntfs3/inode.c    | 275 ++++++++++++-----------------------
>>  fs/ntfs3/namei.c    | 236 ++++++++----------------------
>>  fs/ntfs3/ntfs_fs.h  |  31 +++-
>>  fs/ntfs3/record.c   |   8 +-
>>  fs/ntfs3/xattr.c    |  25 ++--
>>  10 files changed, 563 insertions(+), 529 deletions(-)
>>
>> diff --git a/fs/ntfs3/attrib.c b/fs/ntfs3/attrib.c
>> index 4b285f704e62..ffc323bacc9f 100644
>> --- a/fs/ntfs3/attrib.c
>> +++ b/fs/ntfs3/attrib.c
>> @@ -218,9 +218,11 @@ int attr_allocate_clusters(struct ntfs_sb_info *sbi, struct runs_tree *run,
>>  	}
>>  
>>  out:
>> -	/* Undo. */
>> -	run_deallocate_ex(sbi, run, vcn0, vcn - vcn0, NULL, false);
>> -	run_truncate(run, vcn0);
>> +	/* Undo 'ntfs_look_for_free_space' */
>> +	if (vcn - vcn0) {
>> +		run_deallocate_ex(sbi, run, vcn0, vcn - vcn0, NULL, false);
>> +		run_truncate(run, vcn0);
>> +	}
> 
> Can this happend for both goto out paths? If not then other should
> return err straight away. 
> 
>>  
>>  	return err;
>>  }
>> @@ -701,7 +703,7 @@ int attr_set_size(struct ntfs_inode *ni, enum ATTR_TYPE type,
>>  			 * (list entry for std attribute always first).
>>  			 * So it is safe to step back.
>>  			 */
>> -			mi_remove_attr(mi, attr);
>> +			mi_remove_attr(NULL, mi, attr);
>>  
>>  			if (!al_remove_le(ni, le)) {
>>  				err = -EINVAL;
>> @@ -1004,7 +1006,7 @@ int attr_data_get_block(struct ntfs_inode *ni, CLST vcn, CLST clen, CLST *lcn,
>>  			end = next_svcn;
>>  		while (end > evcn) {
>>  			/* Remove segment [svcn : evcn). */
>> -			mi_remove_attr(mi, attr);
>> +			mi_remove_attr(NULL, mi, attr);
>>  
>>  			if (!al_remove_le(ni, le)) {
>>  				err = -EINVAL;
>> @@ -1600,7 +1602,7 @@ int attr_allocate_frame(struct ntfs_inode *ni, CLST frame, size_t compr_size,
>>  			end = next_svcn;
>>  		while (end > evcn) {
>>  			/* Remove segment [svcn : evcn). */
>> -			mi_remove_attr(mi, attr);
>> +			mi_remove_attr(NULL, mi, attr);
>>  
>>  			if (!al_remove_le(ni, le)) {
>>  				err = -EINVAL;
>> @@ -1836,13 +1838,12 @@ int attr_collapse_range(struct ntfs_inode *ni, u64 vbo, u64 bytes)
>>  			u16 le_sz;
>>  			u16 roff = le16_to_cpu(attr->nres.run_off);
>>  
>> -			/* run==1 means unpack and deallocate. */
> 
> What's whit this one? Old comment maybe but should not be addressed with
> this patch.
> 
>>  			run_unpack_ex(RUN_DEALLOCATE, sbi, ni->mi.rno, svcn,
>>  				      evcn1 - 1, svcn, Add2Ptr(attr, roff),
>>  				      le32_to_cpu(attr->size) - roff);
>>  
>>  			/* Delete this attribute segment. */
>> -			mi_remove_attr(mi, attr);
>> +			mi_remove_attr(NULL, mi, attr);
>>  			if (!le)
>>  				break;
>>  
>> diff --git a/fs/ntfs3/attrlist.c b/fs/ntfs3/attrlist.c
>> index 32ca990af64b..fa32399eb517 100644
>> --- a/fs/ntfs3/attrlist.c
>> +++ b/fs/ntfs3/attrlist.c
>> @@ -279,7 +279,7 @@ int al_add_le(struct ntfs_inode *ni, enum ATTR_TYPE type, const __le16 *name,
>>  	struct ATTR_LIST_ENTRY *le;
>>  	size_t off;
>>  	u16 sz;
>> -	size_t asize, new_asize;
>> +	size_t asize, new_asize, old_size;
>>  	u64 new_size;
>>  	typeof(ni->attr_list) *al = &ni->attr_list;
>>  
>> @@ -287,8 +287,9 @@ int al_add_le(struct ntfs_inode *ni, enum ATTR_TYPE type, const __le16 *name,
>>  	 * Compute the size of the new 'le'
>>  	 */
>>  	sz = le_size(name_len);
>> -	new_size = al->size + sz;
>> -	asize = al_aligned(al->size);
>> +	old_size = al->size;
>> +	asize = al_aligned(old_size);
>>  	new_asize = al_aligned(new_size);
>>  
>>  	/* Scan forward to the point at which the new 'le' should be inserted. */
>> @@ -302,13 +303,14 @@ int al_add_le(struct ntfs_inode *ni, enum ATTR_TYPE type, const __le16 *name,
>>  			return -ENOMEM;
>>  
>>  		memcpy(ptr, al->le, off);
>> -		memcpy(Add2Ptr(ptr, off + sz), le, al->size - 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, al->size - off);
>> +		memmove(Add2Ptr(le, sz), le, old_size - off);
>>  	}
>> +	*new_le = le;
>>  
>>  	al->size = new_size;
>>  
>> @@ -321,23 +323,25 @@ int al_add_le(struct ntfs_inode *ni, enum ATTR_TYPE type, const __le16 *name,
>>  	le->id = id;
>>  	memcpy(le->name, name, sizeof(short) * name_len);
>>  
>> -	al->dirty = true;
>> -
>>  	err = attr_set_size(ni, ATTR_LIST, NULL, 0, &al->run, new_size,
>>  			    &new_size, true, &attr);
>> -	if (err)
>> +	if (err) {
>> +		/* Undo memmove above. */
> 
> There is path also for memcpy. What if we go there. Is this path then
> impossible? Just checking.
> 
>> +		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);
>>  		if (err)
>>  			return err;
>> +		al->dirty = false;
>>  	}
>>  
>> -	al->dirty = false;
>> -	*new_le = le;
>> -
>>  	return 0;
>>  }
>>  
>> diff --git a/fs/ntfs3/frecord.c b/fs/ntfs3/frecord.c
>> index 9d374827750b..3f48b612ec96 100644
>> --- a/fs/ntfs3/frecord.c
>> +++ b/fs/ntfs3/frecord.c
>> @@ -163,7 +163,7 @@ int ni_load_mi_ex(struct ntfs_inode *ni, CLST rno, struct mft_inode **mi)
>>  /*
>>   * ni_load_mi - Load mft_inode corresponded list_entry.
>>   */
>> -int ni_load_mi(struct ntfs_inode *ni, struct ATTR_LIST_ENTRY *le,
>> +int ni_load_mi(struct ntfs_inode *ni, const struct ATTR_LIST_ENTRY *le,
>>  	       struct mft_inode **mi)
> 
> Feels like unnecesary change for this patch.
> 
>>  {
>>  	CLST rno;
>> @@ -402,7 +402,7 @@ int ni_remove_attr(struct ntfs_inode *ni, enum ATTR_TYPE type,
>>  		if (!attr)
>>  			return -ENOENT;
>>  
>> -		mi_remove_attr(&ni->mi, attr);
>> +		mi_remove_attr(ni, &ni->mi, attr);
>>  		return 0;
>>  	}
>>  
>> @@ -441,7 +441,7 @@ int ni_remove_attr(struct ntfs_inode *ni, enum ATTR_TYPE type,
>>  		if (!attr)
>>  			return -ENOENT;
>>  
>> -		mi_remove_attr(mi, attr);
>> +		mi_remove_attr(ni, mi, attr);
>>  
>>  		if (PtrOffset(ni->attr_list.le, le) >= ni->attr_list.size)
>>  			return 0;
>> @@ -454,12 +454,11 @@ int ni_remove_attr(struct ntfs_inode *ni, enum ATTR_TYPE type,
>>   *
>>   * Return: Not full constructed attribute or NULL if not possible to create.
>>   */
>> -static struct ATTRIB *ni_ins_new_attr(struct ntfs_inode *ni,
>> -				      struct mft_inode *mi,
>> -				      struct ATTR_LIST_ENTRY *le,
>> -				      enum ATTR_TYPE type, const __le16 *name,
>> -				      u8 name_len, u32 asize, u16 name_off,
>> -				      CLST svcn)
>> +static struct ATTRIB *
>> +ni_ins_new_attr(struct ntfs_inode *ni, struct mft_inode *mi,
>> +		struct ATTR_LIST_ENTRY *le, enum ATTR_TYPE type,
>> +		const __le16 *name, u8 name_len, u32 asize, u16 name_off,
>> +		CLST svcn, struct ATTR_LIST_ENTRY **ins_le)
> 
> Reviewing would be lot lot easier if you make one patch which just adds
> this new ins_le to every function needed. Just call it with NULL. Then
> there would be much less noise to watch.
> 
>>  {
>>  	int err;
>>  	struct ATTRIB *attr;
>> @@ -507,6 +506,8 @@ static struct ATTRIB *ni_ins_new_attr(struct ntfs_inode *ni,
>>  	le->ref = ref;
>>  
>>  out:
>> +	if (ins_le)
>> +		*ins_le = le;
>>  	return attr;
>>  }
>>  
>> @@ -599,7 +600,7 @@ static int ni_repack(struct ntfs_inode *ni)
>>  		if (next_svcn >= evcn + 1) {
>>  			/* We can remove this attribute segment. */
>>  			al_remove_le(ni, le);
>> -			mi_remove_attr(mi, attr);
>> +			mi_remove_attr(NULL, mi, attr);
>>  			le = le_p;
>>  			continue;
>>  		}
>> @@ -695,8 +696,8 @@ static int ni_try_remove_attr_list(struct ntfs_inode *ni)
>>  		free -= asize;
>>  	}
>>  
>> -	/* Is seems that attribute list can be removed from primary record. */
>> -	mi_remove_attr(&ni->mi, attr_list);
>> +	/* It seems that attribute list can be removed from primary record. */
>> +	mi_remove_attr(NULL, &ni->mi, attr_list);
>>  
>>  	/*
>>  	 * Repeat the cycle above and move all attributes to primary record.
>> @@ -724,7 +725,7 @@ static int ni_try_remove_attr_list(struct ntfs_inode *ni)
>>  		attr_ins->id = id;
>>  
>>  		/* Remove from original record. */
>> -		mi_remove_attr(mi, attr);
>> +		mi_remove_attr(NULL, mi, attr);
>>  	}
>>  
>>  	run_deallocate(sbi, &ni->attr_list.run, true);
>> @@ -842,7 +843,8 @@ int ni_create_attr_list(struct ntfs_inode *ni)
>>  		memcpy(attr, b, asize);
>>  		attr->id = le_b[nb]->id;
>>  
>> -		WARN_ON(!mi_remove_attr(&ni->mi, b));
>> +		/* Remove from primary record. */
>> +		WARN_ON(!mi_remove_attr(NULL, &ni->mi, b));
>>  
>>  		if (to_free <= asize)
>>  			break;
>> @@ -883,7 +885,8 @@ int ni_create_attr_list(struct ntfs_inode *ni)
>>  static int ni_ins_attr_ext(struct ntfs_inode *ni, struct ATTR_LIST_ENTRY *le,
>>  			   enum ATTR_TYPE type, const __le16 *name, u8 name_len,
>>  			   u32 asize, CLST svcn, u16 name_off, bool force_ext,
>> -			   struct ATTRIB **ins_attr, struct mft_inode **ins_mi)
>> +			   struct ATTRIB **ins_attr, struct mft_inode **ins_mi,
>> +			   struct ATTR_LIST_ENTRY **ins_le)
>>  {
>>  	struct ATTRIB *attr;
>>  	struct mft_inode *mi;
>> @@ -956,12 +959,14 @@ static int ni_ins_attr_ext(struct ntfs_inode *ni, struct ATTR_LIST_ENTRY *le,
>>  
>>  		/* Try to insert attribute into this subrecord. */
>>  		attr = ni_ins_new_attr(ni, mi, le, type, name, name_len, asize,
>> -				       name_off, svcn);
>> +				       name_off, svcn, ins_le);
>>  		if (!attr)
>>  			continue;
>>  
>>  		if (ins_attr)
>>  			*ins_attr = attr;
>> +		if (ins_mi)
>> +			*ins_mi = mi;
>>  		return 0;
>>  	}
>>  
>> @@ -977,7 +982,7 @@ static int ni_ins_attr_ext(struct ntfs_inode *ni, struct ATTR_LIST_ENTRY *le,
>>  	}
>>  
>>  	attr = ni_ins_new_attr(ni, mi, le, type, name, name_len, asize,
>> -			       name_off, svcn);
>> +			       name_off, svcn, ins_le);
>>  	if (!attr)
>>  		goto out2;
>>  
>> @@ -1016,7 +1021,8 @@ static int ni_ins_attr_ext(struct ntfs_inode *ni, struct ATTR_LIST_ENTRY *le,
>>  static int ni_insert_attr(struct ntfs_inode *ni, enum ATTR_TYPE type,
>>  			  const __le16 *name, u8 name_len, u32 asize,
>>  			  u16 name_off, CLST svcn, struct ATTRIB **ins_attr,
>> -			  struct mft_inode **ins_mi)
>> +			  struct mft_inode **ins_mi,
>> +			  struct ATTR_LIST_ENTRY **ins_le)
>>  {
>>  	struct ntfs_sb_info *sbi = ni->mi.sbi;
>>  	int err;
>> @@ -1045,7 +1051,7 @@ static int ni_insert_attr(struct ntfs_inode *ni, enum ATTR_TYPE type,
>>  
>>  	if (asize <= free) {
>>  		attr = ni_ins_new_attr(ni, &ni->mi, NULL, type, name, name_len,
>> -				       asize, name_off, svcn);
>> +				       asize, name_off, svcn, ins_le);
>>  		if (attr) {
>>  			if (ins_attr)
>>  				*ins_attr = attr;
>> @@ -1059,7 +1065,8 @@ static int ni_insert_attr(struct ntfs_inode *ni, enum ATTR_TYPE type,
>>  	if (!is_mft || type != ATTR_DATA || svcn) {
>>  		/* This ATTRIB will be external. */
>>  		err = ni_ins_attr_ext(ni, NULL, type, name, name_len, asize,
>> -				      svcn, name_off, false, ins_attr, ins_mi);
>> +				      svcn, name_off, false, ins_attr, ins_mi,
>> +				      ins_le);
>>  		goto out;
>>  	}
>>  
>> @@ -1117,7 +1124,7 @@ static int ni_insert_attr(struct ntfs_inode *ni, enum ATTR_TYPE type,
>>  		t16 = le16_to_cpu(attr->name_off);
>>  		err = ni_ins_attr_ext(ni, le, attr->type, Add2Ptr(attr, t16),
>>  				      attr->name_len, t32, attr_svcn(attr), t16,
>> -				      false, &eattr, NULL);
>> +				      false, &eattr, NULL, NULL);
>>  		if (err)
>>  			return err;
>>  
>> @@ -1125,8 +1132,8 @@ static int ni_insert_attr(struct ntfs_inode *ni, enum ATTR_TYPE type,
>>  		memcpy(eattr, attr, t32);
>>  		eattr->id = id;
>>  
>> -		/* Remove attrib from primary record. */
>> -		mi_remove_attr(&ni->mi, attr);
>> +		/* Remove from primary record. */
>> +		mi_remove_attr(NULL, &ni->mi, attr);
>>  
>>  		/* attr now points to next attribute. */
>>  		if (attr->type == ATTR_END)
>> @@ -1136,7 +1143,7 @@ static int ni_insert_attr(struct ntfs_inode *ni, enum ATTR_TYPE type,
>>  		;
>>  
>>  	attr = ni_ins_new_attr(ni, &ni->mi, NULL, type, name, name_len, asize,
>> -			       name_off, svcn);
>> +			       name_off, svcn, ins_le);
>>  	if (!attr) {
>>  		err = -EINVAL;
>>  		goto out;
>> @@ -1251,7 +1258,7 @@ static int ni_expand_mft_list(struct ntfs_inode *ni)
>>  	 */
>>  	attr = ni_ins_new_attr(ni, mi_min, NULL, ATTR_DATA, NULL, 0,
>>  			       SIZEOF_NONRESIDENT + run_size,
>> -			       SIZEOF_NONRESIDENT, svcn);
>> +			       SIZEOF_NONRESIDENT, svcn, NULL);
>>  	if (!attr) {
>>  		err = -EINVAL;
>>  		goto out;
>> @@ -1315,14 +1322,15 @@ int ni_expand_list(struct ntfs_inode *ni)
>>  		err = ni_ins_attr_ext(ni, le, attr->type, attr_name(attr),
>>  				      attr->name_len, asize, attr_svcn(attr),
>>  				      le16_to_cpu(attr->name_off), true,
>> -				      &ins_attr, NULL);
>> +				      &ins_attr, NULL, NULL);
>>  
>>  		if (err)
>>  			goto out;
>>  
>>  		memcpy(ins_attr, attr, asize);
>>  		ins_attr->id = le->id;
>> -		mi_remove_attr(&ni->mi, attr);
>> +		/* Remove from primary record. */
>> +		mi_remove_attr(NULL, &ni->mi, attr);
>>  
>>  		done += asize;
>>  		goto out;
>> @@ -1382,7 +1390,7 @@ int ni_insert_nonresident(struct ntfs_inode *ni, enum ATTR_TYPE type,
>>  	}
>>  
>>  	err = ni_insert_attr(ni, type, name, name_len, asize, name_off, svcn,
>> -			     &attr, mi);
>> +			     &attr, mi, NULL);
>>  
>>  	if (err)
>>  		goto out;
>> @@ -1422,7 +1430,8 @@ int ni_insert_nonresident(struct ntfs_inode *ni, enum ATTR_TYPE type,
>>   */
>>  int ni_insert_resident(struct ntfs_inode *ni, u32 data_size,
>>  		       enum ATTR_TYPE type, const __le16 *name, u8 name_len,
>> -		       struct ATTRIB **new_attr, struct mft_inode **mi)
>> +		       struct ATTRIB **new_attr, struct mft_inode **mi,
>> +		       struct ATTR_LIST_ENTRY **le)
>>  {
>>  	int err;
>>  	u32 name_size = ALIGN(name_len * sizeof(short), 8);
>> @@ -1430,7 +1439,7 @@ int ni_insert_resident(struct ntfs_inode *ni, u32 data_size,
>>  	struct ATTRIB *attr;
>>  
>>  	err = ni_insert_attr(ni, type, name, name_len, asize, SIZEOF_RESIDENT,
>> -			     0, &attr, mi);
>> +			     0, &attr, mi, le);
>>  	if (err)
>>  		return err;
>>  
>> @@ -1439,8 +1448,13 @@ int ni_insert_resident(struct ntfs_inode *ni, u32 data_size,
>>  
>>  	attr->res.data_size = cpu_to_le32(data_size);
>>  	attr->res.data_off = cpu_to_le16(SIZEOF_RESIDENT + name_size);
>> -	if (type == ATTR_NAME)
>> +	if (type == ATTR_NAME) {
>>  		attr->res.flags = RESIDENT_FLAG_INDEXED;
>> +
>> +		/* is_attr_indexed(attr)) == true */
>> +		le16_add_cpu(&ni->mi.mrec->hard_links, +1);
>> +		ni->mi.dirty = true;
>> +	}
>>  	attr->res.res = 0;
>>  
>>  	if (new_attr)
>> @@ -1452,22 +1466,13 @@ int ni_insert_resident(struct ntfs_inode *ni, u32 data_size,
>>  /*
>>   * ni_remove_attr_le - Remove attribute from record.
>>   */
>> -int ni_remove_attr_le(struct ntfs_inode *ni, struct ATTRIB *attr,
>> -		      struct ATTR_LIST_ENTRY *le)
>> +void ni_remove_attr_le(struct ntfs_inode *ni, struct ATTRIB *attr,
>> +		       struct mft_inode *mi, struct ATTR_LIST_ENTRY *le)
>>  {
>> -	int err;
>> -	struct mft_inode *mi;
>> -
>> -	err = ni_load_mi(ni, le, &mi);
>> -	if (err)
>> -		return err;
>> -
>> -	mi_remove_attr(mi, attr);
>> +	mi_remove_attr(ni, mi, attr);
>>  
>>  	if (le)
>>  		al_remove_le(ni, le);
>> -
>> -	return 0;
>>  }
>>  
>>  /*
>> @@ -1549,10 +1554,12 @@ int ni_delete_all(struct ntfs_inode *ni)
>>  
>>  /* ni_fname_name
>>   *
>> - *Return: File name attribute by its value. */
>> + * Return: File name attribute by its value.
>> + */
>>  struct ATTR_FILE_NAME *ni_fname_name(struct ntfs_inode *ni,
>>  				     const struct cpu_str *uni,
>>  				     const struct MFT_REF *home_dir,
>> +				     struct mft_inode **mi,
>>  				     struct ATTR_LIST_ENTRY **le)
>>  {
>>  	struct ATTRIB *attr = NULL;
>> @@ -1562,7 +1569,7 @@ struct ATTR_FILE_NAME *ni_fname_name(struct ntfs_inode *ni,
>>  
>>  	/* Enumerate all names. */
>>  next:
>> -	attr = ni_find_attr(ni, attr, le, ATTR_NAME, NULL, 0, NULL, NULL);
>> +	attr = ni_find_attr(ni, attr, le, ATTR_NAME, NULL, 0, NULL, mi);
>>  	if (!attr)
>>  		return NULL;
>>  
>> @@ -1592,6 +1599,7 @@ struct ATTR_FILE_NAME *ni_fname_name(struct ntfs_inode *ni,
>>   * Return: File name attribute with given type.
>>   */
>>  struct ATTR_FILE_NAME *ni_fname_type(struct ntfs_inode *ni, u8 name_type,
>> +				     struct mft_inode **mi,
>>  				     struct ATTR_LIST_ENTRY **le)
>>  {
>>  	struct ATTRIB *attr = NULL;
>> @@ -1599,10 +1607,12 @@ struct ATTR_FILE_NAME *ni_fname_type(struct ntfs_inode *ni, u8 name_type,
>>  
>>  	*le = NULL;
>>  
>> +	if (FILE_NAME_POSIX == name_type)
>> +		return NULL;
>> +
>>  	/* Enumerate all names. */
>>  	for (;;) {
>> -		attr = ni_find_attr(ni, attr, le, ATTR_NAME, NULL, 0, NULL,
>> -				    NULL);
>> +		attr = ni_find_attr(ni, attr, le, ATTR_NAME, NULL, 0, NULL, mi);
>>  		if (!attr)
>>  			return NULL;
>>  
>> @@ -2788,6 +2798,222 @@ int ni_write_frame(struct ntfs_inode *ni, struct page **pages,
>>  	return err;
>>  }
>>  
>> +/*
>> + * ni_remove_name - Removes name 'de' from MFT and from directory.
>> + * 'de2' and 'undo_step' are used to restore MFT/dir, if error occurs.
>> + */
>> +int ni_remove_name(struct ntfs_inode *dir_ni, struct ntfs_inode *ni,
>> +		   struct NTFS_DE *de, struct NTFS_DE **de2, int *undo_step)
>> +{
>> +	int err;
>> +	struct ntfs_sb_info *sbi = ni->mi.sbi;
>> +	struct ATTR_FILE_NAME *de_name = (struct ATTR_FILE_NAME *)(de + 1);
>> +	struct ATTR_FILE_NAME *fname;
>> +	struct ATTR_LIST_ENTRY *le;
>> +	struct mft_inode *mi;
>> +	u16 de_key_size = le16_to_cpu(de->key_size);
>> +	u8 name_type;
>> +
>> +	*undo_step = 0;
> 
> It looks to me that this function can make undo by itself. There is no
> need for ni_remove_name_undo. This looks very strange way to do this.
> 
> One other way if really needed is also to use return value, but this
> pointer undo_step feels just wrong. 
> 
>> +
>> +	/* Find name in record. */
>> +	mi_get_ref(&dir_ni->mi, &de_name->home);
>> +
>> +	fname = ni_fname_name(ni, (struct cpu_str *)&de_name->name_len,
>> +			      &de_name->home, &mi, &le);
>> +	if (!fname)
>> +		return -ENOENT;
>> +
>> +	memcpy(&de_name->dup, &fname->dup, sizeof(struct NTFS_DUP_INFO));
>> +	name_type = paired_name(fname->type);
>> +
>> +	/* Mark ntfs as dirty. It will be cleared at umount. */
>> +	ntfs_set_state(sbi, NTFS_DIRTY_DIRTY);
>> +
>> +	/* Step 1: Remove name from directory. */
>> +	err = indx_delete_entry(&dir_ni->dir, dir_ni, fname, de_key_size, sbi);
>> +	if (err)
>> +		return err;
>> +
>> +	/* Step 2: Remove name from MFT. */
>> +	ni_remove_attr_le(ni, attr_from_name(fname), mi, le);
>> +
>> +	*undo_step = 2;
>> +
>> +	/* Get paired name. */
>> +	fname = ni_fname_type(ni, name_type, &mi, &le);
> 
> It does not feel right that ni_fname_type does not return anything if
> name_type is FILE_NAME_POSIX. It can do it right? Why won't we check
> before ni_fname_type call if name_type == FILE_NAME_POSIX and just exit
> with return 0 if it is.
> 
>> +	if (fname) {
>> +		u16 de2_key_size = fname_full_size(fname);
>> +
>> +		*de2 = Add2Ptr(de, 1024);
>> +		(*de2)->key_size = cpu_to_le16(de2_key_size);
>> +
>> +		memcpy(*de2 + 1, fname, de2_key_size);
>> +
>> +		/* Step 3: Remove paired name from directory. */
>> +		err = indx_delete_entry(&dir_ni->dir, dir_ni, fname,
>> +					de2_key_size, sbi);
>> +		if (err)
>> +			return err;
>> +
>> +		/* Step 4: Remove paired name from MFT. */
>> +		ni_remove_attr_le(ni, attr_from_name(fname), mi, le);
>> +
>> +		*undo_step = 4;
>> +	}
>> +	return 0;
>> +}
>> +
>> +/*
>> + * ni_remove_name_undo - Paired function for ni_remove_name.
>> + *
>> + * Return: True if ok
>> + */
>> +bool ni_remove_name_undo(struct ntfs_inode *dir_ni, struct ntfs_inode *ni,
>> +			 struct NTFS_DE *de, struct NTFS_DE *de2, int undo_step)
>> +{
>> +	struct ntfs_sb_info *sbi = ni->mi.sbi;
>> +	struct ATTRIB *attr;
>> +	u16 de_key_size = de2 ? le16_to_cpu(de2->key_size) : 0;
>> +
>> +	switch (undo_step) {
>> +	case 4:
>> +		if (ni_insert_resident(ni, de_key_size, ATTR_NAME, NULL, 0,
>> +				       &attr, NULL, NULL)) {
>> +			return false;
>> +		}
>> +		memcpy(Add2Ptr(attr, SIZEOF_RESIDENT), de2 + 1, de_key_size);
>> +
>> +		mi_get_ref(&ni->mi, &de2->ref);
>> +		de2->size = cpu_to_le16(ALIGN(de_key_size, 8) +
>> +					sizeof(struct NTFS_DE));
>> +		de2->flags = 0;
>> +		de2->res = 0;
>> +
>> +		if (indx_insert_entry(&dir_ni->dir, dir_ni, de2, sbi, NULL,
>> +				      1)) {
>> +			return false;
>> +		}
>> +		fallthrough;
>> +
>> +	case 2:
>> +		de_key_size = le16_to_cpu(de->key_size);
>> +
>> +		if (ni_insert_resident(ni, de_key_size, ATTR_NAME, NULL, 0,
>> +				       &attr, NULL, NULL)) {
>> +			return false;
>> +		}
>> +
>> +		memcpy(Add2Ptr(attr, SIZEOF_RESIDENT), de + 1, de_key_size);
>> +		mi_get_ref(&ni->mi, &de->ref);
>> +
>> +		if (indx_insert_entry(&dir_ni->dir, dir_ni, de, sbi, NULL, 1)) {
>> +			return false;
>> +		}
>> +	}
>> +
>> +	return true;
>> +}
>> +
>> +/*
>> + * ni_add_name - Add new name in MFT and in directory.
> 
> *to would be better? Also in comments.
> 
>> + */
>> +int ni_add_name(struct ntfs_inode *dir_ni, struct ntfs_inode *ni,
>> +		struct NTFS_DE *de)
>> +{
>> +	int err;
>> +	struct ATTRIB *attr;
>> +	struct ATTR_LIST_ENTRY *le;
>> +	struct mft_inode *mi;
>> +	struct ATTR_FILE_NAME *de_name = (struct ATTR_FILE_NAME *)(de + 1);
>> +	u16 de_key_size = le16_to_cpu(de->key_size);
>> +
>> +	mi_get_ref(&ni->mi, &de->ref);
>> +	mi_get_ref(&dir_ni->mi, &de_name->home);
>> +
>> +	/* Insert new name in MFT. */
>> +	err = ni_insert_resident(ni, de_key_size, ATTR_NAME, NULL, 0, &attr,
>> +				 &mi, &le);
>> +	if (err)
>> +		return err;
>> +
>> +	memcpy(Add2Ptr(attr, SIZEOF_RESIDENT), de_name, de_key_size);
>> +
>> +	/* Insert new name in directory. */
>> +	err = indx_insert_entry(&dir_ni->dir, dir_ni, de, ni->mi.sbi, NULL, 0);
>> +	if (err)
>> +		ni_remove_attr_le(ni, attr, mi, le);
>> +
>> +	return err;
>> +}
>> +
>> +/*
>> + * ni_rename - Remove one name and insert new name.
>> + */
>> +int ni_rename(struct ntfs_inode *dir_ni, struct ntfs_inode *new_dir_ni,
>> +	      struct ntfs_inode *ni, struct NTFS_DE *de, struct NTFS_DE *new_de,
>> +	      bool *is_bad)
>> +{
>> +	int err;
>> +	struct NTFS_DE *de2 = NULL;
>> +	int undo = 0;
>> +
>> +	/*
>> +	 * There are two possible ways to rename:
>> +	 * 1) Add new name and remove old name.
>> +	 * 2) Remove old name and add new name.
>> +	 *
>> +	 * In most cases (not all!) adding new name in MFT and in directory can
>> +	 * allocate additional cluster(s).
>> +	 * Second way may result to bad inode if we can't add new name
>> +	 * and then can't restore (add) old name.
>> +	 */
>> +
>> +	/*
>> +	 * Way 1 - Add new + remove old.
>> +	 */
> 
> Way too big comment for thing this small.
> 
>> +	err = ni_add_name(new_dir_ni, ni, new_de);
> 
> if (err)
> 	return err;
> 
>> +	if (!err) {
>> +		err = ni_remove_name(dir_ni, ni, de, &de2, &undo);
>> +		if (err && ni_remove_name(new_dir_ni, ni, new_de, &de2, &undo))
>> +			*is_bad = true;
> 
> Maybe we can return errno or 1 here. is_bad is again imo little
> unnecessary here. And now that I think this maybe this should be in
> caller site in ntfs_rename. 
> 
>> +	}
>> +
>> +	/*
>> +	 * Way 2 - Remove old + add new.
>> +	 */
>> +	/*
>> +	 *	err = ni_remove_name(dir_ni, ni, de, &de2, &undo);
>> +	 *	if (!err) {
>> +	 *		err = ni_add_name(new_dir_ni, ni, new_de);
>> +	 *		if (err && !ni_remove_name_undo(dir_ni, ni, de, de2, undo))
>> +	 *			*is_bad = true;
>> +	 *	}
>> +	 */
>> +
>> +	return err;
>> +}
>> +
>> +/*
>> + * ni_is_dirty - Return: True if 'ni' requires ni_write_inode.
>> + */
>> +bool ni_is_dirty(struct inode *inode)
>> +{
>> +	struct ntfs_inode *ni = ntfs_i(inode);
>> +	struct rb_node *node;
>> +
>> +	if (ni->mi.dirty || ni->attr_list.dirty ||
>> +	    (ni->ni_flags & NI_FLAG_UPDATE_PARENT))
> 
> No need to save space here. Just another if statment for third one.
> 
>> +		return true;
>> +
>> +	for (node = rb_first(&ni->mi_tree); node; node = rb_next(node)) {
>> +		if (rb_entry(node, struct mft_inode, node)->dirty)
>> +			return true;
>> +	}
>> +
>> +	return false;
>> +}
>> +
>>  /*
>>   * ni_update_parent
>>   *
>> @@ -2802,8 +3028,6 @@ static bool ni_update_parent(struct ntfs_inode *ni, struct NTFS_DUP_INFO *dup,
>>  	struct ntfs_sb_info *sbi = ni->mi.sbi;
>>  	struct super_block *sb = sbi->sb;
>>  	bool re_dirty = false;
>> -	bool active = sb->s_flags & SB_ACTIVE;
>> -	bool upd_parent = ni->ni_flags & NI_FLAG_UPDATE_PARENT;
>>  
>>  	if (ni->mi.mrec->flags & RECORD_FLAG_DIR) {
>>  		dup->fa |= FILE_ATTRIBUTE_DIRECTORY;
>> @@ -2867,19 +3091,9 @@ static bool ni_update_parent(struct ntfs_inode *ni, struct NTFS_DUP_INFO *dup,
>>  		struct ATTR_FILE_NAME *fname;
>>  
>>  		fname = resident_data_ex(attr, SIZEOF_ATTRIBUTE_FILENAME);
>> -		if (!fname)
>> +		if (!fname || !memcmp(&fname->dup, dup, sizeof(fname->dup)))
>>  			continue;
>>  
>> -		if (memcmp(&fname->dup, dup, sizeof(fname->dup))) {
>> -			memcpy(&fname->dup, dup, sizeof(fname->dup));
>> -			mi->dirty = true;
>> -		} else if (!upd_parent) {
>> -			continue;
>> -		}
>> -
>> -		if (!active)
>> -			continue; /* Avoid __wait_on_freeing_inode(inode); */
>> -
>>  		/* ntfs_iget5 may sleep. */
>>  		dir = ntfs_iget5(sb, &fname->home, NULL);
>>  		if (IS_ERR(dir)) {
>> @@ -2898,6 +3112,8 @@ static bool ni_update_parent(struct ntfs_inode *ni, struct NTFS_DUP_INFO *dup,
>>  			} else {
>>  				indx_update_dup(dir_ni, sbi, fname, dup, sync);
>>  				ni_unlock(dir_ni);
>> +				memcpy(&fname->dup, dup, sizeof(fname->dup));
>> +				mi->dirty = true;
>>  			}
>>  		}
>>  		iput(dir);
>> @@ -2969,7 +3185,9 @@ int ni_write_inode(struct inode *inode, int sync, const char *hint)
>>  			ni->mi.dirty = true;
>>  
>>  		if (!ntfs_is_meta_file(sbi, inode->i_ino) &&
>> -		    (modified || (ni->ni_flags & NI_FLAG_UPDATE_PARENT))) {
>> +		    (modified || (ni->ni_flags & NI_FLAG_UPDATE_PARENT))
>> +		    /* Avoid __wait_on_freeing_inode(inode). */
>> +		    && (sb->s_flags & SB_ACTIVE)) {
>>  			dup.cr_time = std->cr_time;
>>  			/* Not critical if this function fail. */
>>  			re_dirty = ni_update_parent(ni, &dup, sync);
>> @@ -3033,7 +3251,7 @@ int ni_write_inode(struct inode *inode, int sync, const char *hint)
>>  		return err;
>>  	}
>>  
>> -	if (re_dirty && (sb->s_flags & SB_ACTIVE))
>> +	if (re_dirty)
>>  		mark_inode_dirty_sync(inode);
>>  
>>  	return 0;
>> diff --git a/fs/ntfs3/fsntfs.c b/fs/ntfs3/fsntfs.c
>> index 0edb95ed9717..669249439217 100644
>> --- a/fs/ntfs3/fsntfs.c
>> +++ b/fs/ntfs3/fsntfs.c
>> @@ -358,29 +358,25 @@ int ntfs_look_for_free_space(struct ntfs_sb_info *sbi, CLST lcn, CLST len,
>>  			     enum ALLOCATE_OPT opt)
>>  {
>>  	int err;
>> +	CLST alen = 0;
>>  	struct super_block *sb = sbi->sb;
>> -	size_t a_lcn, zlen, zeroes, zlcn, zlen2, ztrim, new_zlen;
>> +	size_t alcn, zlen, zeroes, zlcn, zlen2, ztrim, new_zlen;
>>  	struct wnd_bitmap *wnd = &sbi->used.bitmap;
>>  
>>  	down_write_nested(&wnd->rw_lock, BITMAP_MUTEX_CLUSTERS);
>>  	if (opt & ALLOCATE_MFT) {
>> -		CLST alen;
>> -
>>  		zlen = wnd_zone_len(wnd);
>>  
>>  		if (!zlen) {
>>  			err = ntfs_refresh_zone(sbi);
>>  			if (err)
>>  				goto out;
> 
> Before we return this error code. Now we return -ENOSPC if this error.
> 
>> -
>>  			zlen = wnd_zone_len(wnd);
>> +		}
>>  
>> -			if (!zlen) {
>> -				ntfs_err(sbi->sb,
>> -					 "no free space to extend mft");
>> -				err = -ENOSPC;
>> -				goto out;
>> -			}
>> +		if (!zlen) {
>> +			ntfs_err(sbi->sb, "no free space to extend mft");
>> +			goto out;
> 
> This is just refactoring and should do in different patch.
> 
>>  		}
>>  
>>  		lcn = wnd_zone_bit(wnd);
>> @@ -389,14 +385,13 @@ int ntfs_look_for_free_space(struct ntfs_sb_info *sbi, CLST lcn, CLST len,
>>  		wnd_zone_set(wnd, lcn + alen, zlen - alen);
>>  
>>  		err = wnd_set_used(wnd, lcn, alen);
>> -		if (err)
>> -			goto out;
>> -
>> -		*new_lcn = lcn;
>> -		*new_len = alen;
>> -		goto ok;
>> +		if (err) {
>> +			up_write(&wnd->rw_lock);
>> +			return err;
>> +		}
>> +		alcn = lcn;
>> +		goto out;
>>  	}
>> -
>>  	/*
>>  	 * 'Cause cluster 0 is always used this value means that we should use
>>  	 * cached value of 'next_free_lcn' to improve performance.
>> @@ -407,22 +402,17 @@ int ntfs_look_for_free_space(struct ntfs_sb_info *sbi, CLST lcn, CLST len,
>>  	if (lcn >= wnd->nbits)
>>  		lcn = 0;
>>  
>> -	*new_len = wnd_find(wnd, len, lcn, BITMAP_FIND_MARK_AS_USED, &a_lcn);
>> -	if (*new_len) {
>> -		*new_lcn = a_lcn;
>> -		goto ok;
>> -	}
>> +	alen = wnd_find(wnd, len, lcn, BITMAP_FIND_MARK_AS_USED, &alcn);
>> +	if (alen)
>> +		goto out;
>>  
>>  	/* Try to use clusters from MftZone. */
>>  	zlen = wnd_zone_len(wnd);
>>  	zeroes = wnd_zeroes(wnd);
>>  
>> -	/* Check too big request. */
>> -	if (len > zeroes + zlen)
>> -		goto no_space;
>> -
>> -	if (zlen <= NTFS_MIN_MFT_ZONE)
>> -		goto no_space;
>> +	/* Check too big request */
>> +	if (len > zeroes + zlen || zlen <= NTFS_MIN_MFT_ZONE)
>> +		goto out;
>>  
>>  	/* How many clusters to cat from zone. */
>>  	zlcn = wnd_zone_bit(wnd);
>> @@ -439,31 +429,24 @@ int ntfs_look_for_free_space(struct ntfs_sb_info *sbi, CLST lcn, CLST len,
>>  	wnd_zone_set(wnd, zlcn, new_zlen);
>>  
>>  	/* Allocate continues clusters. */
>> -	*new_len =
>> -		wnd_find(wnd, len, 0,
>> -			 BITMAP_FIND_MARK_AS_USED | BITMAP_FIND_FULL, &a_lcn);
>> -	if (*new_len) {
>> -		*new_lcn = a_lcn;
>> -		goto ok;
>> -	}
>> -
>> -no_space:
>> -	up_write(&wnd->rw_lock);
>> -
>> -	return -ENOSPC;
>> -
>> -ok:
>> -	err = 0;
>> +	alen = wnd_find(wnd, len, 0,
>> +			BITMAP_FIND_MARK_AS_USED | BITMAP_FIND_FULL, &alcn);
>>  
>> -	ntfs_unmap_meta(sb, *new_lcn, *new_len);
>> +out:
>> +	if (alen) {
> 
> Just use more goto if needed. This is hard to follow when we come here
> and when not.
> 
>> +		err = 0;
>> +		*new_len = alen;
>> +		*new_lcn = alcn;
>>  
>> -	if (opt & ALLOCATE_MFT)
>> -		goto out;
>> +		ntfs_unmap_meta(sb, alcn, alen);
>>  
>> -	/* Set hint for next requests. */
>> -	sbi->used.next_free_lcn = *new_lcn + *new_len;
>> +		/* Set hint for next requests. */
>> +		if (!(opt & ALLOCATE_MFT))
>> +			sbi->used.next_free_lcn = alcn + alen;
>> +	} else {
>> +		err = -ENOSPC;
>> +	}
>>  
>> -out:
> 
> Example here 
> 
> err_up_write:
> 
> and you can use that for many place
> 
>>  	up_write(&wnd->rw_lock);
>>  	return err;
>>  }
>> @@ -2226,7 +2209,7 @@ int ntfs_insert_security(struct ntfs_sb_info *sbi,
>>  	sii_e.sec_id = d_security->key.sec_id;
>>  	memcpy(&sii_e.sec_hdr, d_security, SIZEOF_SECURITY_HDR);
>>  
>> -	err = indx_insert_entry(indx_sii, ni, &sii_e.de, NULL, NULL);
>> +	err = indx_insert_entry(indx_sii, ni, &sii_e.de, NULL, NULL, 0);
>>  	if (err)
>>  		goto out;
>>  
>> @@ -2247,7 +2230,7 @@ int ntfs_insert_security(struct ntfs_sb_info *sbi,
>>  
>>  	fnd_clear(fnd_sdh);
>>  	err = indx_insert_entry(indx_sdh, ni, &sdh_e.de, (void *)(size_t)1,
>> -				fnd_sdh);
>> +				fnd_sdh, 0);
>>  	if (err)
>>  		goto out;
>>  
>> @@ -2385,7 +2368,7 @@ int ntfs_insert_reparse(struct ntfs_sb_info *sbi, __le32 rtag,
>>  
>>  	mutex_lock_nested(&ni->ni_lock, NTFS_INODE_MUTEX_REPARSE);
>>  
>> -	err = indx_insert_entry(indx, ni, &re.de, NULL, NULL);
>> +	err = indx_insert_entry(indx, ni, &re.de, NULL, NULL, 0);
>>  
>>  	mark_inode_dirty(&ni->vfs_inode);
>>  	ni_unlock(ni);
>> diff --git a/fs/ntfs3/index.c b/fs/ntfs3/index.c
>> index 70ef59455b72..1224b8e42b3e 100644
>> --- a/fs/ntfs3/index.c
>> +++ b/fs/ntfs3/index.c
>> @@ -1427,7 +1427,7 @@ static int indx_create_allocate(struct ntfs_index *indx, struct ntfs_inode *ni,
>>  	alloc->nres.valid_size = alloc->nres.data_size = cpu_to_le64(data_size);
>>  
>>  	err = ni_insert_resident(ni, bitmap_size(1), ATTR_BITMAP, in->name,
>> -				 in->name_len, &bitmap, NULL);
>> +				 in->name_len, &bitmap, NULL, NULL);
>>  	if (err)
>>  		goto out2;
>>  
>> @@ -1443,7 +1443,7 @@ static int indx_create_allocate(struct ntfs_index *indx, struct ntfs_inode *ni,
>>  	return 0;
>>  
>>  out2:
>> -	mi_remove_attr(&ni->mi, alloc);
>> +	mi_remove_attr(NULL, &ni->mi, alloc);
>>  
>>  out1:
>>  	run_deallocate(sbi, &run, false);
>> @@ -1529,24 +1529,24 @@ static int indx_add_allocate(struct ntfs_index *indx, struct ntfs_inode *ni,
>>  /*
>>   * indx_insert_into_root - Attempt to insert an entry into the index root.
>>   *
>> + * @undo - True if we undoing previous remove.
>>   * If necessary, it will twiddle the index b-tree.
>>   */
>>  static int indx_insert_into_root(struct ntfs_index *indx, struct ntfs_inode *ni,
>>  				 const struct NTFS_DE *new_de,
>>  				 struct NTFS_DE *root_de, const void *ctx,
>> -				 struct ntfs_fnd *fnd)
>> +				 struct ntfs_fnd *fnd, bool undo)
>>  {
>>  	int err = 0;
>>  	struct NTFS_DE *e, *e0, *re;
>>  	struct mft_inode *mi;
>>  	struct ATTRIB *attr;
>> -	struct MFT_REC *rec;
>>  	struct INDEX_HDR *hdr;
>>  	struct indx_node *n;
>>  	CLST new_vbn;
>>  	__le64 *sub_vbn, t_vbn;
>>  	u16 new_de_size;
>> -	u32 hdr_used, hdr_total, asize, used, to_move;
>> +	u32 hdr_used, hdr_total, asize, to_move;
>>  	u32 root_size, new_root_size;
>>  	struct ntfs_sb_info *sbi;
>>  	int ds_root;
>> @@ -1559,12 +1559,11 @@ static int indx_insert_into_root(struct ntfs_index *indx, struct ntfs_inode *ni,
>>  
>>  	/*
>>  	 * Try easy case:
>> -	 * hdr_insert_de will succeed if there's room the root for the new entry.
>> +	 * hdr_insert_de will succeed if there's
>> +	 * room the root for the new entry.
> 
> Not relevant for this patch.
> 
>>  	 */
>>  	hdr = &root->ihdr;
>>  	sbi = ni->mi.sbi;
>> -	rec = mi->mrec;
>> -	used = le32_to_cpu(rec->used);
>>  	new_de_size = le16_to_cpu(new_de->size);
>>  	hdr_used = le32_to_cpu(hdr->used);
>>  	hdr_total = le32_to_cpu(hdr->total);
>> @@ -1573,9 +1572,9 @@ static int indx_insert_into_root(struct ntfs_index *indx, struct ntfs_inode *ni,
>>  
>>  	ds_root = new_de_size + hdr_used - hdr_total;
>>  
>> -	if (used + ds_root < sbi->max_bytes_per_attr) {
>> -		/* Make a room for new elements. */
>> -		mi_resize_attr(mi, attr, ds_root);
>> +	/* If 'undo' is set then reduce requirements. */
>> +	if ((undo || asize + ds_root < sbi->max_bytes_per_attr) &&
>> +	    mi_resize_attr(mi, attr, ds_root)) {
>>  		hdr->total = cpu_to_le32(hdr_total + ds_root);
>>  		e = hdr_insert_de(indx, hdr, new_de, root_de, ctx);
>>  		WARN_ON(!e);
>> @@ -1629,7 +1628,7 @@ static int indx_insert_into_root(struct ntfs_index *indx, struct ntfs_inode *ni,
>>  			sizeof(u64);
>>  	ds_root = new_root_size - root_size;
>>  
>> -	if (ds_root > 0 && used + ds_root > sbi->max_bytes_per_attr) {
>> +	if (ds_root > 0 && asize + ds_root > sbi->max_bytes_per_attr) {
>>  		/* Make root external. */
>>  		err = -EOPNOTSUPP;
>>  		goto out_free_re;
>> @@ -1710,7 +1709,7 @@ static int indx_insert_into_root(struct ntfs_index *indx, struct ntfs_inode *ni,
>>  
>>  		put_indx_node(n);
>>  		fnd_clear(fnd);
>> -		err = indx_insert_entry(indx, ni, new_de, ctx, fnd);
>> +		err = indx_insert_entry(indx, ni, new_de, ctx, fnd, undo);
>>  		goto out_free_root;
>>  	}
>>  
>> @@ -1854,7 +1853,7 @@ indx_insert_into_buffer(struct ntfs_index *indx, struct ntfs_inode *ni,
>>  	 */
>>  	if (!level) {
>>  		/* Insert in root. */
>> -		err = indx_insert_into_root(indx, ni, up_e, NULL, ctx, fnd);
>> +		err = indx_insert_into_root(indx, ni, up_e, NULL, ctx, fnd, 0);
>>  		if (err)
>>  			goto out;
>>  	} else {
>> @@ -1876,10 +1875,12 @@ indx_insert_into_buffer(struct ntfs_index *indx, struct ntfs_inode *ni,
>>  
>>  /*
>>   * indx_insert_entry - Insert new entry into index.
>> + *
>> + * @undo - True if we undoing previous remove.
>>   */
>>  int indx_insert_entry(struct ntfs_index *indx, struct ntfs_inode *ni,
>>  		      const struct NTFS_DE *new_de, const void *ctx,
>> -		      struct ntfs_fnd *fnd)
>> +		      struct ntfs_fnd *fnd, bool undo)
>>  {
>>  	int err;
>>  	int diff;
>> @@ -1925,7 +1926,7 @@ int indx_insert_entry(struct ntfs_index *indx, struct ntfs_inode *ni,
>>  		 * new entry into it.
>>  		 */
>>  		err = indx_insert_into_root(indx, ni, new_de, fnd->root_de, ctx,
>> -					    fnd);
>> +					    fnd, undo);
>>  		if (err)
>>  			goto out;
>>  	} else {
>> @@ -2302,7 +2303,7 @@ int indx_delete_entry(struct ntfs_index *indx, struct ntfs_inode *ni,
>>  							      fnd->level - 1,
>>  							      fnd)
>>  				    : indx_insert_into_root(indx, ni, re, e,
>> -							    ctx, fnd);
>> +							    ctx, fnd, 0);
>>  			kfree(re);
>>  
>>  			if (err)
>> @@ -2507,7 +2508,7 @@ int indx_delete_entry(struct ntfs_index *indx, struct ntfs_inode *ni,
>>  		 * Re-insert the entry into the tree.
>>  		 * Find the spot the tree where we want to insert the new entry.
>>  		 */
>> -		err = indx_insert_entry(indx, ni, me, ctx, fnd);
>> +		err = indx_insert_entry(indx, ni, me, ctx, fnd, 0);
>>  		kfree(me);
>>  		if (err)
>>  			goto out;
>> @@ -2595,10 +2596,8 @@ int indx_update_dup(struct ntfs_inode *ni, struct ntfs_sb_info *sbi,
>>  	struct ntfs_index *indx = &ni->dir;
>>  
>>  	fnd = fnd_get();
>> -	if (!fnd) {
>> -		err = -ENOMEM;
>> -		goto out1;
>> -	}
>> +	if (!fnd)
>> +		return -ENOMEM;
>>  
>>  	root = indx_get_root(indx, ni, NULL, &mi);
>>  	if (!root) {
>> @@ -2645,7 +2644,5 @@ int indx_update_dup(struct ntfs_inode *ni, struct ntfs_sb_info *sbi,
>>  
>>  out:
>>  	fnd_put(fnd);
>> -
>> -out1:
>>  	return err;
>>  }
>> diff --git a/fs/ntfs3/inode.c b/fs/ntfs3/inode.c
>> index b86ec7dd731c..8f72066b3229 100644
>> --- a/fs/ntfs3/inode.c
>> +++ b/fs/ntfs3/inode.c
>> @@ -399,6 +399,12 @@ static struct inode *ntfs_read_mft(struct inode *inode,
>>  		goto out;
>>  	}
>>  
>> +	if (names != le16_to_cpu(rec->hard_links)) {
>> +		/* Correct minor error on the fly. Do not mark inode as dirty. */
>> +		rec->hard_links = cpu_to_le16(names);
>> +		ni->mi.dirty = true;
>> +	}
>> +
>>  	set_nlink(inode, names);
>>  
>>  	if (S_ISDIR(mode)) {
>> @@ -1279,6 +1285,7 @@ struct inode *ntfs_create_inode(struct user_namespace *mnt_userns,
>>  	}
>>  	inode = &ni->vfs_inode;
>>  	inode_init_owner(mnt_userns, inode, dir, mode);
>> +	mode = inode->i_mode;
>>  
>>  	inode->i_atime = inode->i_mtime = inode->i_ctime = ni->i_crtime =
>>  		current_time(inode);
>> @@ -1371,6 +1378,7 @@ struct inode *ntfs_create_inode(struct user_namespace *mnt_userns,
>>  		attr = Add2Ptr(attr, asize);
>>  	}
>>  
>> +	attr->id = cpu_to_le16(aid++);
>>  	if (fa & FILE_ATTRIBUTE_DIRECTORY) {
>>  		/*
>>  		 * Regular directory or symlink to directory.
>> @@ -1381,7 +1389,6 @@ struct inode *ntfs_create_inode(struct user_namespace *mnt_userns,
>>  
>>  		attr->type = ATTR_ROOT;
>>  		attr->size = cpu_to_le32(asize);
>> -		attr->id = cpu_to_le16(aid++);
>>  
>>  		attr->name_len = ARRAY_SIZE(I30_NAME);
>>  		attr->name_off = SIZEOF_RESIDENT_LE;
>> @@ -1412,52 +1419,46 @@ struct inode *ntfs_create_inode(struct user_namespace *mnt_userns,
>>  		/* Insert empty ATTR_DATA */
>>  		attr->type = ATTR_DATA;
>>  		attr->size = cpu_to_le32(SIZEOF_RESIDENT);
>> -		attr->id = cpu_to_le16(aid++);
>>  		attr->name_off = SIZEOF_RESIDENT_LE;
>>  		attr->res.data_off = SIZEOF_RESIDENT_LE;
>> -	} else {
>> +	} else if (S_ISREG(mode)) {
> 
> This should definetly be own patch. Way too much noice. And yes I think
> this is a good change but if this is in this patch then how do we see
> what is relevant?
> 
>>  		/*
>> -		 * Regular file or node.
>> +		 * Regular file. Create empty non resident data attribute.
>>  		 */
>>  		attr->type = ATTR_DATA;
>> -		attr->id = cpu_to_le16(aid++);
>> -
>> -		if (S_ISREG(mode)) {
>> -			/* Create empty non resident data attribute. */
>> -			attr->non_res = 1;
>> -			attr->nres.evcn = cpu_to_le64(-1ll);
>> -			if (fa & FILE_ATTRIBUTE_SPARSE_FILE) {
>> -				attr->size =
>> -					cpu_to_le32(SIZEOF_NONRESIDENT_EX + 8);
>> -				attr->name_off = SIZEOF_NONRESIDENT_EX_LE;
>> -				attr->flags = ATTR_FLAG_SPARSED;
>> -				asize = SIZEOF_NONRESIDENT_EX + 8;
>> -			} else if (fa & FILE_ATTRIBUTE_COMPRESSED) {
>> -				attr->size =
>> -					cpu_to_le32(SIZEOF_NONRESIDENT_EX + 8);
>> -				attr->name_off = SIZEOF_NONRESIDENT_EX_LE;
>> -				attr->flags = ATTR_FLAG_COMPRESSED;
>> -				attr->nres.c_unit = COMPRESSION_UNIT;
>> -				asize = SIZEOF_NONRESIDENT_EX + 8;
>> -			} else {
>> -				attr->size =
>> -					cpu_to_le32(SIZEOF_NONRESIDENT + 8);
>> -				attr->name_off = SIZEOF_NONRESIDENT_LE;
>> -				asize = SIZEOF_NONRESIDENT + 8;
>> -			}
>> -			attr->nres.run_off = attr->name_off;
>> +		attr->non_res = 1;
>> +		attr->nres.evcn = cpu_to_le64(-1ll);
>> +		if (fa & FILE_ATTRIBUTE_SPARSE_FILE) {
>> +			attr->size = cpu_to_le32(SIZEOF_NONRESIDENT_EX + 8);
>> +			attr->name_off = SIZEOF_NONRESIDENT_EX_LE;
>> +			attr->flags = ATTR_FLAG_SPARSED;
>> +			asize = SIZEOF_NONRESIDENT_EX + 8;
>> +		} else if (fa & FILE_ATTRIBUTE_COMPRESSED) {
>> +			attr->size = cpu_to_le32(SIZEOF_NONRESIDENT_EX + 8);
>> +			attr->name_off = SIZEOF_NONRESIDENT_EX_LE;
>> +			attr->flags = ATTR_FLAG_COMPRESSED;
>> +			attr->nres.c_unit = COMPRESSION_UNIT;
>> +			asize = SIZEOF_NONRESIDENT_EX + 8;
>>  		} else {
>> -			/* Create empty resident data attribute. */
>> -			attr->size = cpu_to_le32(SIZEOF_RESIDENT);
>> -			attr->name_off = SIZEOF_RESIDENT_LE;
>> -			if (fa & FILE_ATTRIBUTE_SPARSE_FILE)
>> -				attr->flags = ATTR_FLAG_SPARSED;
>> -			else if (fa & FILE_ATTRIBUTE_COMPRESSED)
>> -				attr->flags = ATTR_FLAG_COMPRESSED;
>> -			attr->res.data_off = SIZEOF_RESIDENT_LE;
>> -			asize = SIZEOF_RESIDENT;
>> -			ni->ni_flags |= NI_FLAG_RESIDENT;
>> +			attr->size = cpu_to_le32(SIZEOF_NONRESIDENT + 8);
>> +			attr->name_off = SIZEOF_NONRESIDENT_LE;
>> +			asize = SIZEOF_NONRESIDENT + 8;
>>  		}
>> +		attr->nres.run_off = attr->name_off;
>> +	} else {
>> +		/*
>> +		 * Node. Create empty resident data attribute.
>> +		 */
>> +		attr->type = ATTR_DATA;
>> +		attr->size = cpu_to_le32(SIZEOF_RESIDENT);
>> +		attr->name_off = SIZEOF_RESIDENT_LE;
>> +		if (fa & FILE_ATTRIBUTE_SPARSE_FILE)
>> +			attr->flags = ATTR_FLAG_SPARSED;
>> +		else if (fa & FILE_ATTRIBUTE_COMPRESSED)
>> +			attr->flags = ATTR_FLAG_COMPRESSED;
>> +		attr->res.data_off = SIZEOF_RESIDENT_LE;
>> +		asize = SIZEOF_RESIDENT;
>> +		ni->ni_flags |= NI_FLAG_RESIDENT;
>>  	}
>>  
>>  	if (S_ISDIR(mode)) {
>> @@ -1485,7 +1486,8 @@ struct inode *ntfs_create_inode(struct user_namespace *mnt_userns,
>>  		asize = ALIGN(SIZEOF_RESIDENT + nsize, 8);
>>  		t16 = PtrOffset(rec, attr);
>>  
>> -		if (asize + t16 + 8 > sbi->record_size) {
>> +		/* 0x78 - the size of EA + EAINFO to store WSL */
>> +		if (asize + t16 + 0x78 + 8 > sbi->record_size) {
>>  			CLST alen;
>>  			CLST clst = bytes_to_cluster(sbi, nsize);
>>  
>> @@ -1545,20 +1547,15 @@ struct inode *ntfs_create_inode(struct user_namespace *mnt_userns,
>>  	rec->next_attr_id = cpu_to_le16(aid);
>>  
>>  	/* Step 2: Add new name in index. */
>> -	err = indx_insert_entry(&dir_ni->dir, dir_ni, new_de, sbi, fnd);
>> +	err = indx_insert_entry(&dir_ni->dir, dir_ni, new_de, sbi, fnd, 0);
>>  	if (err)
>>  		goto out6;
>>  
>> -	/* Update current directory record. */
>> -	mark_inode_dirty(dir);
>> -
> 
> This was also probably just fix it is own?
> 
>>  	inode->i_generation = le16_to_cpu(rec->seq);
>>  
>>  	dir->i_mtime = dir->i_ctime = inode->i_atime;
>>  
>>  	if (S_ISDIR(mode)) {
>> -		if (dir->i_mode & S_ISGID)
>> -			mode |= S_ISGID;
> 
> This also is not relevant for this patch. Yes dead code but not releted
> to this one. This kind of stuff takes lot of reviewers time.
> 
> 
> I do not even feel like i will continue this review. There is just way
> too much stuff and would definetly nack. But as this already is in ntfs3
> master I just don't know what to do. I cc fsdevel so maybe they can help
> a little bit.
> 
> 	Argillander
> 
>>  		inode->i_op = &ntfs_dir_inode_operations;
>>  		inode->i_fop = &ntfs_dir_operations;
>>  	} else if (S_ISLNK(mode)) {
>> @@ -1601,8 +1598,8 @@ struct inode *ntfs_create_inode(struct user_namespace *mnt_userns,
>>  	d_instantiate(dentry, inode);
>>  
>>  	ntfs_save_wsl_perm(inode);
>> -	mark_inode_dirty(inode);
>>  	mark_inode_dirty(dir);
>> +	mark_inode_dirty(inode);
>>  
>>  	/* Normal exit. */
>>  	goto out2;
>> @@ -1646,61 +1643,36 @@ struct inode *ntfs_create_inode(struct user_namespace *mnt_userns,
>>  int ntfs_link_inode(struct inode *inode, struct dentry *dentry)
>>  {
>>  	int err;
>> -	struct inode *dir = d_inode(dentry->d_parent);
>> -	struct ntfs_inode *dir_ni = ntfs_i(dir);
>>  	struct ntfs_inode *ni = ntfs_i(inode);
>> -	struct super_block *sb = inode->i_sb;
>> -	struct ntfs_sb_info *sbi = sb->s_fs_info;
>> -	const struct qstr *name = &dentry->d_name;
>> -	struct NTFS_DE *new_de = NULL;
>> -	struct ATTR_FILE_NAME *fname;
>> -	struct ATTRIB *attr;
>> -	u16 key_size;
>> -	struct INDEX_ROOT *dir_root;
>> -
>> -	dir_root = indx_get_root(&dir_ni->dir, dir_ni, NULL, NULL);
>> -	if (!dir_root)
>> -		return -EINVAL;
>> +	struct ntfs_sb_info *sbi = inode->i_sb->s_fs_info;
>> +	struct NTFS_DE *de;
>> +	struct ATTR_FILE_NAME *de_name;
>>  
>>  	/* Allocate PATH_MAX bytes. */
>> -	new_de = __getname();
>> -	if (!new_de)
>> +	de = __getname();
>> +	if (!de)
>>  		return -ENOMEM;
>>  
>> -	/* Mark rw ntfs as dirty.  It will be cleared at umount. */
>> -	ntfs_set_state(ni->mi.sbi, NTFS_DIRTY_DIRTY);
>> -
>> -	/* Insert file name. */
>> -	err = fill_name_de(sbi, new_de, name, NULL);
>> -	if (err)
>> -		goto out;
>> -
>> -	key_size = le16_to_cpu(new_de->key_size);
>> -	err = ni_insert_resident(ni, key_size, ATTR_NAME, NULL, 0, &attr, NULL);
>> -	if (err)
>> -		goto out;
>> -
>> -	mi_get_ref(&ni->mi, &new_de->ref);
>> -
>> -	fname = (struct ATTR_FILE_NAME *)(new_de + 1);
>> -	mi_get_ref(&dir_ni->mi, &fname->home);
>> -	fname->dup.cr_time = fname->dup.m_time = fname->dup.c_time =
>> -		fname->dup.a_time = kernel2nt(&inode->i_ctime);
>> -	fname->dup.alloc_size = fname->dup.data_size = 0;
>> -	fname->dup.fa = ni->std_fa;
>> -	fname->dup.ea_size = fname->dup.reparse = 0;
>> -
>> -	memcpy(Add2Ptr(attr, SIZEOF_RESIDENT), fname, key_size);
>> +	/* Mark rw ntfs as dirty. It will be cleared at umount. */
>> +	ntfs_set_state(sbi, NTFS_DIRTY_DIRTY);
>>  
>> -	err = indx_insert_entry(&dir_ni->dir, dir_ni, new_de, sbi, NULL);
>> +	/* Construct 'de'. */
>> +	err = fill_name_de(sbi, de, &dentry->d_name, NULL);
>>  	if (err)
>>  		goto out;
>>  
>> -	le16_add_cpu(&ni->mi.mrec->hard_links, 1);
>> -	ni->mi.dirty = true;
>> +	de_name = (struct ATTR_FILE_NAME *)(de + 1);
>> +	/* Fill duplicate info. */
>> +	de_name->dup.cr_time = de_name->dup.m_time = de_name->dup.c_time =
>> +		de_name->dup.a_time = kernel2nt(&inode->i_ctime);
>> +	de_name->dup.alloc_size = de_name->dup.data_size =
>> +		cpu_to_le64(inode->i_size);
>> +	de_name->dup.fa = ni->std_fa;
>> +	de_name->dup.ea_size = de_name->dup.reparse = 0;
>>  
>> +	err = ni_add_name(ntfs_i(d_inode(dentry->d_parent)), ni, de);
>>  out:
>> -	__putname(new_de);
>> +	__putname(de);
>>  	return err;
>>  }
>>  
>> @@ -1713,113 +1685,56 @@ int ntfs_link_inode(struct inode *inode, struct dentry *dentry)
>>  int ntfs_unlink_inode(struct inode *dir, const struct dentry *dentry)
>>  {
>>  	int err;
>> -	struct super_block *sb = dir->i_sb;
>> -	struct ntfs_sb_info *sbi = sb->s_fs_info;
>> +	struct ntfs_sb_info *sbi = dir->i_sb->s_fs_info;
>>  	struct inode *inode = d_inode(dentry);
>>  	struct ntfs_inode *ni = ntfs_i(inode);
>> -	const struct qstr *name = &dentry->d_name;
>>  	struct ntfs_inode *dir_ni = ntfs_i(dir);
>> -	struct ntfs_index *indx = &dir_ni->dir;
>> -	struct cpu_str *uni = NULL;
>> -	struct ATTR_FILE_NAME *fname;
>> -	u8 name_type;
>> -	struct ATTR_LIST_ENTRY *le;
>> -	struct MFT_REF ref;
>> -	bool is_dir = S_ISDIR(inode->i_mode);
>> -	struct INDEX_ROOT *dir_root;
>> +	struct NTFS_DE *de, *de2 = NULL;
>> +	int undo_remove;
>>  
>> -	dir_root = indx_get_root(indx, dir_ni, NULL, NULL);
>> -	if (!dir_root)
>> +	if (ntfs_is_meta_file(sbi, ni->mi.rno))
>>  		return -EINVAL;
>>  
>> +	/* Allocate PATH_MAX bytes. */
>> +	de = __getname();
>> +	if (!de)
>> +		return -ENOMEM;
>> +
>>  	ni_lock(ni);
>>  
>> -	if (is_dir && !dir_is_empty(inode)) {
>> +	if (S_ISDIR(inode->i_mode) && !dir_is_empty(inode)) {
>>  		err = -ENOTEMPTY;
>> -		goto out1;
>> -	}
>> -
>> -	if (ntfs_is_meta_file(sbi, inode->i_ino)) {
>> -		err = -EINVAL;
>> -		goto out1;
>> -	}
>> -
>> -	/* Allocate PATH_MAX bytes. */
>> -	uni = __getname();
>> -	if (!uni) {
>> -		err = -ENOMEM;
>> -		goto out1;
>> +		goto out;
>>  	}
>>  
>> -	/* Convert input string to unicode. */
>> -	err = ntfs_nls_to_utf16(sbi, name->name, name->len, uni, NTFS_NAME_LEN,
>> -				UTF16_HOST_ENDIAN);
>> +	err = fill_name_de(sbi, de, &dentry->d_name, NULL);
>>  	if (err < 0)
>> -		goto out2;
>> -
>> -	/* Mark rw ntfs as dirty.  It will be cleared at umount. */
>> -	ntfs_set_state(sbi, NTFS_DIRTY_DIRTY);
>> -
>> -	/* Find name in record. */
>> -	mi_get_ref(&dir_ni->mi, &ref);
>> -
>> -	le = NULL;
>> -	fname = ni_fname_name(ni, uni, &ref, &le);
>> -	if (!fname) {
>> -		err = -ENOENT;
>> -		goto out3;
>> -	}
>> -
>> -	name_type = paired_name(fname->type);
>> -
>> -	err = indx_delete_entry(indx, dir_ni, fname, fname_full_size(fname),
>> -				sbi);
>> -	if (err)
>> -		goto out3;
>> -
>> -	/* Then remove name from MFT. */
>> -	ni_remove_attr_le(ni, attr_from_name(fname), le);
>> -
>> -	le16_add_cpu(&ni->mi.mrec->hard_links, -1);
>> -	ni->mi.dirty = true;
>> -
>> -	if (name_type != FILE_NAME_POSIX) {
>> -		/* Now we should delete name by type. */
>> -		fname = ni_fname_type(ni, name_type, &le);
>> -		if (fname) {
>> -			err = indx_delete_entry(indx, dir_ni, fname,
>> -						fname_full_size(fname), sbi);
>> -			if (err)
>> -				goto out3;
>> +		goto out;
>>  
>> -			ni_remove_attr_le(ni, attr_from_name(fname), le);
>> +	undo_remove = 0;
>> +	err = ni_remove_name(dir_ni, ni, de, &de2, &undo_remove);
>>  
>> -			le16_add_cpu(&ni->mi.mrec->hard_links, -1);
>> -		}
>> -	}
>> -out3:
>> -	switch (err) {
>> -	case 0:
>> +	if (!err) {
>>  		drop_nlink(inode);
>> -		break;
>> -	case -ENOTEMPTY:
>> -	case -ENOSPC:
>> -	case -EROFS:
>> -		break;
>> -	default:
>> +		dir->i_mtime = dir->i_ctime = current_time(dir);
>> +		mark_inode_dirty(dir);
>> +		inode->i_ctime = dir->i_ctime;
>> +		if (inode->i_nlink)
>> +			mark_inode_dirty(inode);
>> +	} else if (!ni_remove_name_undo(dir_ni, ni, de, de2, undo_remove)) {
>>  		make_bad_inode(inode);
>> +		ntfs_inode_err(inode, "failed to undo unlink");
>> +		ntfs_set_state(sbi, NTFS_DIRTY_ERROR);
>> +	} else {
>> +		if (ni_is_dirty(dir))
>> +			mark_inode_dirty(dir);
>> +		if (ni_is_dirty(inode))
>> +			mark_inode_dirty(inode);
>>  	}
>>  
>> -	dir->i_mtime = dir->i_ctime = current_time(dir);
>> -	mark_inode_dirty(dir);
>> -	inode->i_ctime = dir->i_ctime;
>> -	if (inode->i_nlink)
>> -		mark_inode_dirty(inode);
>> -
>> -out2:
>> -	__putname(uni);
>> -out1:
>> +out:
>>  	ni_unlock(ni);
>> +	__putname(de);
>>  	return err;
>>  }
>>  
>> diff --git a/fs/ntfs3/namei.c b/fs/ntfs3/namei.c
>> index f79a399bd015..e58415d07132 100644
>> --- a/fs/ntfs3/namei.c
>> +++ b/fs/ntfs3/namei.c
>> @@ -152,12 +152,14 @@ static int ntfs_link(struct dentry *ode, struct inode *dir, struct dentry *de)
>>  	if (inode != dir)
>>  		ni_lock(ni);
>>  
>> -	dir->i_ctime = dir->i_mtime = inode->i_ctime = current_time(inode);
>>  	inc_nlink(inode);
>>  	ihold(inode);
>>  
>>  	err = ntfs_link_inode(inode, de);
>> +
>>  	if (!err) {
>> +		dir->i_ctime = dir->i_mtime = inode->i_ctime =
>> +			current_time(dir);
>>  		mark_inode_dirty(inode);
>>  		mark_inode_dirty(dir);
>>  		d_instantiate(de, inode);
>> @@ -249,25 +251,26 @@ static int ntfs_rmdir(struct inode *dir, struct dentry *dentry)
>>  /*
>>   * ntfs_rename - inode_operations::rename
>>   */
>> -static int ntfs_rename(struct user_namespace *mnt_userns, struct inode *old_dir,
>> -		       struct dentry *old_dentry, struct inode *new_dir,
>> +static int ntfs_rename(struct user_namespace *mnt_userns, struct inode *dir,
>> +		       struct dentry *dentry, struct inode *new_dir,
>>  		       struct dentry *new_dentry, u32 flags)
>>  {
>>  	int err;
>> -	struct super_block *sb = old_dir->i_sb;
>> +	struct super_block *sb = dir->i_sb;
>>  	struct ntfs_sb_info *sbi = sb->s_fs_info;
>> -	struct ntfs_inode *old_dir_ni = ntfs_i(old_dir);
>> +	struct ntfs_inode *dir_ni = ntfs_i(dir);
>>  	struct ntfs_inode *new_dir_ni = ntfs_i(new_dir);
>> -	struct ntfs_inode *old_ni;
>> -	struct ATTR_FILE_NAME *old_name, *new_name, *fname;
>> -	u8 name_type;
>> -	bool is_same;
>> -	struct inode *old_inode, *new_inode;
>> -	struct NTFS_DE *old_de, *new_de;
>> -	struct ATTRIB *attr;
>> -	struct ATTR_LIST_ENTRY *le;
>> -	u16 new_de_key_size;
>> -
>> +	struct inode *inode = d_inode(dentry);
>> +	struct ntfs_inode *ni = ntfs_i(inode);
>> +	struct inode *new_inode = d_inode(new_dentry);
>> +	struct NTFS_DE *de, *new_de;
>> +	bool is_same, is_bad;
>> +	/*
>> +	 * de		- memory of PATH_MAX bytes:
>> +	 * [0-1024)	- original name (dentry->d_name)
>> +	 * [1024-2048)	- paired to original name, usually DOS variant of dentry->d_name
>> +	 * [2048-3072)	- new name (new_dentry->d_name)
>> +	 */
>>  	static_assert(SIZEOF_ATTRIBUTE_FILENAME_MAX + SIZEOF_RESIDENT < 1024);
>>  	static_assert(SIZEOF_ATTRIBUTE_FILENAME_MAX + sizeof(struct NTFS_DE) <
>>  		      1024);
>> @@ -276,24 +279,18 @@ static int ntfs_rename(struct user_namespace *mnt_userns, struct inode *old_dir,
>>  	if (flags & ~RENAME_NOREPLACE)
>>  		return -EINVAL;
>>  
>> -	old_inode = d_inode(old_dentry);
>> -	new_inode = d_inode(new_dentry);
>> -
>> -	old_ni = ntfs_i(old_inode);
>> +	is_same = dentry->d_name.len == new_dentry->d_name.len &&
>> +		  !memcmp(dentry->d_name.name, new_dentry->d_name.name,
>> +			  dentry->d_name.len);
>>  
>> -	is_same = old_dentry->d_name.len == new_dentry->d_name.len &&
>> -		  !memcmp(old_dentry->d_name.name, new_dentry->d_name.name,
>> -			  old_dentry->d_name.len);
>> -
>> -	if (is_same && old_dir == new_dir) {
>> +	if (is_same && dir == new_dir) {
>>  		/* Nothing to do. */
>> -		err = 0;
>> -		goto out;
>> +		return 0;
>>  	}
>>  
>> -	if (ntfs_is_meta_file(sbi, old_inode->i_ino)) {
>> -		err = -EINVAL;
>> -		goto out;
>> +	if (ntfs_is_meta_file(sbi, inode->i_ino)) {
>> +		/* Should we print an error? */
>> +		return -EINVAL;
>>  	}
>>  
>>  	if (new_inode) {
>> @@ -304,168 +301,61 @@ static int ntfs_rename(struct user_namespace *mnt_userns, struct inode *old_dir,
>>  		ni_unlock(new_dir_ni);
>>  		dput(new_dentry);
>>  		if (err)
>> -			goto out;
>> +			return err;
>>  	}
>>  
>>  	/* Allocate PATH_MAX bytes. */
>> -	old_de = __getname();
>> -	if (!old_de) {
>> -		err = -ENOMEM;
>> -		goto out;
>> -	}
>> +	de = __getname();
>> +	if (!de)
>> +		return -ENOMEM;
>>  
>> -	err = fill_name_de(sbi, old_de, &old_dentry->d_name, NULL);
>> +	/* Translate dentry->d_name into unicode form. */
>> +	err = fill_name_de(sbi, de, &dentry->d_name, NULL);
>>  	if (err < 0)
>> -		goto out1;
>> -
>> -	old_name = (struct ATTR_FILE_NAME *)(old_de + 1);
>> +		goto out;
>>  
>>  	if (is_same) {
>> -		new_de = old_de;
>> +		/* Reuse 'de'. */
>> +		new_de = de;
>>  	} else {
>> -		new_de = Add2Ptr(old_de, 1024);
>> +		/* Translate new_dentry->d_name into unicode form. */
>> +		new_de = Add2Ptr(de, 2048);
>>  		err = fill_name_de(sbi, new_de, &new_dentry->d_name, NULL);
>>  		if (err < 0)
>> -			goto out1;
>> -	}
>> -
>> -	ni_lock_dir(old_dir_ni);
>> -	ni_lock(old_ni);
>> -
>> -	mi_get_ref(&old_dir_ni->mi, &old_name->home);
>> -
>> -	/* Get pointer to file_name in MFT. */
>> -	fname = ni_fname_name(old_ni, (struct cpu_str *)&old_name->name_len,
>> -			      &old_name->home, &le);
>> -	if (!fname) {
>> -		err = -EINVAL;
>> -		goto out2;
>> +			goto out;
>>  	}
>>  
>> -	/* Copy fname info from record into new fname. */
>> -	new_name = (struct ATTR_FILE_NAME *)(new_de + 1);
>> -	memcpy(&new_name->dup, &fname->dup, sizeof(fname->dup));
>> -
>> -	name_type = paired_name(fname->type);
>> -
>> -	/* Remove first name from directory. */
>> -	err = indx_delete_entry(&old_dir_ni->dir, old_dir_ni, old_de + 1,
>> -				le16_to_cpu(old_de->key_size), sbi);
>> -	if (err)
>> -		goto out3;
>> -
>> -	/* Remove first name from MFT. */
>> -	err = ni_remove_attr_le(old_ni, attr_from_name(fname), le);
>> -	if (err)
>> -		goto out4;
>> -
>> -	le16_add_cpu(&old_ni->mi.mrec->hard_links, -1);
>> -	old_ni->mi.dirty = true;
>> -
>> -	if (name_type != FILE_NAME_POSIX) {
>> -		/* Get paired name. */
>> -		fname = ni_fname_type(old_ni, name_type, &le);
>> -		if (fname) {
>> -			/* Remove second name from directory. */
>> -			err = indx_delete_entry(&old_dir_ni->dir, old_dir_ni,
>> -						fname, fname_full_size(fname),
>> -						sbi);
>> -			if (err)
>> -				goto out5;
>> -
>> -			/* Remove second name from MFT. */
>> -			err = ni_remove_attr_le(old_ni, attr_from_name(fname),
>> -						le);
>> -			if (err)
>> -				goto out6;
>> -
>> -			le16_add_cpu(&old_ni->mi.mrec->hard_links, -1);
>> -			old_ni->mi.dirty = true;
>> +	ni_lock_dir(dir_ni);
>> +	ni_lock(ni);
>> +
>> +	is_bad = false;
>> +	err = ni_rename(dir_ni, new_dir_ni, ni, de, new_de, &is_bad);
>> +	if (is_bad) {
>> +		/* Restore after failed rename failed too. */
>> +		make_bad_inode(inode);
>> +		ntfs_inode_err(inode, "failed to undo rename");
>> +		ntfs_set_state(sbi, NTFS_DIRTY_ERROR);
>> +	} else if (!err) {
>> +		inode->i_ctime = dir->i_ctime = dir->i_mtime =
>> +			current_time(dir);
>> +		mark_inode_dirty(inode);
>> +		mark_inode_dirty(dir);
>> +		if (dir != new_dir) {
>> +			new_dir->i_mtime = new_dir->i_ctime = dir->i_ctime;
>> +			mark_inode_dirty(new_dir);
>>  		}
>> -	}
>> -
>> -	/* Add new name. */
>> -	mi_get_ref(&old_ni->mi, &new_de->ref);
>> -	mi_get_ref(&ntfs_i(new_dir)->mi, &new_name->home);
>> -
>> -	new_de_key_size = le16_to_cpu(new_de->key_size);
>> -
>> -	/* Insert new name in MFT. */
>> -	err = ni_insert_resident(old_ni, new_de_key_size, ATTR_NAME, NULL, 0,
>> -				 &attr, NULL);
>> -	if (err)
>> -		goto out7;
>> -
>> -	attr->res.flags = RESIDENT_FLAG_INDEXED;
>> -
>> -	memcpy(Add2Ptr(attr, SIZEOF_RESIDENT), new_name, new_de_key_size);
>> -
>> -	le16_add_cpu(&old_ni->mi.mrec->hard_links, 1);
>> -	old_ni->mi.dirty = true;
>> -
>> -	/* Insert new name in directory. */
>> -	err = indx_insert_entry(&new_dir_ni->dir, new_dir_ni, new_de, sbi,
>> -				NULL);
>> -	if (err)
>> -		goto out8;
>>  
>> -	if (IS_DIRSYNC(new_dir))
>> -		err = ntfs_sync_inode(old_inode);
>> -	else
>> -		mark_inode_dirty(old_inode);
>> +		if (IS_DIRSYNC(dir))
>> +			ntfs_sync_inode(dir);
>>  
>> -	old_dir->i_ctime = old_dir->i_mtime = current_time(old_dir);
>> -	if (IS_DIRSYNC(old_dir))
>> -		(void)ntfs_sync_inode(old_dir);
>> -	else
>> -		mark_inode_dirty(old_dir);
>> -
>> -	if (old_dir != new_dir) {
>> -		new_dir->i_mtime = new_dir->i_ctime = old_dir->i_ctime;
>> -		mark_inode_dirty(new_dir);
>> -	}
>> -
>> -	if (old_inode) {
>> -		old_inode->i_ctime = old_dir->i_ctime;
>> -		mark_inode_dirty(old_inode);
>> +		if (IS_DIRSYNC(new_dir))
>> +			ntfs_sync_inode(inode);
>>  	}
>>  
>> -	err = 0;
>> -	/* Normal way* */
>> -	goto out2;
>> -
>> -out8:
>> -	/* undo
>> -	 * ni_insert_resident(old_ni, new_de_key_size, ATTR_NAME, NULL, 0,
>> -	 *			 &attr, NULL);
>> -	 */
>> -	mi_remove_attr(&old_ni->mi, attr);
>> -out7:
>> -	/* undo
>> -	 * ni_remove_attr_le(old_ni, attr_from_name(fname), le);
>> -	 */
>> -out6:
>> -	/* undo
>> -	 * indx_delete_entry(&old_dir_ni->dir, old_dir_ni,
>> -	 *					fname, fname_full_size(fname),
>> -	 *					sbi);
>> -	 */
>> -out5:
>> -	/* undo
>> -	 * ni_remove_attr_le(old_ni, attr_from_name(fname), le);
>> -	 */
>> -out4:
>> -	/* undo:
>> -	 * indx_delete_entry(&old_dir_ni->dir, old_dir_ni, old_de + 1,
>> -	 *			old_de->key_size, NULL);
>> -	 */
>> -out3:
>> -out2:
>> -	ni_unlock(old_ni);
>> -	ni_unlock(old_dir_ni);
>> -out1:
>> -	__putname(old_de);
>> +	ni_unlock(ni);
>> +	ni_unlock(dir_ni);
>>  out:
>> +	__putname(de);
>>  	return err;
>>  }
>>  
>> diff --git a/fs/ntfs3/ntfs_fs.h b/fs/ntfs3/ntfs_fs.h
>> index 64ef92e16363..f9436cbbc347 100644
>> --- a/fs/ntfs3/ntfs_fs.h
>> +++ b/fs/ntfs3/ntfs_fs.h
>> @@ -478,7 +478,7 @@ struct ATTR_STD_INFO *ni_std(struct ntfs_inode *ni);
>>  struct ATTR_STD_INFO5 *ni_std5(struct ntfs_inode *ni);
>>  void ni_clear(struct ntfs_inode *ni);
>>  int ni_load_mi_ex(struct ntfs_inode *ni, CLST rno, struct mft_inode **mi);
>> -int ni_load_mi(struct ntfs_inode *ni, struct ATTR_LIST_ENTRY *le,
>> +int ni_load_mi(struct ntfs_inode *ni, const struct ATTR_LIST_ENTRY *le,
>>  	       struct mft_inode **mi);
>>  struct ATTRIB *ni_find_attr(struct ntfs_inode *ni, struct ATTRIB *attr,
>>  			    struct ATTR_LIST_ENTRY **entry_o,
>> @@ -505,15 +505,18 @@ int ni_insert_nonresident(struct ntfs_inode *ni, enum ATTR_TYPE type,
>>  			  struct mft_inode **mi);
>>  int ni_insert_resident(struct ntfs_inode *ni, u32 data_size,
>>  		       enum ATTR_TYPE type, const __le16 *name, u8 name_len,
>> -		       struct ATTRIB **new_attr, struct mft_inode **mi);
>> -int ni_remove_attr_le(struct ntfs_inode *ni, struct ATTRIB *attr,
>> -		      struct ATTR_LIST_ENTRY *le);
>> +		       struct ATTRIB **new_attr, struct mft_inode **mi,
>> +		       struct ATTR_LIST_ENTRY **le);
>> +void ni_remove_attr_le(struct ntfs_inode *ni, struct ATTRIB *attr,
>> +		       struct mft_inode *mi, struct ATTR_LIST_ENTRY *le);
>>  int ni_delete_all(struct ntfs_inode *ni);
>>  struct ATTR_FILE_NAME *ni_fname_name(struct ntfs_inode *ni,
>>  				     const struct cpu_str *uni,
>>  				     const struct MFT_REF *home,
>> +				     struct mft_inode **mi,
>>  				     struct ATTR_LIST_ENTRY **entry);
>>  struct ATTR_FILE_NAME *ni_fname_type(struct ntfs_inode *ni, u8 name_type,
>> +				     struct mft_inode **mi,
>>  				     struct ATTR_LIST_ENTRY **entry);
>>  int ni_new_attr_flags(struct ntfs_inode *ni, enum FILE_ATTRIBUTE new_fa);
>>  enum REPARSE_SIGN ni_parse_reparse(struct ntfs_inode *ni, struct ATTRIB *attr,
>> @@ -528,6 +531,21 @@ int ni_read_frame(struct ntfs_inode *ni, u64 frame_vbo, struct page **pages,
>>  		  u32 pages_per_frame);
>>  int ni_write_frame(struct ntfs_inode *ni, struct page **pages,
>>  		   u32 pages_per_frame);
>> +int ni_remove_name(struct ntfs_inode *dir_ni, struct ntfs_inode *ni,
>> +		   struct NTFS_DE *de, struct NTFS_DE **de2, int *undo_step);
>> +
>> +bool ni_remove_name_undo(struct ntfs_inode *dir_ni, struct ntfs_inode *ni,
>> +			 struct NTFS_DE *de, struct NTFS_DE *de2,
>> +			 int undo_step);
>> +
>> +int ni_add_name(struct ntfs_inode *dir_ni, struct ntfs_inode *ni,
>> +		struct NTFS_DE *de);
>> +
>> +int ni_rename(struct ntfs_inode *dir_ni, struct ntfs_inode *new_dir_ni,
>> +	      struct ntfs_inode *ni, struct NTFS_DE *de, struct NTFS_DE *new_de,
>> +	      bool *is_bad);
>> +
>> +bool ni_is_dirty(struct inode *inode);
>>  
>>  /* Globals from fslog.c */
>>  int log_replay(struct ntfs_inode *ni, bool *initialized);
>> @@ -631,7 +649,7 @@ int indx_find_raw(struct ntfs_index *indx, struct ntfs_inode *ni,
>>  		  size_t *off, struct ntfs_fnd *fnd);
>>  int indx_insert_entry(struct ntfs_index *indx, struct ntfs_inode *ni,
>>  		      const struct NTFS_DE *new_de, const void *param,
>> -		      struct ntfs_fnd *fnd);
>> +		      struct ntfs_fnd *fnd, bool undo);
>>  int indx_delete_entry(struct ntfs_index *indx, struct ntfs_inode *ni,
>>  		      const void *key, u32 key_len, const void *param);
>>  int indx_update_dup(struct ntfs_inode *ni, struct ntfs_sb_info *sbi,
>> @@ -694,7 +712,8 @@ struct ATTRIB *mi_insert_attr(struct mft_inode *mi, enum ATTR_TYPE type,
>>  			      const __le16 *name, u8 name_len, u32 asize,
>>  			      u16 name_off);
>>  
>> -bool mi_remove_attr(struct mft_inode *mi, struct ATTRIB *attr);
>> +bool mi_remove_attr(struct ntfs_inode *ni, struct mft_inode *mi,
>> +		    struct ATTRIB *attr);
>>  bool mi_resize_attr(struct mft_inode *mi, struct ATTRIB *attr, int bytes);
>>  int mi_pack_runs(struct mft_inode *mi, struct ATTRIB *attr,
>>  		 struct runs_tree *run, CLST len);
>> diff --git a/fs/ntfs3/record.c b/fs/ntfs3/record.c
>> index d48a5e6c5045..61e3f2fb619f 100644
>> --- a/fs/ntfs3/record.c
>> +++ b/fs/ntfs3/record.c
>> @@ -489,7 +489,8 @@ struct ATTRIB *mi_insert_attr(struct mft_inode *mi, enum ATTR_TYPE type,
>>   *
>>   * NOTE: The source attr will point to next attribute.
>>   */
>> -bool mi_remove_attr(struct mft_inode *mi, struct ATTRIB *attr)
>> +bool mi_remove_attr(struct ntfs_inode *ni, struct mft_inode *mi,
>> +		    struct ATTRIB *attr)
>>  {
>>  	struct MFT_REC *rec = mi->mrec;
>>  	u32 aoff = PtrOffset(rec, attr);
>> @@ -499,6 +500,11 @@ bool mi_remove_attr(struct mft_inode *mi, struct ATTRIB *attr)
>>  	if (aoff + asize > used)
>>  		return false;
>>  
>> +	if (ni && is_attr_indexed(attr)) {
>> +		le16_add_cpu(&ni->mi.mrec->hard_links, -1);
>> +		ni->mi.dirty = true;
>> +	}
>> +
>>  	used -= asize;
>>  	memmove(attr, Add2Ptr(attr, asize), used - aoff);
>>  	rec->used = cpu_to_le32(used);
>> diff --git a/fs/ntfs3/xattr.c b/fs/ntfs3/xattr.c
>> index b4c921e4bc1a..22fd5eb32c5b 100644
>> --- a/fs/ntfs3/xattr.c
>> +++ b/fs/ntfs3/xattr.c
>> @@ -395,11 +395,13 @@ static noinline int ntfs_set_ea(struct inode *inode, const char *name,
>>  		}
>>  
>>  		err = ni_insert_resident(ni, sizeof(struct EA_INFO),
>> -					 ATTR_EA_INFO, NULL, 0, NULL, NULL);
>> +					 ATTR_EA_INFO, NULL, 0, NULL, NULL,
>> +					 NULL);
>>  		if (err)
>>  			goto out;
>>  
>> -		err = ni_insert_resident(ni, 0, ATTR_EA, NULL, 0, NULL, NULL);
>> +		err = ni_insert_resident(ni, 0, ATTR_EA, NULL, 0, NULL, NULL,
>> +					 NULL);
>>  		if (err)
>>  			goto out;
>>  	}
>> @@ -419,9 +421,7 @@ static noinline int ntfs_set_ea(struct inode *inode, const char *name,
>>  
>>  	if (!size) {
>>  		/* Delete xattr, ATTR_EA_INFO */
>> -		err = ni_remove_attr_le(ni, attr, le);
>> -		if (err)
>> -			goto out;
>> +		ni_remove_attr_le(ni, attr, mi, le);
>>  	} else {
>>  		p = resident_data_ex(attr, sizeof(struct EA_INFO));
>>  		if (!p) {
>> @@ -441,9 +441,7 @@ static noinline int ntfs_set_ea(struct inode *inode, const char *name,
>>  
>>  	if (!size) {
>>  		/* Delete xattr, ATTR_EA */
>> -		err = ni_remove_attr_le(ni, attr, le);
>> -		if (err)
>> -			goto out;
>> +		ni_remove_attr_le(ni, attr, mi, le);
>>  	} else if (attr->non_res) {
>>  		err = ntfs_sb_write_run(sbi, &ea_run, 0, ea_all, size);
>>  		if (err)
>> @@ -605,8 +603,7 @@ static noinline int ntfs_set_acl_ex(struct user_namespace *mnt_userns,
>>  			goto out;
>>  	}
>>  
>> -	err = ntfs_set_ea(inode, name, name_len, value, size,
>> -			  acl ? 0 : XATTR_REPLACE, locked);
>> +	err = ntfs_set_ea(inode, name, name_len, value, size, 0, locked);
>>  	if (!err)
>>  		set_cached_acl(inode, type, acl);
>>  
>> @@ -632,8 +629,10 @@ static int ntfs_xattr_get_acl(struct user_namespace *mnt_userns,
>>  	struct posix_acl *acl;
>>  	int err;
>>  
>> -	if (!(inode->i_sb->s_flags & SB_POSIXACL))
>> +	if (!(inode->i_sb->s_flags & SB_POSIXACL)) {
>> +		ntfs_inode_warn(inode, "add mount option \"acl\" to use acl");
>>  		return -EOPNOTSUPP;
>> +	}
>>  
>>  	acl = ntfs_get_acl(inode, type);
>>  	if (IS_ERR(acl))
>> @@ -655,8 +654,10 @@ static int ntfs_xattr_set_acl(struct user_namespace *mnt_userns,
>>  	struct posix_acl *acl;
>>  	int err;
>>  
>> -	if (!(inode->i_sb->s_flags & SB_POSIXACL))
>> +	if (!(inode->i_sb->s_flags & SB_POSIXACL)) {
>> +		ntfs_inode_warn(inode, "add mount option \"acl\" to use acl");
>>  		return -EOPNOTSUPP;
>> +	}
>>  
>>  	if (!inode_owner_or_capable(mnt_userns, inode))
>>  		return -EPERM;
>> -- 
>> 2.28.0
>>





[Index of Archives]     [Linux Driver Backports]     [DMA Engine]     [Linux GPIO]     [Linux SPI]     [Video for Linux]     [Linux USB Devel]     [Linux Coverity]     [Linux Audio Users]     [Linux Kernel]     [Linux SCSI]     [Yosemite Backpacking]
  Powered by Linux