// dentry tapset
// Copyright (c) 2009-2015 Red Hat Inc.
//
// This file is part of systemtap, and is free software. You can
// redistribute it and/or modify it under the terms of the GNU General
// Public License (GPL); either version 2, or (at your option) any
// later version.
%{
// Make sure the filesystem "magic" constants we use are defined.
#include <linux/magic.h>
#ifndef PIPEFS_MAGIC
#define PIPEFS_MAGIC 0x50495045
#endif
#ifndef SOCKFS_MAGIC
#define SOCKFS_MAGIC 0x534F434B
#endif
#ifndef ANON_INODE_FS_MAGIC
#define ANON_INODE_FS_MAGIC 0x09041934
#endif
#ifndef NSFS_MAGIC
#define NSFS_MAGIC 0x6e736673
#endif
%}
@__private30 function __dentry_IS_ROOT:long(dentry:long)
{
return (@cast(dentry, "dentry", "kernel")->d_parent == dentry)
}
@__private30 function __dentry_prepend:string(dentry:long,name:string)
{
dname = d_name(dentry)
/*
* In case we are following down a mount point trigger, we can get
* multiple instances of a root mount.
*/
c = substr(name, strlen(name)-1, strlen(name)-1)
if (dname == "/" && c == "/")
return name;
if (name == "") {
return dname;
} else {
return sprintf("%s/%s", dname, name);
}
}
/**
* sfunction d_name - get the dirent name
*
* Returns the dirent name (path basename).
* @dentry: Pointer to dentry.
*/
function d_name:string(dentry:long)
{
s = & @cast(dentry, "dentry", "kernel")->d_name;
return kernel_string_n(s->name, s->len);
}
@__private30 function __inode_first_dentry:long(inode:long)
{
/* i_dentry is an hlist_head on 3.6+, or a list_head before that. */
d_alias = @choose_defined(
@cast(inode, "struct inode", "kernel")->i_dentry->first,
@cast(inode, "struct inode", "kernel")->i_dentry->next)
if (@type_member_defined("struct dentry", d_alias)) {
return & @module_container_of(d_alias, "kernel<linux/dcache.h>", "struct dentry", d_alias)
}
else {
return & @module_container_of(d_alias, "kernel<linux/dcache.h>", "struct dentry", d_u->d_alias)
}
}
@__private30 function __inode_vfsmount:long(inode:long)
{
/* s_mounts was added in kernel 3.6, commit b3d9b7a3c. */
if (@type_member_defined("struct super_block", s_mounts)) {
mnt_ns = @cast(task_current(), "struct task_struct", "kernel<linux/sched.h>")->nsproxy->mnt_ns
sb = @cast(inode, "struct inode", "kernel")->i_sb
/* Look for the mount which matches the current namespace */
head = &sb->s_mounts
for (pos = head->next; pos != head; pos = pos->next) {
mount = & @container_of(pos, "struct mount", mnt_instance)
if (mount->mnt_ns == mnt_ns)
return & mount->mnt
}
}
return 0
}
/**
* sfunction inode_name - get the inode name
*
* Returns the first path basename associated with the given inode.
* @inode: Pointer to inode.
*/
function inode_name:string(inode:long)
{
return reverse_path_walk(__inode_first_dentry(inode))
}
/**
* sfunction inode_path - get the path to an inode
*
* Returns the full path associated with the given inode.
* @inode: Pointer to inode.
*/
function inode_path:string(inode:long)
{
dentry = __inode_first_dentry(inode)
vfsmount = __inode_vfsmount(inode)
if (vfsmount != 0)
return task_dentry_path(task_current(), dentry, vfsmount)
/* This is not really a full path... */
return reverse_path_walk(dentry)
}
/**
* sfunction reverse_path_walk - get the full dirent path
*
* Returns the path name (partial path to mount point).
* @dentry: Pointer to dentry.
*/
function reverse_path_walk:string(dentry:long)
{
while(1) {
name = __dentry_prepend(dentry, name);
dentry = @cast(dentry, "dentry", "kernel")->d_parent;
if (__dentry_IS_ROOT(dentry))
return name;
}
}
/**
* sfunction real_mount - get the 'struct mount' pointer
*
* Returns the 'struct mount' pointer value for a 'struct vfsmount'
* pointer.
* @vfsmnt: Pointer to 'struct vfsmount'
*/
function real_mount:long(vfsmnt:long)
{
if (@type_member_defined("mount", mnt_parent)) {
/*
* The following is the script language equivalent of:
*
* return container_of(vfsmnt, struct mount, mnt);
*
* We can't do the above because 'struct mount' is
* defined in a private header (in fs/mount.h). But,
* we can do the script language equivalent (because
* we've got dwarf info).
*
* More spelled out in C, the above would look like:
*
* return (vfsmnt - offsetof(struct mount, mnt));
*
* but here we're also making sure it won't wrap around.
*/
offset = @offsetof("mount", mnt)
if (vfsmnt < 0 || vfsmnt > offset)
return (vfsmnt - offset)
}
return 0
}
/**
* sfunction task_dentry_path - get the full dentry path
*
* Returns the full dirent name (full path to the root), like
* the kernel d_path function.
* @task: task_struct pointer.
* @dentry: direntry pointer.
* @vfsmnt: vfsmnt pointer.
*/
function task_dentry_path:string(task:long,dentry:long,vfsmnt:long)
{
/*
* Note that this function is based on __d_path() in RHEL6-era kernels
* and prepend_path() in RHEL7+ kernels.
*/
/*
* There are various synthetic filesystems that never get
* mounted. Filesystems needing to implement special "root
* names" do so with dentry->d_op->d_dname(). Unfortunately,
* it isn't really safe for us to call
* dentry->d_op->d_dname(). We can't really validate the
* function pointer or know that it can be called safely in
* the current context.
*
* Some pseudo inodes are mountable. When they are mounted,
* dentry == vfsmnt->mnt_root. In that case, we'll just go
* ahead and handle them normally.
*/
dentry = & @cast(dentry, "dentry", "kernel")
vfsmnt = & @cast(vfsmnt, "vfsmount", "kernel")
if (@type_member_defined("dentry", d_op->d_dname)
&& dentry->d_op && dentry->d_op->d_dname
&& (!__dentry_IS_ROOT(dentry) || dentry != vfsmnt->mnt_root)) {
// The following code hits the majority of synthetic
// filesystems that need special handling. As
// mentioned earlier, we'd like to call d_dname()
// here, but it isn't safe.
if (vfsmnt->mnt_sb->s_magic == @const("SOCKFS_MAGIC")) {
return sprintf("socket:[%lu]", dentry->d_inode->i_ino)
}
else if (vfsmnt->mnt_sb->s_magic == @const("PIPEFS_MAGIC")) {
return sprintf("pipe:[%lu]", dentry->d_inode->i_ino)
}
else if (vfsmnt->mnt_sb->s_magic
== @const("ANON_INODE_FS_MAGIC")) {
return sprintf("ANON_INODE:%s", d_name(dentry))
}
else if (vfsmnt->mnt_sb->s_magic == @const("NSFS_MAGIC")) {
ns_ops = &@cast(dentry->d_fsdata, "proc_ns_operations", "kernel")
return sprintf("%s:[%lu]", kernel_string(ns_ops->name),
dentry->d_inode->i_ino)
}
return sprintf("UNKNOWN:[%p]", dentry)
}
# Handle old-school vs. new-school fs_structs.
if (@type_member_defined("fs_struct", rootmnt)) {
root_dentry = & @cast(task, "task_struct", "kernel")->fs->root
root_vfsmnt = & @cast(task, "task_struct", "kernel")->fs->rootmnt
}
else {
root_dentry = @cast(task, "task_struct", "kernel")->fs->root->dentry
root_vfsmnt = @cast(task, "task_struct", "kernel")->fs->root->mnt
}
if (@type_member_defined("mount", mnt_parent)) {
mnt = &@cast(real_mount(vfsmnt), "mount", "kernel")
if (mnt == 0)
return "<unknown>"
}
# If we've found the right dentry/vfsmnt, we're done.
while (dentry != root_dentry || vfsmnt == root_vfsmnt) {
if (dentry == vfsmnt->mnt_root || __dentry_IS_ROOT(dentry)) {
/* Escaped? */
if (dentry != vfsmnt->mnt_root) {
return "<unknown>"
}
/* RHEL7+ kernels */
if (! @type_member_defined("vfsmount", mnt_parent)) {
/* Global root? */
if (mnt != mnt->mnt_parent) {
dentry = mnt->mnt_mountpoint
vfsmnt = & mnt->mnt_parent->mnt
mnt = mnt->mnt_parent
if (mnt == 0)
return "<unknown>"
continue
}
break
}
}
name = __dentry_prepend(dentry, name)
dentry = dentry->d_parent
}
return sprintf("/%s", name);
}
/**
* sfunction d_path - get the full nameidata path
*
* Returns the full dirent name (full path to the root), like
* the kernel d_path function.
* @nd: Pointer to nameidata.
*/
function d_path:string(nd:long)
{
dentry = @choose_defined(@cast(nd,"nameidata", "kernel")->path->dentry,
@cast(nd,"nameidata", "kernel")->dentry)
vfsmnt = @choose_defined(@cast(nd,"nameidata", "kernel")->path->mnt,
@cast(nd,"nameidata", "kernel")->mnt)
return sprintf("%s/", task_dentry_path(task_current(), dentry, vfsmnt))
}
/**
* sfunction fullpath_struct_nameidata - get the full nameidata path
*
* Returns the full dirent name (full path to the root), like
* the kernel (and systemtap-tapset) d_path function, with a "/".
* @nd: Pointer to "struct nameidata".
*/
function fullpath_struct_nameidata(nd)
{
return d_path(nd)
}
/**
* sfunction fullpath_struct_path - get the full path
*
* Returns the full dirent name (full path to the root), like
* the kernel d_path function.
* @path: Pointer to "struct path".
*/
function fullpath_struct_path:string(path:long)
{
return task_dentry_path(task_current(),
@cast(path,"path","kernel:nfs:kernel<linux/path.h>")->dentry,
@cast(path,"path","kernel:nfs:kernel<linux/path.h>")->mnt)
}
/**
* sfunction fullpath_struct_file - get the full path
*
* Returns the full dirent name (full path to the root), like
* the kernel d_path function.
* @task: task_struct pointer.
* @file: Pointer to "struct file".
*/
function fullpath_struct_file:string(task:long, file:long)
{
return task_dentry_path(task,
@choose_defined(@cast(file, "file", "kernel")->f_path->dentry,
@cast(file, "file", "kernel")->f_dentry),
@choose_defined(@cast(file, "file", "kernel")->f_path->mnt,
@cast(file, "file", "kernel")->f_vfsmnt))
}