I agree.

You're right, the issue on the FreeBSD jail is fstab, not mnttab. Ignore what I said.

I still don't really like the assumption "no mountpoint found for a given path => we're on android" in a comment. I bet there are other corner cases where this can happen. If you really want to find out you're on android, surely there's Q_OS_ANDROID. Or until we find out what those other corner cases are, the code can stay, but the comment should say "for instance" or "maybe", not "can only mean".

You forgot to update lastMountPointUpdate here.

And to avoid calling currentDateTime() twice (this is a relatively slow method), make sure to put the result into a local var used in both places.

OK, but I still read "can only mean" like a possibly incorrect assumption.

I suggest s/can only mean/for instance/

Did you mean || ?

Otherwise this changes the behaviour also on fast local paths (when SkipMimeTypeFromContent is set).

Then again, D19887 (which introduced this if) was apparently about network mounts.

I don't really like the name, it's non-obvious until reading the documentation.
Maybe it should be findByPath(path, KMountPoint::DontResolveSymlinks) ?
(with a 2-args findByPath overload and a KF6 TODO to merge the two)

I see. Sorry, I hadn't realized that there is a Q_OS_ANDROID check in kmountpoint itself.

Compared to canonicalPath, this only works if the very last component is a symlink.

If I make /home/dfaure a symlink to /opt/dfaure (because I have more disk space there), then findByPath("/home/dfaure/Documents/foo.odt") used to return the mountpoint for /opt (which was correct) while now it will return the mount point for /home.
isSymlink() will say false because foo.odt isn't a symlink.

I don't see a perfect solution to this. The best we can do IMHO is make things work for local symlinked directories and for remote mounts, but we can't fully avoid slow calls in the case of symlinks-to-remote-mounts.

So I would just call canonicalPath here, once we find out that the orig path isn't a slow mount. Yes it might point to a slow mount, but IMHO that's the user asking for (performance) trouble :)

Hmm, what if the symlink *is* the very last component, like your previous iteration tried to handle?

I don't want to be a pain, but this is still wrong....

If /home/dfaure is a symlink to /opt/dfaure, and then /opt/dfaure/tmp is a symlink to /tmp, then the canonical path (and therefore the mount point) for /home/dfaure/tmp is in fact /tmp.

But this is going to call findByPath(/opt/dfaure) (the symlink target of the first symlink found in the path), and stop there, assuming that everything at that target is part of the same mountpoint, which isn't necessarily the case.

I guess this should be findByPath(symLinkTarget() + remainder_of_path)

One possible objection is a case like /a/b/c/d/e/f/g where g is a symlink to h (in the same directory), because then both levels of recursion will stat a, b, c, d, e, f. But maybe this is unavoidable. I don't know how clever canonicalPath() implementations are to optimize such things, while still allowing for /a/b/c/d/e to be a symlink to something totally different, like /x/y, where /x itself might be a symlink (!!).
OK so maybe the recursion and redoing the stat's for all levels is correct.

You should rename this variable, it's no longer the result of canonicalFilePath() (also called "realpath" in glibc).

Missing @since

This is BIC, you changed the signature of an existing exported method.

You need to overload it, instead.
i.e. add a method with two args, and a comment like

// TODO KF6 merge with the above method using RealMountPoint as default value

(and a @since flag of course)