FM / process

/usr/share/systemtap/examples/process

Name	Size	Mode	Actions
auditbt.meta	429	0644	edit dl rm
auditbt.stp	622	0755	edit dl rm
auditbt.tcl	79	0644	edit dl rm
chng_cpu.meta	775	0644	edit dl rm
chng_cpu.stp	1049	0755	edit dl rm
chng_cpu.tcl	140	0644	edit dl rm
cycle_thief.meta	1082	0644	edit dl rm
cycle_thief.stp	2893	0755	edit dl rm
cycle_thief.txt	5974	0644	edit dl rm
errsnoop.meta	575	0644	edit dl rm
errsnoop.stp	1015	0755	edit dl rm
forktracker.meta	525	0644	edit dl rm
forktracker.stp	601	0755	edit dl rm
futexes.meta	520	0644	edit dl rm
futexes.stp	1118	0755	edit dl rm
futexes.txt	944	0644	edit dl rm
futexes2.meta	593	0644	edit dl rm
futexes2.stp	2014	0644	edit dl rm
ltrace.meta	314	0644	edit dl rm
ltrace.stp	3007	0755	edit dl rm
ltrace.tcl	122	0644	edit dl rm
migrate.meta	746	0644	edit dl rm
migrate.stp	1037	0755	edit dl rm
mutex-contention.meta	479	0644	edit dl rm
mutex-contention.stp	5559	0755	edit dl rm
mutex-contention.tcl	79	0644	edit dl rm
noptrace.meta	512	0644	edit dl rm
noptrace.stp	2235	0755	edit dl rm
noptrace.txt	1212	0644	edit dl rm
pfiles.meta	450	0644	edit dl rm
pfiles.stp	24523	0755	edit dl rm
plimit.meta	387	0644	edit dl rm
plimit.stp	3029	0755	edit dl rm
procmod_watcher.meta	657	0644	edit dl rm
procmod_watcher.stp	2406	0644	edit dl rm
proctop.meta	601	0644	edit dl rm
proctop.stp	4245	0755	edit dl rm
proctop.txt	8654	0644	edit dl rm
proc_snoop.stp	1133	0755	edit dl rm
proc_snoop_parser.xml	818	0644	edit dl rm
proc_snoop_parser_instructions.txt	2180	0644	edit dl rm
psig.meta	354	0644	edit dl rm
psig.stp	5616	0755	edit dl rm
pstrace_exec.meta	545	0644	edit dl rm
pstrace_exec.stp	465	0755	edit dl rm
pstree.meta	455	0644	edit dl rm
pstree.stp	1957	0755	edit dl rm
rlimit_nofile.meta	319	0644	edit dl rm
rlimit_nofile.stp	1151	0755	edit dl rm
sched-latency.meta	470	0644	edit dl rm
sched-latency.stp	508	0644	edit dl rm
sched-latency.txt	1566	0644	edit dl rm
schedtimes.meta	814	0644	edit dl rm
schedtimes.stp	3949	0755	edit dl rm
schedtimes.txt	3278	0644	edit dl rm
semop-watch.meta	267	0644	edit dl rm
semop-watch.stp	822	0755	edit dl rm
sigkill.meta	560	0644	edit dl rm
sigkill.stp	656	0755	edit dl rm
sigmon.meta	669	0644	edit dl rm
sigmon.stp	932	0755	edit dl rm
sig_by_pid.meta	357	0644	edit dl rm
sig_by_pid.stp	1078	0755	edit dl rm
sig_by_pid.txt	1514	0644	edit dl rm
sig_by_proc.meta	364	0644	edit dl rm
sig_by_proc.stp	851	0755	edit dl rm
sig_by_proc.txt	951	0644	edit dl rm
sleepingBeauties.meta	581	0644	edit dl rm
sleepingBeauties.stp	1364	0755	edit dl rm
sleepingBeauties.tcl	140	0644	edit dl rm
sleeptime.meta	601	0644	edit dl rm
sleeptime.stp	1469	0755	edit dl rm
spawn_seeker.meta	854	0644	edit dl rm
spawn_seeker.stp	1526	0755	edit dl rm
spawn_seeker.txt	1318	0644	edit dl rm
strace.meta	385	0644	edit dl rm
strace.stp	2081	0755	edit dl rm
strace.txt	3672	0644	edit dl rm
syscalls_by_pid.meta	514	0644	edit dl rm
syscalls_by_pid.stp	633	0755	edit dl rm
syscalls_by_pid.txt	597	0644	edit dl rm
syscalls_by_proc.meta	531	0644	edit dl rm
syscalls_by_proc.stp	692	0755	edit dl rm
syscalls_by_proc.txt	1130	0644	edit dl rm
syscalltimes	6291	0755	edit dl rm
syscalltimes.meta	454	0644	edit dl rm
syscalltimes.txt	11459	0644	edit dl rm
thread-business.meta	346	0644	edit dl rm
thread-business.stp	866	0755	edit dl rm
thread-business.txt	2823	0644	edit dl rm
threadstacks.meta	585	0644	edit dl rm
threadstacks.stp	1789	0755	edit dl rm
threadstacks.tcl	79	0644	edit dl rm
wait4time.meta	658	0644	edit dl rm
wait4time.stp	1347	0755	edit dl rm

Edit: /usr/share/systemtap/examples/process/pfiles.stp (24523B)

# pfiles.stp
# Copyright (C) 2007-2010, 2012, 2015-2019 Red Hat, Inc., Eugene Teo
# <eteo@redhat.com>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.

# Example:
# $ stap -g pfiles.stp `pgrep udevd`
# OR
# $ stap -g pfiles.stp -x `pgrep udevd`

#
# pfiles.stp report information for all open files by the process id.
#
# pfiles.stp is not a port of Solaris' pfiles tool. It was written based
# on the example outputs in:
# - https://bugzilla.redhat.com/show_bug.cgi?id=223489
# - http://blogs.sun.com/peteh/entry/pfiles_1_locked_files_and
# - http://lists.samba.org/archive/samba-technical/2001-May/014293.html
# - http://mail.gnome.org/archives/gconf-list/2004-December/msg00005.html
#
# pfiles.stp is able to:
# - report locked open files
# - report pathname information
# - report socket information (thanks Luis Henriques)
# - report sk_userlocks (thanks Arnaldo Carvalho de Melo)
# - report socket options
#
# Example:
# $ stap -g pfiles.stp `pgrep udevd`
#    787: udevd
#   Current rlimit: 32 file descriptors
#    0: S_IFCHR mode:0666 dev:0,15 ino:396 uid:0 gid:0 rdev:1,3
#       O_RDWR|O_LARGEFILE 
#       /dev/null
#    1: S_IFCHR mode:0666 dev:0,15 ino:396 uid:0 gid:0 rdev:1,3
#       O_RDWR|O_LARGEFILE 
#       /dev/null
#    2: S_IFCHR mode:0666 dev:0,15 ino:396 uid:0 gid:0 rdev:1,3
#       O_RDWR|O_LARGEFILE 
#       /dev/null
#    3: S_IFDIR mode:0600 dev:0,9 ino:1 uid:0 gid:0 rdev:0,0
#       O_RDONLY 
#       inotify
#    4: S_IFSOCK mode:0777 dev:0,4 ino:2353 uid:0 gid:0 rdev:0,0
#       O_RDWR 
#       socket:[2353]
#       SO_PASSCRED,SO_TYPE(2),SO_SNDBUF(111616),SO_RCVBUF(111616)
#         sockname: AF_UNIX
#    5: S_IFSOCK mode:0777 dev:0,4 ino:2354 uid:0 gid:0 rdev:0,0
#       O_RDWR 
#       socket:[2354]
#       SO_TYPE(2),SO_SNDBUF(111616),SO_RCVBUF(33554432)
#         ulocks: rcv
#    6: S_IFIFO mode:0600 dev:0,6 ino:2355 uid:0 gid:0 rdev:0,0
#       O_RDONLY|O_NONBLOCK 
#       pipe:[2355]
#    7: S_IFIFO mode:0600 dev:0,6 ino:2355 uid:0 gid:0 rdev:0,0
#       O_WRONLY|O_NONBLOCK 
#       pipe:[2355]
#
# I used Andrew Tridgell's locktst.c to test the advisory lock code.
# You can download it at http://samba.org/ftp/unpacked/junkcode/locktst.c
#
# $ ./locktst file &
# fcntl_lock 3 6 1 1 1
# $ pfiles 10126 | grep advisory -A1 -B2
#   3: S_IFREG mode:0644 dev:253,0 ino:15237159 uid:500 gid:500 rdev:0,0
#      O_RDWR 
#      advisory write lock set by process 10126
#      /home/eteo/pfiles/file
#

%{
#include <linux/file.h>
#include <net/sock.h>
#include <linux/un.h>
#include <linux/tcp.h>
#ifdef CONFIG_USER_NS
#include <linux/user_namespace.h>
#endif
#ifdef STAPCONF_LINUX_UIDGID_H
#include <linux/uidgid.h>
#endif
%}

# XXX: For the time being, mark this example as not working on PREEMPT_RT kernels:
%{
#if defined(CONFIG_PREEMPT_RT_FULL) || defined(CONFIG_PREEMPT_RT)
#error "pfiles.stp not supported on PREEMPT_RT kernels"
#endif
%}

function task_valid_file_handle:long (task:long, fd:long) %{ /* pure */
	struct task_struct *p = (struct task_struct *)((long)STAP_ARG_task);
	struct files_struct *files;
	struct file *filp;

rcu_read_lock();
	if ((files = kread(&p->files))) {
		filp = fcheck_files(files, STAP_ARG_fd);
		STAP_RETVALUE = !!filp;
	}

CATCH_DEREF_FAULT();
	rcu_read_unlock();
%}

function i_mode2str:string (i_mode:long) {
	if (%{ S_ISLNK(STAP_ARG_i_mode) %})
		return "S_IFLNK"
	if (%{ S_ISREG(STAP_ARG_i_mode) %})
		return "S_IFREG"
	if (%{ S_ISDIR(STAP_ARG_i_mode) %})
		return "S_IFDIR"
	if (%{ S_ISCHR(STAP_ARG_i_mode) %})
		return "S_IFCHR"
	if (%{ S_ISBLK(STAP_ARG_i_mode) %})
		return "S_IFBLK"
	if (%{ S_ISFIFO(STAP_ARG_i_mode) %})
		return "S_IFIFO"
	if (%{ S_ISSOCK(STAP_ARG_i_mode) %})
		return "S_IFSOCK"
}

function task_file_handle_i_mode:long (task:long, fd:long) %{ /* pure */
	struct task_struct *p = (struct task_struct *)((long)STAP_ARG_task);
	struct files_struct *files;
	struct file *filp;
	struct dentry *dentry;
	struct inode *inode;

CATCH_DEREF_FAULT();
	rcu_read_unlock();
%}

function task_file_handle_majmin_dev:string (task:long, fd:long) %{ /* pure */
	struct task_struct *p = (struct task_struct *)((long)STAP_ARG_task);
	struct files_struct *files;
	struct file *filp;
	struct dentry *dentry;
	struct inode *inode;
	struct super_block *sb;
	int dev_nr;

rcu_read_lock();
	if ((files = kread(&p->files)) &&
	    (filp = fcheck_files(files, STAP_ARG_fd)) &&
#ifdef STAPCONF_DPATH_PATH
	    (dentry = kread(&filp->f_path.dentry)) &&
#else
	    (dentry = kread(&filp->f_dentry)) &&
#endif
	    (inode = kread(&dentry->d_inode)) &&
	    (sb = kread(&inode->i_sb))) {
		dev_nr = kread(&sb->s_dev);
		snprintf(STAP_RETVALUE, MAXSTRINGLEN,
			"%d,%d", MAJOR(dev_nr), MINOR(dev_nr));
	}

CATCH_DEREF_FAULT();
	rcu_read_unlock();
%}

function task_file_handle_majmin_rdev:string (task:long, fd:long) %{ /* pure */
	struct task_struct *p = (struct task_struct *)((long)STAP_ARG_task);
	struct files_struct *files;
	struct file *filp;
	struct dentry *dentry;
	struct inode *inode;
	int rdev_nr;

rcu_read_lock();
	if ((files = kread(&p->files)) &&
	    (filp = fcheck_files(files, STAP_ARG_fd)) &&
#ifdef STAPCONF_DPATH_PATH
	    (dentry = kread(&filp->f_path.dentry)) &&
#else
	    (dentry = kread(&filp->f_dentry)) &&
#endif
	    (inode = kread(&dentry->d_inode))) {
		rdev_nr = kread(&inode->i_rdev);
		snprintf(STAP_RETVALUE, MAXSTRINGLEN,
			"%d,%d", MAJOR(rdev_nr), MINOR(rdev_nr));
	}

CATCH_DEREF_FAULT();
	rcu_read_unlock();
%}

function task_file_handle_i_node:long (task:long, fd:long) %{ /* pure */
	struct task_struct *p = (struct task_struct *)((long)STAP_ARG_task);
	struct files_struct *files;
	struct file *filp;
	struct dentry *dentry;
	struct inode *inode;

CATCH_DEREF_FAULT();
	rcu_read_unlock();
%}

function task_file_handle_uid:long (task:long, fd:long) %{ /* pure */
	struct task_struct *p = (struct task_struct *)((long)STAP_ARG_task);
	struct files_struct *files;
	struct file *filp;
#ifdef CONFIG_USER_NS
	struct user_namespace *ns = NULL;
#endif

rcu_read_lock();
	if ((files = kread(&p->files)) &&
	    (filp = fcheck_files(files, STAP_ARG_fd))) {
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,29)
		/* git commit d76b0d9b */
		const struct cred *cred;
		if ((cred = kread(&filp->f_cred))) {
#ifdef CONFIG_USER_NS
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 29)
			ns = p->nsproxy->user_ns;
#else
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 39)
			ns = (task_cred_xxx(p, user))->user_ns;
#else /* LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 39) */
			ns = task_cred_xxx(p, user_ns);
#endif
#endif
			if (ns) {
				get_user_ns(ns);
				// We call kderef_buffer() here to
				// ensure the memory at the kuid_t
				// location is valid to read. We can't
				// use kderef()/kread(), since they
				// only handle data with a size of 1,
				// 2, 4, or 8 bytes.
				kderef_buffer(NULL,  &cred->fsuid,
					      sizeof(cred->fsuid));
				STAP_RETVALUE = from_kuid_munged(ns,
								 cred->fsuid);
			}
			else
				STAP_RETVALUE = -1;

#else	/* ! CONFIG_USER_NS */
			STAP_RETVALUE = kread(&cred->fsuid);
#endif	/* ! CONFIG_USER_NS */
		}
#else
		STAP_RETVALUE = kread(&filp->f_uid);
#endif
	}

CATCH_DEREF_FAULT();
#ifdef CONFIG_USER_NS
	if (ns)
		put_user_ns(ns);
#endif
	rcu_read_unlock();
%}

function task_file_handle_gid:long (task:long, fd:long) %{ /* pure */
	struct task_struct *p = (struct task_struct *)((long)STAP_ARG_task);
	struct files_struct *files;
	struct file *filp;
#ifdef CONFIG_USER_NS
	struct user_namespace *ns = NULL;
#endif

rcu_read_lock();
	if ((files = kread(&p->files)) &&
	    (filp = fcheck_files(files, STAP_ARG_fd))) {
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,29)
		/* git commit d76b0d9b */
		const struct cred *cred;
		if ((cred = kread(&filp->f_cred))) {
#ifdef CONFIG_USER_NS
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 29)
			ns = p->nsproxy->user_ns;
#else
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 39)
			ns = (task_cred_xxx(p, user))->user_ns;
#else /* LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 39) */
			ns = task_cred_xxx(p, user_ns);
#endif
#endif
			if (ns) {
				get_user_ns(ns);
				// We call kderef_buffer() here to
				// ensure the memory at the kgid_t
				// location is valid to read. We can't
				// use kderef()/kread(), since they
				// only handle data with a size of 1,
				// 2, 4, or 8 bytes.
				kderef_buffer(NULL,  &cred->fsgid,
					      sizeof(cred->fsgid));
				STAP_RETVALUE = from_kgid_munged(ns,
								 cred->fsgid);
			}
			else
				STAP_RETVALUE = -1;

#else	/* ! CONFIG_USER_NS */
			STAP_RETVALUE = kread(&cred->fsgid);
#endif	/* ! CONFIG_USER_NS */
		}
#else
		STAP_RETVALUE = kread(&filp->f_gid);
#endif
	}

CATCH_DEREF_FAULT();
#ifdef CONFIG_USER_NS
	if (ns)
		put_user_ns(ns);
#endif
	rcu_read_unlock();
%}

function task_file_handle_f_flags:long (task:long, fd:long) %{ /* pure */
	struct task_struct *p = (struct task_struct *)((long)STAP_ARG_task);
	struct files_struct *files;
	struct file *filp;

rcu_read_lock();
	if ((files = kread(&p->files)) &&
	    (filp = fcheck_files(files, STAP_ARG_fd))) {
		STAP_RETVALUE = kread(&filp->f_flags);
	}

CATCH_DEREF_FAULT();
	rcu_read_unlock();
%}

function task_file_handle_fd_flags:string (task:long, fd:long) %{ /* pure */
	struct task_struct *p = (struct task_struct *)((long)STAP_ARG_task);
	struct files_struct *files;
	struct fdtable *fdt;
	int gcoe;

rcu_read_lock();
	if ((files = kread(&p->files)) &&
	    (fdt = files_fdtable(files))) {
		/* Use test_bit directly instead of FD_ISSET which might
		   not be defined on some kernels.  */
		unsigned long *bs = (unsigned long *)kread(&fdt->close_on_exec);
		gcoe = test_bit(STAP_ARG_fd, bs);
		snprintf(STAP_RETVALUE, MAXSTRINGLEN,
			"%s", gcoe ? "FD_CLOEXEC" : "");
	}

CATCH_DEREF_FAULT();
	rcu_read_unlock();
%}

function task_file_handle_flock:string (task:long, fd:long) %{ /* pure */
	struct task_struct *p = (struct task_struct *)((long)STAP_ARG_task);
	struct files_struct *files;
	struct file_lock *flock;
	int fl_type = -1;
	int fl_pid = -1;
	struct file *filp;
	struct dentry *dentry;
	struct inode *inode;
#if LINUX_VERSION_CODE >= KERNEL_VERSION(4,0,0)
	struct file_lock_context *ctx;
	int flc_lock_set = 0;
#endif

rcu_read_lock();
	if ((files = kread(&p->files)) &&
	    (filp = fcheck_files(files, STAP_ARG_fd)) &&
#ifdef STAPCONF_DPATH_PATH
	    (dentry = kread(&filp->f_path.dentry)) &&
#else
	    (dentry = kread(&filp->f_dentry)) &&
#endif
	    (inode = kread(&dentry->d_inode))) {
// In kernels >= 4.0, we've now got a list of file_lock structures.
#if LINUX_VERSION_CODE >= KERNEL_VERSION(4,0,0)
		if ((ctx = kread(&inode->i_flctx))) {
			struct file_lock *lock;

// Make sure the file_lock_context struct is valid.
			kderef_buffer(NULL, ctx,
				      sizeof(struct file_lock_context));

// We'll just look at the first lock.
			spin_lock(&ctx->flc_lock);
			flc_lock_set = 1;
			list_for_each_entry(lock, &ctx->flc_flock, fl_list) {
				fl_type = kread(&lock->fl_type);
				fl_pid = kread(&lock->fl_pid);
				break;
			}
			spin_unlock(&ctx->flc_lock);
			flc_lock_set = 0;
		}
#else
		if ((flock = kread(&inode->i_flock))) {
			fl_type = kread(&flock->fl_type);
			fl_pid = kread(&flock->fl_pid);
		}
#endif

if (fl_type != -1) { /* !flock */
			snprintf(STAP_RETVALUE, MAXSTRINGLEN,
				"      advisory %s lock set by process %d",
				fl_type ? "write" : "read", fl_pid);
		} else {
			snprintf(STAP_RETVALUE, MAXSTRINGLEN, "NULL");
		}
	}

CATCH_DEREF_FAULT();
#if LINUX_VERSION_CODE >= KERNEL_VERSION(4,0,0)
	if (flc_lock_set)
		spin_unlock(&ctx->flc_lock);
#endif
	rcu_read_unlock();
%}

function task_file_handle_d_path:string (task:long, fd:long) %{ /* pure */
	struct task_struct *p = (struct task_struct *)((long)STAP_ARG_task);
	struct files_struct *files;
	char *page = NULL;
	struct file *filp;
	struct dentry *dentry;
	struct vfsmount *vfsmnt;
	char *path = NULL;

rcu_read_lock();
	if ((files = kread(&p->files)) &&
	    // We need GFP_ATOMIC since we're inside a lock so we
	    // can't sleep.
	    (page = (char *)__get_free_page(GFP_ATOMIC)) &&
	    (filp = fcheck_files(files, STAP_ARG_fd))) {

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,26)
		/* git commit 9d1bc601 */
		path = d_path(&filp->f_path, page, PAGE_SIZE);
#else
		dentry = kread(&filp->f_dentry);
		vfsmnt = kread(&filp->f_vfsmnt);

if (dentry && vfsmnt) {
			path = d_path(dentry, vfsmnt, page, PAGE_SIZE);
		}
#endif
		if (path && !IS_ERR(path)) {
			snprintf(STAP_RETVALUE, MAXSTRINGLEN, "%s", path);
		}
	}
	CATCH_DEREF_FAULT();

if (page) free_page((unsigned long)page);

rcu_read_unlock();
%}

function task_file_handle_socket:long (task:long, fd:long) %{ /* pure */
	struct task_struct *p = (struct task_struct *)((long)STAP_ARG_task);
	struct files_struct *files;
	struct file *filp;
	struct dentry *dentry;
	struct inode *inode;

rcu_read_lock();
	if ((files = kread(&p->files)) &&
	    (filp = fcheck_files(files, STAP_ARG_fd)) &&
#ifdef STAPCONF_DPATH_PATH
	    (dentry = kread(&filp->f_path.dentry)) &&
#else
	    (dentry = kread(&filp->f_dentry)) &&
#endif
	    (inode = kread(&dentry->d_inode))) {
		if (S_ISSOCK(kread(&inode->i_mode)))
			STAP_RETVALUE = (long)SOCKET_I(inode);
	}

CATCH_DEREF_FAULT();
	rcu_read_unlock();
%}

function socket_userlocks:string (sock:long) %{ /* pure */
	struct socket *sock = (struct socket *)((long)STAP_ARG_sock);
	struct sock *sk = (struct sock *)kread(&sock->sk);
	unsigned char locks = sk->sk_userlocks;
	int printed = 0;

STAP_RETVALUE[0] = '\0';

if (locks & SOCK_RCVBUF_LOCK)
		printed = snprintf(STAP_RETVALUE, MAXSTRINGLEN,
			"ulocks: rcv");

if (locks & SOCK_SNDBUF_LOCK)
		snprintf(STAP_RETVALUE, MAXSTRINGLEN,
			"ulocks: %ssnd",
			printed ? "rcv, " : "");

CATCH_DEREF_FAULT();
%}

function socket_optname:string (sock:long) %{ /* pure */
    struct socket *sock = (struct socket *)((long)STAP_ARG_sock);
    int optval;
    int optlen;
    int ret, a;
    char str[30];
    struct linger ling;
    struct optname_item {
        int optfam;
        int optnum;
        const char *optname;
        int show_val;
    } const *p;
    static const struct optname_item optname_entries[] = {
        { SOL_SOCKET, SO_DEBUG,     "SO_DEBUG",     0 },
        { SOL_SOCKET, SO_REUSEADDR, "SO_REUSEADDR", 0 },
        { SOL_SOCKET, SO_DONTROUTE, "SO_DONTROUTE", 0 },
        { SOL_SOCKET, SO_BROADCAST, "SO_BROADCAST", 0 },
        { SOL_SOCKET, SO_KEEPALIVE, "SO_KEEPALIVE", 0 },
        { SOL_SOCKET, SO_OOBINLINE, "SO_OOBINLINE", 0 },
        { SOL_SOCKET, SO_PASSCRED,  "SO_PASSCRED",  0 },
/*      { SOL_SOCKET, SO_SNDLOWAT,  "SO_SNDLOWAT",  0 },*/
        { SOL_SOCKET, SO_TYPE,      "SO_TYPE",      1 },
        { SOL_SOCKET, SO_ERROR,     "SO_ERROR",     1 },
        { SOL_SOCKET, SO_SNDBUF,    "SO_SNDBUF",    1 },
        { SOL_SOCKET, SO_RCVBUF,    "SO_RCVBUF",    1 },
        { SOL_SOCKET, SO_NO_CHECK,  "SO_NO_CHECK",  1 },
        { SOL_TCP,    TCP_NODELAY,  "TCP_NODELAY",  0 },
        { 0, 0, NULL, 0 },
    };

for (p = optname_entries; p->optname; ++p) {
       optlen = sizeof(optval);
       ret = kernel_getsockopt(sock, p->optfam, p->optnum, (char *)&optval, &optlen);
       if (ret == 0 && optval != 0) {
           if (!p->show_val)
               snprintf(str, MAXSTRINGLEN, "%s,", p->optname);
           else
               snprintf(str, MAXSTRINGLEN, "%s(%d),", p->optname, optval);
           strcat(STAP_RETVALUE, str);
       }
    }

optlen = sizeof(ling);
    ret = kernel_getsockopt(sock, SOL_SOCKET, SO_LINGER, (void *)&ling, &optlen);
    if (ret == 0 && ling.l_onoff != 0) {
        snprintf(str, MAXSTRINGLEN, "SO_LINGER(%d),", ling.l_linger);
        strcat(STAP_RETVALUE, str);
    }

STAP_RETVALUE[strlen(STAP_RETVALUE) - 1] = '\0';
%}

function socket_family:long (sock:long) %{ /* pure */
	struct socket *sock = (struct socket *)((long)STAP_ARG_sock);
	const struct proto_ops *ops = kread(&sock->ops);
	STAP_RETVALUE = (long)kread(&ops->family);
	CATCH_DEREF_FAULT();
%}

function socket_unix_sockname:string (sock:long) %{ /* pure */
	struct socket *sock = (struct socket *)((long)STAP_ARG_sock);
	const struct proto_ops *ops = kread(&sock->ops);
	struct sockaddr_un un_addr;
	int err, len;

#if LINUX_VERSION_CODE >= KERNEL_VERSION(4,17,0)
	err = ops->getname(sock, (struct sockaddr *)(&un_addr), 0);
#else
	err = ops->getname(sock, (struct sockaddr *)(&un_addr), &len, 0);
#endif
//	err = kernel_getsockname(kread(&sock), (struct sockaddr *)(&un_addr), &len);
	if (!(err < 0)) {
		if (kread(&un_addr.sun_path[0]) != 0)
			snprintf(STAP_RETVALUE, MAXSTRINGLEN,
				"        sockname: AF_UNIX %s", un_addr.sun_path);
		else
			snprintf(STAP_RETVALUE, MAXSTRINGLEN, "        sockname: AF_UNIX");
	}
	CATCH_DEREF_FAULT();
%}

function socket_unix_peername:string (sock:long) %{ /* pure */
	struct socket *sock = (struct socket *)((long)STAP_ARG_sock);
	const struct proto_ops *ops = kread(&sock->ops);
	struct sockaddr_un un_addr;
	int err, len;

#if LINUX_VERSION_CODE >= KERNEL_VERSION(4,17,0)
	err = ops->getname(sock, (struct sockaddr *)(&un_addr), 1);
#else
	err = ops->getname(sock, (struct sockaddr *)(&un_addr), &len, 1);
#endif
//	err = kernel_getpeername(kread(&sock), (struct sockaddr *)(&un_addr), &len);
	if (!(err < 0)) {
		if (un_addr.sun_path[0] != 0)
			snprintf(STAP_RETVALUE, MAXSTRINGLEN,
				"        peername: AF_UNIX %s", un_addr.sun_path);
		else
			snprintf(STAP_RETVALUE, MAXSTRINGLEN, "        peername: AF_UNIX");
	}
	CATCH_DEREF_FAULT();
%}

%{
#ifndef NIPQUAD
#define NIPQUAD(addr) \
	((unsigned char *)&addr)[0], \
	((unsigned char *)&addr)[1], \
	((unsigned char *)&addr)[2], \
	((unsigned char *)&addr)[3]
#endif
#ifndef NIPQUAD_FMT
#define NIPQUAD_FMT "%u.%u.%u.%u"
#endif
%}

function socket_ipv4_sockname:string (sock:long) %{ /* pure */
	struct socket *sock = (struct socket *)((long)STAP_ARG_sock);
	const struct proto_ops *ops = kread(&sock->ops);
	struct sockaddr_in in_addr;
	__be32 addr, port;
	int err, len;

#if LINUX_VERSION_CODE >= KERNEL_VERSION(4,17,0)
	err = ops->getname (sock, (struct sockaddr*)(&in_addr), 0);
#else
	err = ops->getname (sock, (struct sockaddr*)(&in_addr), &len, 0);
#endif
	if (!(err < 0)) {
		addr = in_addr.sin_addr.s_addr;
		port = htons(in_addr.sin_port);
		snprintf(STAP_RETVALUE, MAXSTRINGLEN,
			"        sockname: AF_INET " NIPQUAD_FMT "  port: %d",
			NIPQUAD(addr), port);
	}
	CATCH_DEREF_FAULT();
%}

function socket_ipv4_peername:string (sock:long) %{ /* pure */
	struct socket *sock = (struct socket *)((long)STAP_ARG_sock);
	const struct proto_ops *ops = kread(&sock->ops);
	struct sockaddr_in in_addr;
	__be32 addr, port;
	int err, len;

#if LINUX_VERSION_CODE >= KERNEL_VERSION(4,17,0)
	err = ops->getname (sock, (struct sockaddr*)(&in_addr), 1);
#else
	err = ops->getname (sock, (struct sockaddr*)(&in_addr), &len, 1);
#endif
	if (!(err < 0)) {
		addr = in_addr.sin_addr.s_addr;
		port = htons(in_addr.sin_port);
		snprintf(STAP_RETVALUE, MAXSTRINGLEN,
			"        peername: AF_INET " NIPQUAD_FMT "  port: %d",
			NIPQUAD(addr), port);
	}
	CATCH_DEREF_FAULT();
%}

%{
#ifndef NIP6_FMT
#define NIP6_FMT "%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x"
#endif
#ifndef NIP6
#define NIP6(addr) \
    ntohs((addr).s6_addr16[0]), \
    ntohs((addr).s6_addr16[1]), \
    ntohs((addr).s6_addr16[2]), \
    ntohs((addr).s6_addr16[3]), \
    ntohs((addr).s6_addr16[4]), \
    ntohs((addr).s6_addr16[5]), \
    ntohs((addr).s6_addr16[6]), \
    ntohs((addr).s6_addr16[7])
#endif

function socket_ipv6_sockname:string (sock:long) %{ /* pure */
	struct socket *sock = (struct socket *)((long)STAP_ARG_sock);
	const struct proto_ops *ops = kread(&sock->ops);
	struct sockaddr_in6 in_addr;
	__be32 port;
	int err, len;

#if LINUX_VERSION_CODE >= KERNEL_VERSION(4,17,0)
	err = ops->getname (sock, (struct sockaddr*)(&in_addr), 0);
#else
	err = ops->getname (sock, (struct sockaddr*)(&in_addr), &len, 0);
#endif
	if (!(err < 0)) {
		port = htons(in_addr.sin6_port);
		snprintf(STAP_RETVALUE, MAXSTRINGLEN,
			"        sockname: AF_INET6 " NIP6_FMT "  port: %d",
			NIP6(in_addr.sin6_addr), port);
	}
	CATCH_DEREF_FAULT();
%}

function socket_ipv6_peername:string (sock:long) %{ /* pure */
	struct socket *sock = (struct socket *)((long)STAP_ARG_sock);
	const struct proto_ops *ops = kread(&sock->ops);
	struct sockaddr_in6 in_addr;
	__be32 port;
	int err, len;

#if LINUX_VERSION_CODE >= KERNEL_VERSION(4,17,0)
	err = ops->getname (sock, (struct sockaddr*)(&in_addr), 1);
#else
	err = ops->getname (sock, (struct sockaddr*)(&in_addr), &len, 1);
#endif
	if (!(err < 0)) {
		port = htons(in_addr.sin6_port);
		snprintf(STAP_RETVALUE, MAXSTRINGLEN,
			"        peername: AF_INET6 " NIP6_FMT "  port: %d",
			NIP6(in_addr.sin6_addr), port);
	}
	CATCH_DEREF_FAULT();
%}

function print_file_handle_general(task, fd) {
	printf("%4d: %s mode:%04o dev:%s ino:%d uid:%d gid:%d rdev:%s\n",
		fd, i_mode2str(task_file_handle_i_mode(task, fd)),
		task_file_handle_i_mode(task, fd) & 0777,
		task_file_handle_majmin_dev(task, fd),
		task_file_handle_i_node(task, fd),
		task_file_handle_uid(task, fd),
		task_file_handle_gid(task, fd),
		task_file_handle_majmin_rdev(task, fd));
}

function print_file_handle_flags(task, fd) {
	printf("      %s %s\n",
		_sys_open_flag_str(task_file_handle_f_flags(task, fd)),
		task_file_handle_fd_flags(task, fd));
}

function print_file_handle_flock(task, fd) {
	flock = task_file_handle_flock(task, fd)
	if (!isinstr(flock, "NULL"))
		printf("%s\n", flock)
}

function print_file_handle_d_path(task, fd) {
	printf("      %s\n", task_file_handle_d_path(task, fd))
}

function print_socket_userlocks(sock) {
	slocks = socket_userlocks(sock)
	if (strlen(slocks) > 0)
		printf("        %s\n", slocks)
}

function print_unix_socket(sock) {
	sockname = socket_unix_sockname(sock)
	peername = socket_unix_peername(sock)
	printf("%s%s", strlen(sockname) > 0 ? sockname . "\n" : "",
		strlen(peername) > 0 ? peername . "\n" : "")
        try { # skip line in case of null pointers
	printf("        peercred pid: %d\n",
            @defined(@cast(sock, "socket", "kernel")->sk->sk_peer_pid) ?
	    @cast(sock, "socket", "kernel")->sk->sk_peer_pid->numbers[0]->nr :
	    @cast(sock, "socket", "kernel")->sk->sk_peercred->pid ); } catch { }
}

function print_ipv4_socket(sock) {
	sockname = socket_ipv4_sockname(sock)
	peername = socket_ipv4_peername(sock)
	printf("%s%s", strlen(sockname) > 0 ? sockname . "\n" : "",
		strlen(peername) > 0 ? peername . "\n" : "")
}

function print_ipv6_socket(sock) {
	sockname = socket_ipv6_sockname(sock)
	peername = socket_ipv6_peername(sock)
	printf("%s%s", strlen(sockname) > 0 ? sockname . "\n" : "",
		strlen(peername) > 0 ? peername . "\n" : "")
}

function print_socket_optname(sock) {
    str = socket_optname(sock)
    printf("      %s", strlen(str) > 0 ? str . "\n" : "")
}

probe begin {
%( $# < 1
        %? pid = target()
        %: pid = $1
%)
   task = pid2task(pid)
   if (task == 0) error (sprintf("Process-id %d is invalid, please provide valid PID as $1 or -x PID", pid))
   
	max_fds = task_max_file_handles(task)

printf("%6d: %s\n", pid, pid2execname(pid))
	printf("  Current rlimit: %d file descriptors\n", max_fds)

for (fd = 0; fd < max_fds; fd++) {
		if (task_valid_file_handle(task, fd)) {
			print_file_handle_general(task, fd)
			print_file_handle_flags(task, fd)
			print_file_handle_flock(task, fd)
			print_file_handle_d_path(task, fd)
			sock = task_file_handle_socket(task, fd)
			if (sock) {
				print_socket_optname(sock)
				fam = socket_family(sock)
				if (fam == %{ AF_UNIX %}) {
					print_unix_socket(sock)
				} else if (fam == %{ AF_INET %}) {
					print_ipv4_socket(sock)
				} else if (fam == %{ AF_INET6 %}) {
					print_ipv6_socket(sock)
				}
				print_socket_userlocks(sock)
			}
		}
	}

exit()
}

cmd: