Skip to contentSkip to conversation

Difference between invalidating and deleting dentry

DISCUSSION Nikolaus Rath 5 participants 16 messages Oct 9, 2016 – Nov 1, 2016 VFS

lore
Share & tools
lore
#0 lore raw

Hello,

I just added an example to FUSE that illustrates use of the fuse_lowlevel_notify_inval_entry() function. However, when writing it I realized that I don't actually fully understand how this function differs from fuse_lowlevel_notify_delete(). Could someone shed some light on this?

Currently, the FUSE documentation says:

fuse_lowlevel_notify_inval_entry:
Notify to invalidate parent attributes and the dentry matching parent/name

fuse_lowlevel_notify_delete:
Notify to invalidate parent attributes and delete the dentry matching parent/name if the dentry's inode number matches child (otherwise it will invalidate the matching dentry).

But what exactly is the difference between deleting and invalidating a dentry? In each case, isn't the resulting behavior the same, in that the next time someone tries to access this (parent_inode,entry_name) combination a lookup() request will be send to the FUSE process?

Thanks,
-Nikolaus

Signature · 4 lines
GPG encrypted emails preferred. Key id: 0xD113FCAC3C4E599F
Fingerprint: ED31 791B 2C5C 1613 AF38 8B8A D113 FCAC 3C4E 599F

             »Time flies like an arrow, fruit flies like a Banana.«
#1 lore raw

Hi Nikolaus,

Quoted 14 lines · Nikolaus Rath

Hello,

I just added an example to FUSE that illustrates use of the fuse_lowlevel_notify_inval_entry() function. However, when writing it I realized that I don't actually fully understand how this function differs from fuse_lowlevel_notify_delete(). Could someone shed some light on this?

Currently, the FUSE documentation says:

fuse_lowlevel_notify_inval_entry:
Notify to invalidate parent attributes and the dentry matching parent/name

Quoted 8 lines

fuse_lowlevel_notify_delete:
Notify to invalidate parent attributes and delete the dentry matching parent/name if the dentry's inode number matches child (otherwise it will invalidate the matching dentry).

But what exactly is the difference between deleting and invalidating a dentry?

That is the difference:

/*
* d_drop() unhashes the entry from the parent dentry hashes, so that it won't
* be found through a VFS lookup any more. Note that this is different from
* deleting the dentry - d_delete will try to mark the dentry negative if
* possible, giving a successful _negative_ lookup, while d_drop will
* just make the cache lookup fail.
*/

But since fuse_lowlevel_notify_delete does among other things:
d_invalidate->...d_drop()
d_delete()

You may still ask yourself what is the purpose of d_delete() after d_drop(), because there is no cache entry to make negative...

Quoted 3 lines

In each case, isn't the resulting behavior the same, in that the next time someone tries to access this (parent_inode,entry_name) combination a lookup() request will be send to the FUSE process?

You are right about the next lookup behavior being the same, but there are other things that d_delete() does which d_invalidate does not, which are important, like calling fsnotify_nameremove() and update the cached inode and dentry that are referenced by open files.

Cheers,
Amir.

#2 lore raw

Hi Amir,

Quoted 28 lines · Amir Goldstein

Hi Nikolaus,

Quoted 14 lines · Nikolaus Rath

Hello,

I just added an example to FUSE that illustrates use of the fuse_lowlevel_notify_inval_entry() function. However, when writing it I realized that I don't actually fully understand how this function differs from fuse_lowlevel_notify_delete(). Could someone shed some light on this?

Currently, the FUSE documentation says:

fuse_lowlevel_notify_inval_entry:
Notify to invalidate parent attributes and the dentry matching parent/name

Quoted 8 lines

fuse_lowlevel_notify_delete:
Notify to invalidate parent attributes and delete the dentry matching parent/name if the dentry's inode number matches child (otherwise it will invalidate the matching dentry).

But what exactly is the difference between deleting and invalidating a dentry?

That is the difference:

Quoted 7 lines

/*
* d_drop() unhashes the entry from the parent dentry hashes, so that it won't
* be found through a VFS lookup any more. Note that this is different from
* deleting the dentry - d_delete will try to mark the dentry negative if
* possible, giving a successful _negative_ lookup, while d_drop will
* just make the cache lookup fail.
*/

Alright, so at this point I thought I understood the difference and got ready to update the documentation, but then you got me very confused:

Quoted 6 lines

But since fuse_lowlevel_notify_delete does among other things:
d_invalidate->...d_drop()
d_delete()

You may still ask yourself what is the purpose of d_delete() after d_drop(), because there is no cache entry to make negative...

So, in other words, FUSE's notify_delete will *not* store a negative dentry, but will just drop the dentry?

Quoted 8 lines
Quoted 3 lines

In each case, isn't the resulting behavior the same, in that the next time someone tries to access this (parent_inode,entry_name) combination a lookup() request will be send to the FUSE process?

You are right about the next lookup behavior being the same, but there are other things that d_delete() does which d_invalidate does not, which are important, like calling fsnotify_nameremove() and update the cached inode and dentry that are referenced by open files.

Hmm. So when should one use notify_delete() and when notify_inval_entry()? I understand there is a difference, but I'm uncertain about the practical consequences...

Thanks!
-Nikolaus

Signature · 4 lines
GPG encrypted emails preferred. Key id: 0xD113FCAC3C4E599F
Fingerprint: ED31 791B 2C5C 1613 AF38 8B8A D113 FCAC 3C4E 599F

             »Time flies like an arrow, fruit flies like a Banana.«
#3 lore raw
Quoted 76 lines · Nikolaus Rath

Hi Amir,

Quoted 35 lines · Amir Goldstein

Hi Nikolaus,

Quoted 25 lines · Nikolaus Rath

Hello,

I just added an example to FUSE that illustrates use of the fuse_lowlevel_notify_inval_entry() function. However, when writing it I
realized that I don't actually fully understand how this function differs from fuse_lowlevel_notify_delete(). Could someone shed some
light on this?

Currently, the FUSE documentation says:

fuse_lowlevel_notify_inval_entry:
   Notify to invalidate parent attributes and the dentry matching parent/name

fuse_lowlevel_notify_delete:
   Notify to invalidate parent attributes and delete the dentry matching
   parent/name if the dentry's inode number matches child (otherwise it
   will invalidate the matching dentry).

Quoted 3 lines

But what exactly is the difference between deleting and invalidating a
dentry?

That is the difference:

Quoted 11 lines

/*
 * d_drop() unhashes the entry from the parent dentry hashes, so that it won't
 * be found through a VFS lookup any more. Note that this is different from
 * deleting the dentry - d_delete will try to mark the dentry negative if
 * possible, giving a successful _negative_ lookup, while d_drop will
 * just make the cache lookup fail.
 */

Alright, so at this point I thought I understood the difference and got
ready to update the documentation, but then you got me very confused:

Quoted 8 lines

But since fuse_lowlevel_notify_delete does among other things:
d_invalidate->...d_drop()
d_delete()

You may still ask yourself what is the purpose of d_delete() after d_drop(),
because there is no cache entry to make negative...

So, in other words, FUSE's notify_delete will *not* store a negative dentry, but will just drop the dentry?

Quoted 5 lines
Quoted 5 lines

In each case, isn't the resulting behavior the same, in that the next time someone tries to access this (parent_inode,entry_name) combination a lookup() request will be send to the FUSE process?

Quoted 7 lines

You are right about the next lookup behavior being the same, but there
are other things that d_delete() does which d_invalidate does not, which
are important, like calling fsnotify_nameremove() and update the cached
inode and dentry that are referenced by open files.

Quoted 7 lines

Hmm. So when should one use notify_delete() and when notify_inval_entry()? I understand there is a difference, but I'm uncertain about the practical consequences...

Thanks!
-Nikolaus

Hi Nikolaus,

It sounds to me like you want to use notify_delete() for an unlink/rmdir and you want to use notify_inval_entry for a rename() (maybe delete the old name and invalidate the new name). You would want to do this when you know either of these things has happened outside the knowledge of the kernel, e.g. you know that an external client has deleted/renamed a file.

Regards,
Michael Theall

#4 lore raw
Quoted 85 lines · Michael Theall
Quoted 76 lines · Nikolaus Rath

Hi Amir,

Quoted 35 lines · Amir Goldstein

Hi Nikolaus,

Quoted 25 lines · Nikolaus Rath

Hello,

I just added an example to FUSE that illustrates use of the fuse_lowlevel_notify_inval_entry() function. However, when writing it I
realized that I don't actually fully understand how this function differs from fuse_lowlevel_notify_delete(). Could someone shed some
light on this?

Currently, the FUSE documentation says:

fuse_lowlevel_notify_inval_entry:
Notify to invalidate parent attributes and the dentry matching parent/name

fuse_lowlevel_notify_delete:
Notify to invalidate parent attributes and delete the dentry
matching
parent/name if the dentry's inode number matches child
(otherwise it
will invalidate the matching dentry).

Quoted 3 lines

But what exactly is the difference between deleting and invalidating a
dentry?

That is the difference:

Quoted 11 lines

/*
* d_drop() unhashes the entry from the parent dentry hashes, so
that it won't
* be found through a VFS lookup any more. Note that this is
different from
* deleting the dentry - d_delete will try to mark the dentry
negative if
* possible, giving a successful _negative_ lookup, while d_drop
will
* just make the cache lookup fail.
*/

Alright, so at this point I thought I understood the difference and got
ready to update the documentation, but then you got me very confused:

Quoted 8 lines

But since fuse_lowlevel_notify_delete does among other things:
d_invalidate->...d_drop()
d_delete()

You may still ask yourself what is the purpose of d_delete() after d_drop(),
because there is no cache entry to make negative...

So, in other words, FUSE's notify_delete will *not* store a negative dentry, but will just drop the dentry?

Quoted 5 lines
Quoted 5 lines

In each case, isn't the resulting behavior the same, in that the next time someone tries to access this (parent_inode,entry_name) combination a lookup() request will be send to the FUSE process?

Quoted 7 lines

You are right about the next lookup behavior being the same, but there
are other things that d_delete() does which d_invalidate does not, which
are important, like calling fsnotify_nameremove() and update the cached
inode and dentry that are referenced by open files.

Quoted 7 lines

Hmm. So when should one use notify_delete() and when notify_inval_entry()? I understand there is a difference, but I'm uncertain about the practical consequences...

Thanks!
-Nikolaus

Quoted 8 lines

Hi Nikolaus,

It sounds to me like you want to use notify_delete() for an unlink/rmdir and you want to use notify_inval_entry for a rename() (maybe delete the old name and invalidate the new name). You would want to do this when you know either of these things has happened outside the knowledge of the kernel, e.g. you know that an external client has deleted/renamed a file.

Agree. Also external client has modified a file may be a cause for invalidate.

Quoted 4 lines

Regards,
Michael Theall

#5 lore raw
Quoted 121 lines · Amir Goldstein
Quoted 110 lines · Michael Theall
Quoted 99 lines · Nikolaus Rath

Hi Amir,

Quoted 42 lines · Amir Goldstein

Hi Nikolaus,

Quoted 30 lines · Nikolaus Rath

Hello,

I just added an example to FUSE that illustrates use of the fuse_lowlevel_notify_inval_entry() function. However, when writing it I
realized that I don't actually fully understand how this function
differs from fuse_lowlevel_notify_delete(). Could someone shed
some
light on this?

Currently, the FUSE documentation says:

fuse_lowlevel_notify_inval_entry:
   Notify to invalidate parent attributes and the dentry matching
   parent/name

fuse_lowlevel_notify_delete:
   Notify to invalidate parent attributes and delete the dentry
matching
   parent/name if the dentry's inode number matches child (otherwise it
   will invalidate the matching dentry).

Quoted 3 lines

But what exactly is the difference between deleting and invalidating a
dentry?

That is the difference:

Quoted 13 lines

/*
 * d_drop() unhashes the entry from the parent dentry hashes, so
that it won't
 * be found through a VFS lookup any more. Note that this is different from
 * deleting the dentry - d_delete will try to mark the dentry negative if
 * possible, giving a successful _negative_ lookup, while d_drop
will
 * just make the cache lookup fail.
 */

Alright, so at this point I thought I understood the difference and
got
ready to update the documentation, but then you got me very confused:

Quoted 10 lines

But since fuse_lowlevel_notify_delete does among other things:
d_invalidate->...d_drop()
d_delete()

You may still ask yourself what is the purpose of d_delete() after
d_drop(),
because there is no cache entry to make negative...

So, in other words, FUSE's notify_delete will *not* store a negative
dentry, but will just drop the dentry?

Quoted 10 lines
Quoted 10 lines

In each case, isn't the resulting behavior the same, in that the
next time someone tries to access this (parent_inode,entry_name)
combination a lookup() request will be send to the FUSE process?

Quoted 10 lines

You are right about the next lookup behavior being the same, but
there
are other things that d_delete() does which d_invalidate does not,
which
are important, like calling fsnotify_nameremove() and update the
cached
inode and dentry that are referenced by open files.

Quoted 7 lines

Hmm. So when should one use notify_delete() and when notify_inval_entry()? I understand there is a difference, but I'm uncertain about the practical consequences...

Thanks!
-Nikolaus

Hi Nikolaus,

Quoted 9 lines

It sounds to me like you want to use notify_delete() for an unlink/rmdir and you want to use notify_inval_entry for a rename() (maybe delete the old name and invalidate the new name). You would want
to do this when you know either of these things has happened outside
the knowledge of the kernel, e.g. you know that an external client has
deleted/renamed a file.

Quoted 2 lines

Agree. Also external client has modified a file may be a cause for invalidate.

Unless the name has changed, I would use inval_inode() when an external client has changed the file.

Regards,
Michael Theall

#6 lore raw
In reply to Michael Theall
Quoted 75 lines · Michael Theall
Quoted 74 lines · Nikolaus Rath

Hi Amir,

Quoted 35 lines · Amir Goldstein

Hi Nikolaus,

Quoted 25 lines · Nikolaus Rath

Hello,

I just added an example to FUSE that illustrates use of the fuse_lowlevel_notify_inval_entry() function. However, when writing it I
realized that I don't actually fully understand how this function differs from fuse_lowlevel_notify_delete(). Could someone shed some
light on this?

Currently, the FUSE documentation says:

fuse_lowlevel_notify_inval_entry:
   Notify to invalidate parent attributes and the dentry matching parent/name

fuse_lowlevel_notify_delete:
   Notify to invalidate parent attributes and delete the dentry matching
   parent/name if the dentry's inode number matches child (otherwise it
   will invalidate the matching dentry).

Quoted 3 lines

But what exactly is the difference between deleting and invalidating a
dentry?

That is the difference:

Quoted 11 lines

/*
 * d_drop() unhashes the entry from the parent dentry hashes, so that it won't
 * be found through a VFS lookup any more. Note that this is different from
 * deleting the dentry - d_delete will try to mark the dentry negative if
 * possible, giving a successful _negative_ lookup, while d_drop will
 * just make the cache lookup fail.
 */

Alright, so at this point I thought I understood the difference and got
ready to update the documentation, but then you got me very confused:

Quoted 8 lines

But since fuse_lowlevel_notify_delete does among other things:
d_invalidate->...d_drop()
d_delete()

You may still ask yourself what is the purpose of d_delete() after d_drop(),
because there is no cache entry to make negative...

So, in other words, FUSE's notify_delete will *not* store a negative dentry, but will just drop the dentry?

Quoted 11 lines
Quoted 4 lines

In each case, isn't the resulting behavior the same, in that the next time someone tries to access this (parent_inode,entry_name) combination a lookup() request will be send to the FUSE process?

You are right about the next lookup behavior being the same, but there
are other things that d_delete() does which d_invalidate does not, which
are important, like calling fsnotify_nameremove() and update the cached
inode and dentry that are referenced by open files.

Quoted 7 lines
Quoted 3 lines

Hmm. So when should one use notify_delete() and when notify_inval_entry()? I understand there is a difference, but I'm uncertain about the practical consequences...

It sounds to me like you want to use notify_delete() for an unlink/rmdir and you want to use notify_inval_entry for a rename() (maybe delete the old name and invalidate the new name).

This sounds reasonable, but what are the reasons? Why does the kernel need to be told about a rename in a different way than about a removal? Note that we are not transmitting the new name.

How is a rename even technically different from first removing an entry and entry and then adding a different one for the same inode? For example, suppose I have a network file system and this happens on the remote side:

$ echo "contents" > perm_name
$ ln perm_name old_name
$ rm old_name
$ ln perm_name new name

On the local system, does this really need to be signaled to the kernel differently than

$ echo "contents" > perm_name
$ ln perm_name old_name
$ mv old_name new_name

(Obviously in the file system one is atomic and the other is not, but I don't see how this matters for the call to the notify_* function).

Also, what is the reason for _delete() falling back to _inval_entry() in some conditions? I have trouble coming up with the scenario where this is required / helpful.

Best,
-Nikolaus

Signature · 4 lines
GPG encrypted emails preferred. Key id: 0xD113FCAC3C4E599F
Fingerprint: ED31 791B 2C5C 1613 AF38 8B8A D113 FCAC 3C4E 599F

             »Time flies like an arrow, fruit flies like a Banana.«
#7 lore raw

Hello,

*ping*

Really no one able to clarify the difference between the FUSE invalidate and delete dentry requests?

Best,
-Nikolaus

Quoted 123 lines · Nikolaus Rath
Quoted 75 lines · Michael Theall
Quoted 74 lines · Nikolaus Rath

Hi Amir,

Quoted 35 lines · Amir Goldstein

Hi Nikolaus,

Quoted 25 lines · Nikolaus Rath

Hello,

I just added an example to FUSE that illustrates use of the fuse_lowlevel_notify_inval_entry() function. However, when writing it I
realized that I don't actually fully understand how this function differs from fuse_lowlevel_notify_delete(). Could someone shed some
light on this?

Currently, the FUSE documentation says:

fuse_lowlevel_notify_inval_entry:
   Notify to invalidate parent attributes and the dentry matching parent/name

fuse_lowlevel_notify_delete:
   Notify to invalidate parent attributes and delete the dentry matching
   parent/name if the dentry's inode number matches child (otherwise it
   will invalidate the matching dentry).

Quoted 3 lines

But what exactly is the difference between deleting and invalidating a
dentry?

That is the difference:

Quoted 11 lines

/*
 * d_drop() unhashes the entry from the parent dentry hashes, so that it won't
 * be found through a VFS lookup any more. Note that this is different from
 * deleting the dentry - d_delete will try to mark the dentry negative if
 * possible, giving a successful _negative_ lookup, while d_drop will
 * just make the cache lookup fail.
 */

Alright, so at this point I thought I understood the difference and got
ready to update the documentation, but then you got me very confused:

Quoted 8 lines

But since fuse_lowlevel_notify_delete does among other things:
d_invalidate->...d_drop()
d_delete()

You may still ask yourself what is the purpose of d_delete() after d_drop(),
because there is no cache entry to make negative...

So, in other words, FUSE's notify_delete will *not* store a negative dentry, but will just drop the dentry?

Quoted 11 lines
Quoted 4 lines

In each case, isn't the resulting behavior the same, in that the next time someone tries to access this (parent_inode,entry_name) combination a lookup() request will be send to the FUSE process?

You are right about the next lookup behavior being the same, but there
are other things that d_delete() does which d_invalidate does not, which
are important, like calling fsnotify_nameremove() and update the cached
inode and dentry that are referenced by open files.

Quoted 7 lines
Quoted 3 lines

Hmm. So when should one use notify_delete() and when notify_inval_entry()? I understand there is a difference, but I'm uncertain about the practical consequences...

It sounds to me like you want to use notify_delete() for an unlink/rmdir and you want to use notify_inval_entry for a rename() (maybe delete the old name and invalidate the new name).

This sounds reasonable, but what are the reasons? Why does the kernel need to be told about a rename in a different way than about a removal? Note that we are not transmitting the new name.

How is a rename even technically different from first removing an entry and entry and then adding a different one for the same inode? For example, suppose I have a network file system and this happens on the remote side:

$ echo "contents" > perm_name
$ ln perm_name old_name
$ rm old_name
$ ln perm_name new name

On the local system, does this really need to be signaled to the kernel differently than

$ echo "contents" > perm_name
$ ln perm_name old_name
$ mv old_name new_name

(Obviously in the file system one is atomic and the other is not, but I don't see how this matters for the call to the notify_* function).

Also, what is the reason for _delete() falling back to _inval_entry() in some conditions? I have trouble coming up with the scenario where this is required / helpful.

Best,
-Nikolaus

Signature · 4 lines
GPG encrypted emails preferred. Key id: 0xD113FCAC3C4E599F
Fingerprint: ED31 791B 2C5C 1613 AF38 8B8A D113 FCAC 3C4E 599F

             »Time flies like an arrow, fruit flies like a Banana.«
Signature · 4 lines
GPG encrypted emails preferred. Key id: 0xD113FCAC3C4E599F
Fingerprint: ED31 791B 2C5C 1613 AF38 8B8A D113 FCAC 3C4E 599F

             »Time flies like an arrow, fruit flies like a Banana.«
#8 lore raw
Quoted 6 lines · Nikolaus Rath

Hello,

*ping*

Really no one able to clarify the difference between the FUSE invalidate and delete dentry requests?

It may sound strange to you, but I think the documentation is clear enough. The difference is that in delete case, you *know* that the entry has been deleted
and in invalidate case, you may not know what happened to the entry. The specific use cases are implementation specific, but maybe you lost contact with remote server or maybe the remote protocol imposes a timeout for validity or maybe you do not have enough information
to figure out if the entry has been deleted and re-created. Invalidate simply means that you no longer know that the entry is valid.

Quoted 142 lines

Best,
-Nikolaus

Quoted 118 lines · Nikolaus Rath
Quoted 75 lines · Michael Theall
Quoted 74 lines · Nikolaus Rath

Hi Amir,

Quoted 35 lines · Amir Goldstein

Hi Nikolaus,

Quoted 25 lines · Nikolaus Rath

Hello,

I just added an example to FUSE that illustrates use of the fuse_lowlevel_notify_inval_entry() function. However, when writing it I
realized that I don't actually fully understand how this function differs from fuse_lowlevel_notify_delete(). Could someone shed some
light on this?

Currently, the FUSE documentation says:

fuse_lowlevel_notify_inval_entry:
Notify to invalidate parent attributes and the dentry matching parent/name

fuse_lowlevel_notify_delete:
Notify to invalidate parent attributes and delete the dentry
matching
parent/name if the dentry's inode number matches child
(otherwise it
will invalidate the matching dentry).

Quoted 3 lines

But what exactly is the difference between deleting and invalidating a
dentry?

That is the difference:

Quoted 11 lines

/*
* d_drop() unhashes the entry from the parent dentry hashes, so
that it won't
* be found through a VFS lookup any more. Note that this is
different from
* deleting the dentry - d_delete will try to mark the dentry
negative if
* possible, giving a successful _negative_ lookup, while d_drop
will
* just make the cache lookup fail.
*/

Alright, so at this point I thought I understood the difference and got
ready to update the documentation, but then you got me very confused:

Quoted 8 lines

But since fuse_lowlevel_notify_delete does among other things:
d_invalidate->...d_drop()
d_delete()

You may still ask yourself what is the purpose of d_delete() after d_drop(),
because there is no cache entry to make negative...

So, in other words, FUSE's notify_delete will *not* store a negative dentry, but will just drop the dentry?

Quoted 11 lines
Quoted 4 lines

In each case, isn't the resulting behavior the same, in that the next time someone tries to access this (parent_inode,entry_name) combination a lookup() request will be send to the FUSE process?

You are right about the next lookup behavior being the same, but there
are other things that d_delete() does which d_invalidate does not, which
are important, like calling fsnotify_nameremove() and update the cached
inode and dentry that are referenced by open files.

Quoted 7 lines
Quoted 3 lines

Hmm. So when should one use notify_delete() and when notify_inval_entry()? I understand there is a difference, but I'm uncertain about the practical consequences...

It sounds to me like you want to use notify_delete() for an unlink/rmdir and you want to use notify_inval_entry for a rename() (maybe delete the old name and invalidate the new name).

This sounds reasonable, but what are the reasons? Why does the kernel need to be told about a rename in a different way than about a removal? Note that we are not transmitting the new name.

How is a rename even technically different from first removing an entry and entry and then adding a different one for the same inode? For example, suppose I have a network file system and this happens on the remote side:

$ echo "contents" > perm_name
$ ln perm_name old_name
$ rm old_name
$ ln perm_name new name

On the local system, does this really need to be signaled to the kernel differently than

$ echo "contents" > perm_name
$ ln perm_name old_name
$ mv old_name new_name

(Obviously in the file system one is atomic and the other is not, but I don't see how this matters for the call to the notify_* function).

Also, what is the reason for _delete() falling back to _inval_entry() in some conditions? I have trouble coming up with the scenario where this is required / helpful.

Best,
-Nikolaus

Quoted 5 lines

--
GPG encrypted emails preferred. Key id: 0xD113FCAC3C4E599F
Fingerprint: ED31 791B 2C5C 1613 AF38 8B8A D113 FCAC 3C4E 599F

»Time flies like an arrow, fruit flies like a Banana.«

--
GPG encrypted emails preferred. Key id: 0xD113FCAC3C4E599F
Fingerprint: ED31 791B 2C5C 1613 AF38 8B8A D113 FCAC 3C4E 599F

»Time flies like an arrow, fruit flies like a Banana.«

------------------------------------------------------------------------------
Check out the vibrant tech community on one of the world's most
engaging tech sites, SlashDot.org! http://sdm.link/slashdot
--
fuse-devel mailing list
To unsubscribe or subscribe, visit https://lists.sourceforge.net/lists/listinfo/fuse-devel

#9 lore raw
Quoted 5 lines · Amir Goldstein
Quoted 2 lines · Nikolaus Rath

Really no one able to clarify the difference between the FUSE invalidate and delete dentry requests?

Quoted 9 lines

It may sound strange to you, but I think the documentation is clear enough. The difference is that in delete case, you *know* that the entry has been deleted
and in invalidate case, you may not know what happened to the entry. The specific use cases are implementation specific, but maybe you lost contact with remote server or maybe the remote protocol imposes a timeout for validity or maybe you do not have enough information
to figure out if the entry has been deleted and re-created. Invalidate simply means that you no longer know that the entry is valid.

That was the intent, yes. However 'invalidate' + 'lookup negative' should be equivalent to 'delete'. And it is.

The reason why 'delete' was introduced by commit 451d0f599934 ("FUSE:
Notifying the kernel of deletion.") is that 'invalidate' wasn't able to remove in-use subtrees.

Commit bafc9b754f75 ("vfs: More precise tests in d_invalidate") changed that, so now 'notify_delete' is superfluous and AFAICS the effect of it is exactly the same as 'notify_invalidate'.

Thanks,
Miklos

#10 lore raw
Quoted 19 lines · Miklos Szeredi
Quoted 5 lines · Amir Goldstein
Quoted 2 lines · Nikolaus Rath

Really no one able to clarify the difference between the FUSE invalidate and delete dentry requests?

Quoted 9 lines

It may sound strange to you, but I think the documentation is clear enough. The difference is that in delete case, you *know* that the entry has been deleted
and in invalidate case, you may not know what happened to the entry. The specific use cases are implementation specific, but maybe you lost contact with remote server or maybe the remote protocol imposes a timeout for validity or maybe you do not have enough information
to figure out if the entry has been deleted and re-created. Invalidate simply means that you no longer know that the entry is valid.

That was the intent, yes. However 'invalidate' + 'lookup negative' should be equivalent to 'delete'. And it is.

Quoted 8 lines

The reason why 'delete' was introduced by commit 451d0f599934 ("FUSE:
Notifying the kernel of deletion.") is that 'invalidate' wasn't able to remove in-use subtrees.

Commit bafc9b754f75 ("vfs: More precise tests in d_invalidate") changed that, so now 'notify_delete' is superfluous and AFAICS the effect of it is exactly the same as 'notify_invalidate'.

Minus fsnotify_nameremove() for whatever it is worth.

Amir.

#11 lore raw
Quoted 24 lines · Amir Goldstein
Quoted 23 lines · Miklos Szeredi
Quoted 5 lines · Amir Goldstein
Quoted 2 lines · Nikolaus Rath

Really no one able to clarify the difference between the FUSE invalidate and delete dentry requests?

Quoted 9 lines

It may sound strange to you, but I think the documentation is clear enough. The difference is that in delete case, you *know* that the entry has been deleted
and in invalidate case, you may not know what happened to the entry. The specific use cases are implementation specific, but maybe you lost contact with remote server or maybe the remote protocol imposes a timeout for validity or maybe you do not have enough information
to figure out if the entry has been deleted and re-created. Invalidate simply means that you no longer know that the entry is valid.

That was the intent, yes. However 'invalidate' + 'lookup negative' should be equivalent to 'delete'. And it is.

The reason why 'delete' was introduced by commit 451d0f599934 ("FUSE:
Notifying the kernel of deletion.") is that 'invalidate' wasn't able to remove in-use subtrees.

Quoted 6 lines
Quoted 4 lines

Commit bafc9b754f75 ("vfs: More precise tests in d_invalidate") changed that, so now 'notify_delete' is superfluous and AFAICS the effect of it is exactly the same as 'notify_invalidate'.

Minus fsnotify_nameremove() for whatever it is worth.

Ah, right. But fuse lacks proper fsnotify support for remote fs anyway, so it's not worth much.

Thanks,
Miklos

#12 lore raw
Quoted 30 lines · Miklos Szeredi
Quoted 29 lines · Amir Goldstein
Quoted 27 lines · Miklos Szeredi
Quoted 5 lines · Amir Goldstein
Quoted 2 lines · Nikolaus Rath

Really no one able to clarify the difference between the FUSE invalidate and delete dentry requests?

Quoted 9 lines

It may sound strange to you, but I think the documentation is clear enough. The difference is that in delete case, you *know* that the entry has been deleted
and in invalidate case, you may not know what happened to the entry. The specific use cases are implementation specific, but maybe you lost contact with remote server or maybe the remote protocol imposes a timeout for validity or maybe you do not have enough information
to figure out if the entry has been deleted and re-created. Invalidate simply means that you no longer know that the entry is valid.

That was the intent, yes. However 'invalidate' + 'lookup negative' should be equivalent to 'delete'. And it is.

The reason why 'delete' was introduced by commit 451d0f599934 ("FUSE:
Notifying the kernel of deletion.") is that 'invalidate' wasn't able to remove in-use subtrees.

Commit bafc9b754f75 ("vfs: More precise tests in d_invalidate") changed that, so now 'notify_delete' is superfluous and AFAICS the effect of it is exactly the same as 'notify_invalidate'.

Quoted 4 lines
Quoted 1 line

Minus fsnotify_nameremove() for whatever it is worth.

Ah, right. But fuse lacks proper fsnotify support for remote fs anyway, so it's not worth much.

Thanks Miklos!

So I'll extend the documentation to say that both _invalidate() and _delete() drop the dentry from the cache (so the next lookup attempt) will be passed to the fuse file sysem), but that _delete() will also inform any inotify watchers that the entry has disappeared.

Best,
-Nikolaus

Signature · 4 lines
GPG encrypted emails preferred. Key id: 0xD113FCAC3C4E599F
Fingerprint: ED31 791B 2C5C 1613 AF38 8B8A D113 FCAC 3C4E 599F

             »Time flies like an arrow, fruit flies like a Banana.«
#13 lore raw
In reply to Amir Goldstein
Quoted 8 lines · Amir Goldstein
Quoted 6 lines · Nikolaus Rath

Hello,

*ping*

Really no one able to clarify the difference between the FUSE invalidate and delete dentry requests?

Quoted 9 lines

It may sound strange to you, but I think the documentation is clear enough. The difference is that in delete case, you *know* that the entry has been deleted and in invalidate case, you may not know what happened to the entry. The specific use cases are implementation specific, but maybe you lost contact with remote server or maybe the remote protocol imposes a timeout for validity or maybe you do not have enough information to figure out if the entry has been deleted and re-created. Invalidate simply means that you no longer know that the entry is valid.

This would make sense if delete would cache the negative lookup, but based on what you said earlier this is not the case.

So what is the practical difference between the two functions? Or, putting it differently, what are the consequences of sending a delete when the entry still exists, or an invalidate when it has been deleted?

Best,
-Nikolaus

Signature · 4 lines
GPG encrypted emails preferred. Key id: 0xD113FCAC3C4E599F
Fingerprint: ED31 791B 2C5C 1613 AF38 8B8A D113 FCAC 3C4E 599F

             »Time flies like an arrow, fruit flies like a Banana.«
#14 lore raw
In reply to Nikolaus Rath
Quoted 12 lines · Nikolaus Rath

fuse_lowlevel_notify_inval_entry:
Notify to invalidate parent attributes and the dentry matching parent/name

fuse_lowlevel_notify_delete:
Notify to invalidate parent attributes and delete the dentry matching parent/name if the dentry's inode number matches child (otherwise it will invalidate the matching dentry).

Quoted 4 lines

But what exactly is the difference between deleting and invalidating a dentry? In each case, isn't the resulting behavior the same, in that the next time someone tries to access this (parent_inode,entry_name) combination a lookup() request will be send to the FUSE process?

These are aimed at networked file-systems where changes can be initiated at the other end.

The first clears the cached data for that dentry, so that next time the file lookup occurs the file is still in existence but there is no cached data, forcing the request to go down to the user-space file-system. This would be used during remote rename.

The second actually removes the dentry in the VFS in the kernel. This would be used during remote deletion.

#15 lore raw
Quoted 20 lines · John Muir
Quoted 12 lines · Nikolaus Rath

fuse_lowlevel_notify_inval_entry:
Notify to invalidate parent attributes and the dentry matching parent/name

fuse_lowlevel_notify_delete:
Notify to invalidate parent attributes and delete the dentry matching parent/name if the dentry's inode number matches child (otherwise it will invalidate the matching dentry).

Quoted 4 lines

But what exactly is the difference between deleting and invalidating a dentry? In each case, isn't the resulting behavior the same, in that the next time someone tries to access this (parent_inode,entry_name) combination a lookup() request will be send to the FUSE process?

These are aimed at networked file-systems where changes can be initiated at the other end.

Quoted 7 lines

The first clears the cached data for that dentry, so that next time the file lookup occurs the file is still in existence but there is no cached data, forcing the request to go down to the user-space file-system. This would be used during remote rename.

The second actually removes the dentry in the VFS in the kernel. This would be used during remote deletion.

Alright, seems there are as many different opinions on this as there are replies. So I tried to make sense of the code myself.

I think Miklos and Amir are correct: the only difference between the functions is a call to fsnotify.

At least as of kernel 4.8, both notify_delete and notify_inval_inode result in a call to fuse_reverse_inval_entry() in the kernel. And that function calls fuse_invalidate_attr (to invalidate the attributes of the parent) and fuse_invalidate_entry (which removes the dentry from the hash via d_invalidate *and* marks it as stale).

The only difference is that when reverse_inval_entry is entered via notify_delete, it attempts to call d_delete (after the call to d_invalidate), which seems to have the effect of only calling fsnotify_nameremove().

John, are we missing something?

Best,
Nikolaus

Signature · 4 lines
GPG encrypted emails preferred. Key id: 0xD113FCAC3C4E599F
Fingerprint: ED31 791B 2C5C 1613 AF38 8B8A D113 FCAC 3C4E 599F

             »Time flies like an arrow, fruit flies like a Banana.«