helper: partially follow link in path_lookup

[Wengang-oracle]

Current path_lookup() doesn't follow symbol links. The symbol link following is FS specific, it's hard and not neccesary to support all file systems. This patch supports:

1. EXT4 simple symbol link (target path stored in inode.i_link).
2. XFS inlined symbol link.

Signed-off-by: Wengang Wang [email protected]
Reviewed-by: Stephen Brennan [email protected]

[osandov]

This is a very cool but very tricky feature. I left a few comments.

Repeating what I mentioned inline, I'd like to have an inode_readlink() helper first so we can test that independently, then add this.

[osandov]

This should probably be:

Suggested change

	return inode.i_link
	return inode.i_link.string_()

[osandov]

This deserves to be a public helper. Could you please name this inode_readlink(), document it, and add it to __all__? We should do that before adding symlink lookups to path_lookup(). That can be in a separate PR or a separate commit before this one in this PR, it's up to you.

Then, we can figure out how to write some tests for it.

[osandov]

Please document which commit changed this. See drgn.helpers.linux.sched.task_state_to_char() for an example:

drgn/drgn/helpers/linux/sched.py

Lines 59 to 67 in 220c1c7

	# Since Linux kernel commit 2f064a59a11f ("sched: Change
	# task_struct::state") (in v5.14), the task state is named "__state".
	# Before that, it is named "state".
	try:
	task_state = task.__state
	task_state_name = "__state"
	except AttributeError:
	task_state = task.state
	task_state_name = "state"

[osandov]

Use a try/except AttributeError instead of hasattr() ("easier to ask for forgiveness than permission").

[osandov]

This will redo the entire lookup up to the symlink, right? That sounds pretty inefficient (and racy on live systems), especially if there are multiple symlinks in the path traversal.

There are probably multiple ways to avoid this, but the one that comes to mind is to keep a stack of names being resolved and avoid recursion. Something like:

class PathLookupName:
    def __init__(self, name: str) -> None:
        self.components = name.split(b"/")
        self.index = 0

name_stack = [PathLookupName(os.fsencode(path))]
while name_stack:
    name = name_stack[-1]
    if name.index >= len(name.components):
        name_stack.pop()
        continue

    component = name_stack.components[name.index]
    name.index += 1

    ... handle component ...

    if is_symlink(...):
        link_target = ...
        name_stack.push(PathLookupName(link_target))
        if link_target.startswith(b"/"):
            # Restart at the root.
            mnt = root_mnt
            dentry = root_dentry

I think that general idea will work. We also need to be careful about cycles (the kernel handles this by returning ELOOP if it encounters too many symlinks.)

This is going to need lots of test cases 😄