[RFC Patch 0/2] VFS tapset patches

[RFC Patch 0/2] VFS tapset patches

[K.Prasad]

Hi All,
	Please review the following set of patches, the first of which
deprecates probes corresponding to older kernel versions and the next
one which enhances tapset/vfs.stp by adding probes to more functions and
providing additional worker routines in C.
 
We would be interested to know your thoughts on the patches, more
specifically on a)the choice of functions for defining probe points
b)choice of namespace for the probe variables, and any alternatives for
the same.

These patches are generated on a SystemTap git clone done as of 20th May
2008.
 
Thanks,
K.Prasad

[RFC Patch 1/2] Deprecate certain probes in vfs.stp

[K.Prasad]

This patch deprecates probes/return probes for the following kernel
functions: generic_file_readv, generic_file_writev, generic_file_read
and generic_file_write.

Signed-off-by: K.Prasad <prasad@linux.vnet.ibm.com>
---
 tapset/vfs.stp |    5 +++++
 1 file changed, 5 insertions(+)

Index: systemtap/tapset/vfs.stp
===================================================================
--- systemtap.orig/tapset/vfs.stp
+++ systemtap/tapset/vfs.stp
@@ -241,6 +241,7 @@ probe generic.fop.aio_write.return = ker
 	}
 }
 
+%( kernel_v < "2.6.19" %?
 probe generic.fop.readv = kernel.function ("generic_file_readv") ?
 {
 	dev = __file_dev($filp)
@@ -293,6 +294,8 @@ probe generic.fop.writev.return = kernel
 		units = "bytes"
 	}
 }
+%:
+%)
 
 /* checks for aops->readpage, if not defined, return -ENOEXEC
    else assigns generic_file_vm_ops to vma
@@ -415,6 +418,7 @@ probe generic.fop.splice_write.return = 
 	}
 }
 
+%( kernel_v < "2.6.19" %?
 probe generic.fop.read = kernel.function ("generic_file_read") ?
 {
 	dev = __file_dev($filp)
@@ -464,6 +468,7 @@ probe generic.fop.write.return = kernel.
 		units = "bytes"
 	}
 }
+%)
 
 /* generic_writepages calls mpage_writepages(mapping, wbc, NULL) */
 probe generic.aop.writepages = kernel.function ("mpage_writepages")

[RFC Patch 2/2] Enhancements to vfs.stp

[K.Prasad]

This patch provides enhancements to probe several significant VFS subsystem related
functions apart from providing additional worker C routines.

Signed-off-by: K.Prasad <prasad@linux.vnet.ibm.com>
Signed-off-by: Mike Mason <mmlnx@us.ibm.com>
---
 tapset/vfs.stp |  297 +++++++++++++++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 291 insertions(+), 6 deletions(-)

Index: systemtap/tapset/vfs.stp
===================================================================
--- systemtap.orig/tapset/vfs.stp
+++ systemtap/tapset/vfs.stp
@@ -57,6 +57,18 @@ function __page_ino:long (page:long) %{ 
 	CATCH_DEREF_FAULT();
 %}
 
+function __address_inode:long (page:long) %{ /* pure */
+	struct page *page = (struct page *)(long)THIS->page;
+	struct address_space *mapping =
+			(struct address_space *)(long)THIS;
+	if (mapping == NULL) {
+		THIS->__retvalue = -1;
+	} else {
+		THIS->__retvalue = kread(&(mapping->host));
+	}
+	CATCH_DEREF_FAULT();
+%}
+
 function __page_dev:long (page:long) %{ /* pure */
 	struct page *page = (struct page *)(long)THIS->page;
 	struct address_space *mapping = page? kread(&(page->mapping)) : NULL;
@@ -152,11 +164,46 @@ function __file_filename:string (file:lo
 	CATCH_DEREF_FAULT();
 %}
 
+function __inode_num:long(file:long)
+%{
+	struct file *file = NULL;
+	struct dentry *dentry = NULL;
+	struct inode *inode = NULL;
+
+	file = (struct file *)(long)THIS->file;
+	dentry = file? kread(&(file->f_dentry)) : NULL;
+	inode = dentry? kread(&(dentry->d_inode)) : NULL;
+	THIS->__retvalue? kread(&(inode->i_ino)) : NULL;
+%}
+
+function _get_fopv_size:long (iov:long, nr_segs:long)
+%{
+	struct iovec *iovp = (struct iovec *)(long)THIS->iov;
+	if (iovp) {
+		int i;
+		THIS->__retvalue = 0;
+		for (i = 0 ; i < THIS->nr_segs ; i++)
+			THIS->__retvalue += kread(&(iovp[i].iov_len));
+	} else
+		THIS->__retvalue = -1;
+
+	CATCH_DEREF_FAULT();
+%}
+
+function _dev_minor:long (dev:long) %{ /* pure */
+	THIS->__retvalue = (long)MINOR((dev_t)THIS->dev);
+%}
+
+function _dev_major:long (dev:long) %{ /* pure */
+	THIS->__retvalue = (long)MAJOR((dev_t)THIS->dev);
+%}
+
 probe generic.fop.llseek = kernel.function ("generic_file_llseek")
 {
 	dev = __file_dev($file)
 	devname = __find_bdevname(dev, __file_bdev($file))
 	ino = __file_ino($file)
+	file = $file
 
 	offset = $offset
 	origin = $origin
@@ -168,11 +215,19 @@ probe generic.fop.llseek = kernel.functi
 probe generic.fop.llseek.return = kernel.function ("generic_file_llseek").return
 {
 	name = "generic_file_llseek"
-	retstr = returnstr(1)
+	name = "generic_file_llseek"
+	retstr = $return
+	file = $file
+	offset = $offset
+	origin = $origin
+
+	error = $return < 0 ? $return : 0
+	error_str = error ? errno_str(error) : ""
 }
 
 probe generic.fop.aio_read = kernel.function ("generic_file_aio_read")
 {
+	file = $iocb->ki_filp
 	dev = __file_dev($iocb->ki_filp)
 	devname = __find_bdevname(dev, __file_bdev($iocb->ki_filp))
 	ino = __file_ino($iocb->ki_filp)
@@ -194,9 +249,15 @@ probe generic.fop.aio_read = kernel.func
 }
 probe generic.fop.aio_read.return = kernel.function ("generic_file_aio_read").return
 {
+	file = $iocb->ki_filp
+	nr_segs = $nr_segs
 	name = "generic_file_aio_read"
 	retstr = sprintf("%d", $return)
 
+	bytes_read = $return > 0 ? $return : 0
+	error = $return < 0 ? $return : 0
+ 	error_str = error ? errno_str(error) : ""
+
 	if ($return > 0) {
 		size = $return
 		units = "bytes"
@@ -205,6 +266,7 @@ probe generic.fop.aio_read.return = kern
 
 probe generic.fop.aio_write = kernel.function ("generic_file_aio_write")
 {
+	file = $iocb->ki_filp
 	dev = __file_dev($iocb->ki_filp)
 	devname = __find_bdevname(dev, __file_bdev($iocb->ki_filp))
 	ino = __file_ino($iocb->ki_filp)
@@ -226,6 +288,7 @@ probe generic.fop.aio_write = kernel.fun
 }
 probe generic.fop.aio_write.return = kernel.function ("generic_file_aio_write").return
 {
+	file = $iocb->ki_filp
 	name = "generic_file_aio_write"
 	retstr = sprintf("%d", $return)
 
@@ -280,9 +343,14 @@ probe generic.fop.writev = kernel.functi
 }
 probe generic.fop.writev.return = kernel.function ("generic_file_writev").return ?
 {
+	file = $file
 	name = "generic_file_writev"
 	retstr = sprintf("%d", $return)
 
+	bytes_written = $return > 0 ? $return : 0
+	error = $return < 0 ? $return : 0
+	error_str = error ? errno_str(error) : ""
+
 	if ($return > 0) {
 		size = $return
 		units = "bytes"
@@ -296,6 +364,7 @@ probe generic.fop.writev.return = kernel
    add filemap_nopage, filemap_populate */
 probe generic.fop.mmap = kernel.function ("generic_file_mmap")
 {
+	file = $file
 	dev = __file_dev($file)
 	devname = __find_bdevname(dev, __file_bdev($file))
 	ino = __file_ino($file)
@@ -309,8 +378,12 @@ probe generic.fop.mmap = kernel.function
 }
 probe generic.fop.mmap.return = kernel.function ("generic_file_mmap").return
 {
+	file = $file
 	name = "generic_file_mmap"
 	retstr = sprintf("%d", $return)
+
+	error = $return < 0 ? $return : 0
+	error_str = error ? errno_str(error) : ""
 }
 
 probe generic.fop.open = kernel.function ("generic_file_open")
@@ -365,6 +438,7 @@ probe generic.fop.splice_read = kernel.f
 	dev = __file_dev($in)
 	devname = __find_bdevname(dev, __file_bdev($in))
 	ino = __file_ino($in)
+	file = $in
 
 	len = $len
 	flags = $flags
@@ -379,9 +453,17 @@ probe generic.fop.splice_read.return = k
 {
 	name = "generic_file_splice_read"
 	retstr = sprintf("%d", $return)
+	file = $in
+	ino = __file_ino($in)
+	dev_major = _dev_major(_dev)
+	dev_minor = _dev_minor(_dev)
 
-	if ($return > 0) {
-		size = $return
+	ret = $return
+	error = ret < 0 ? ret : 0
+	error_str = error ? errno_str(error) : ""
+
+	if (error) {
+		size = ret
 		units = "bytes"
 	}
 }
@@ -391,6 +473,7 @@ probe generic.fop.splice_write = kernel.
 	dev = __file_dev($out)
 	devname = __find_bdevname(dev, __file_bdev($out))
 	ino = __file_ino($out)
+	file = $out
 
 	len = $len
 	flags = $flags
@@ -406,7 +489,12 @@ probe generic.fop.splice_write.return = 
 	name = "generic_file_splice_write"
 	retstr = sprintf("%d", $return)
 
-	if ($return > 0) {
+	file = $out
+
+	error = $return < 0 ? $return : 0
+	error_str = error ? errno_str(error) : ""
+
+	if (error) {
 		size = $return
 		units = "bytes"
 	}
@@ -499,12 +587,19 @@ probe vfs.do_sync_read = kernel.function
 
 	size = len
 	units = "bytes"
+	bytes_to_read = len
 }
 probe vfs.do_sync_read.return = kernel.function ("do_sync_read").return
 {
 	name = "do_sync_read"
 	retstr = sprintf("%d", $return)
 
+	bytes_to_read = len
+	ret = $return
+	bytes_read = ret > 0 ? ret : 0
+	error = ret < 0 ? ret : 0
+	error_str = error ? errno_str(error) : ""
+
 	if ($return > 0) {
 		size = $return
 		units = "bytes"
@@ -520,6 +615,7 @@ probe vfs.do_sync_write = kernel.functio
 	len = $len
 	pos = ppos_pos($ppos)
 	buf = $buf
+	bytes_to_write = len
 
 	name = "do_sync_write"
 	argstr = sprintf("%d, %d , %p", len, pos, buf)
@@ -532,8 +628,15 @@ probe vfs.do_sync_write.return = kernel.
 	name = "do_sync_write"
 	retstr = sprintf("%d", $return)
 
-	if ($return > 0) {
-		size = $return
+	bytes_to_write = len
+	ppos = $ppos
+	ret = $return
+	bytes_written = ret > 0 ? ret : 0
+	error = $return < 0 ? ret : 0
+ 	error_str = error ? errno_str(error) : ""
+
+	if (error) {
+		size = ret
 		units = "bytes"
 	}
 }
@@ -682,3 +785,185 @@ probe vfs.remove_from_page_cache.return 
 	retstr = sprintf("N/A")
 }
 
+probe vfs.read = kernel.function ("vfs_read")
+{
+	file = $file
+	pos = $pos
+	buf = $buf
+	bytes_to_read = $count
+}
+
+probe vfs.read.return = kernel.function ("vfs_read").return
+{
+	file = $file
+	pos = $pos
+	buf = $buf
+	bytes_to_read = $count
+
+	ret = $return
+	bytes_read = ret > 0 ? ret : 0
+	error = ret < 0 ? ret : 0
+	error_str = error ? errno_str(error) : ""
+}
+
+probe vfs.readv = kernel.function ("vfs_readv")
+{
+	file = $file
+	pos = $pos
+	vec = $vec
+	vlen = $vlen
+	bytes_to_read = _get_fopv_size($vec, $vlen)
+}
+
+probe vfs.readv.return = kernel.function ("vfs_readv").return
+{
+	file = $file
+	pos = $pos
+	vec = $vec
+	vlen = $vlen
+	bytes_to_read = _get_fopv_size($vec, $vlen)
+
+	ret = $return
+	bytes_read = ret > 0 ? ret : 0
+	error = ret < 0 ? ret : 0
+	error_str = error ? errno_str(error) : ""
+}
+
+probe vfs.write = kernel.function ("vfs_write")
+{
+	file = $file
+	pos = $pos
+	buf = $buf
+	bytes_to_write = $count
+}
+
+probe vfs.write.return = kernel.function ("vfs_write").return
+{
+	file = $file
+	pos = $pos
+	buf = $buf
+	bytes_to_write = $count
+
+	ret = $return
+	bytes_written = ret > 0 ? ret : 0
+	error = ret < 0 ? ret : 0
+	error_str = error ? errno_str(error) : ""
+}
+
+probe vfs.writev = kernel.function("vfs_writev")
+{
+	file = $file
+	pos = $pos
+	vlen = $vlen
+	vec = $vec
+	bytes_to_write = _get_fopv_size($vec, $vlen)
+}
+
+probe vfs.writev.return = kernel.function ("vfs_writev").return
+{
+	file = $file
+	pos = $pos
+	vlen = $vlen
+	vec = $vec
+	bytes_to_write = _get_fopv_size($vec, $vlen)
+
+	ret = $return
+	bytes_written = ret > 0 ? ret : 0
+	error = ret < 0 ? ret : 0
+	error_str = error ? errno_str(error) : ""
+}
+
+probe _vfs.generic_file_readonly_mmap =
+kernel.function("generic_file_readonly_mmap")
+{
+	file = $file
+	vma = $vma
+}
+
+probe _vfs.generic_file_readonly_mmap.return = kernel.function ("generic_file_readonly_mmap").return
+{
+	file = $file
+	vma = $vma
+
+	ret = $return
+	error = ret < 0 ? ret : 0
+	error_str = error ? errno_str(error) : ""
+}
+
+probe _vfs.generic_block_bmap = kernel.function ("generic_block_bmap")
+{
+	mapping = $mapping
+	block = $block
+	get_block = $get_block
+}
+
+probe _vfs.generic_commit_write = kernel.function ("generic_commit_write")
+{
+	file = $file
+	page = $page
+	from = $from
+	to = $to
+}
+
+probe _vfs.block_prepare_write = kernel.function ("__block_prepare_write")
+{
+	_inode = $inode
+	page = $page
+	write_from = $from
+	write_upto = $to
+}
+
+probe _vfs.block_prepare_write.return = kernel.function("__block_prepare_write").return
+{
+	_inode = $inode
+	page = $page
+	write_from = $from
+	write_upto = $to
+
+	ret = $return
+	error = ret < 0 ? ret : 0
+	error_str = error ? errno_str(error) : ""
+}
+
+probe _vfs.block_write_begin = kernel.function ("block_write_begin")
+{
+	file = $file
+	pos = $pos
+	len = $len
+	flags = $flags
+
+	_inode = __address_inode($mapping)
+}
+
+probe _vfs.block_write_begin.return = kernel.function ("block_write_begin").return
+{
+	file = $file
+	pos = $pos
+	len = $len
+	flags = $flags
+
+	_inode = __address_inode($mapping)
+
+	ret = $return
+	error = ret < 0 ? ret : 0
+	error_str = error ? errno_str(error) : ""
+}
+
+probe _vfs.block_write_end = kernel.function ("block_write_end")
+{
+	file = $file
+	pos = $pos
+	len = $len
+	page = $page
+	_inode = __address_inode($mapping)
+}
+
+probe _vfs.block_write_end.return = kernel.function ("block_write_end").return
+{
+	file = $file
+	pos = $pos
+	len = $len
+	page = $page
+	_inode = __address_inode($mapping)
+	ret = $return
+}

Re: [RFC Patch 2/2] Enhancements to vfs.stp

[Frank Ch. Eigler]

"K.Prasad" <prasad@linux.vnet.ibm.com> writes:

> This patch provides enhancements to probe several significant VFS subsystem related
> functions apart from providing additional worker C routines.
> [...]

Looks good to me.  Please make sure that the test suite attempts to
probe all aliases (perhaps even with "stap -u" if possible), and also
attempts to compile all embedded-c routines.

- FChE

Re: [RFC Patch 2/2] Enhancements to vfs.stp

[K.Prasad]

On Wed, May 28, 2008 at 12:12:29PM -0400, Frank Ch. Eigler wrote:
> "K.Prasad" <prasad@linux.vnet.ibm.com> writes:
> 
> > This patch provides enhancements to probe several significant VFS subsystem related
> > functions apart from providing additional worker C routines.
> > [...]
> 
> Looks good to me.  Please make sure that the test suite attempts to
> probe all aliases (perhaps even with "stap -u" if possible), and also
> attempts to compile all embedded-c routines.
> 
> - FChE

I've created a script that probes and prints all functions defined as a
part of the tapset. A successfull compilation of the script indicates to
us that the function, names and the parameters used in the tapset are
intact (I've covered almost all tapset variables created).

Similarly there are a couple of minor changes that were required in
vfs.stp which were uncovered while running the above-mentioned script.

Let me know your comments on the same.

Thanks,
K.Prasad

[Patch 2/2] Enhancements to vfs.stp (with minor modifications)

[K.Prasad]

This patch provides enhancements to probe several significant VFS subsystem related
functions apart from providing additional worker C routines.

Signed-off-by: K.Prasad <prasad@linux.vnet.ibm.com>
Signed-off-by: Mike Mason <mmlnx@us.ibm.com>
---
 tapset/vfs.stp |  297 +++++++++++++++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 291 insertions(+), 6 deletions(-)

Index: systemtap/tapset/vfs.stp
===================================================================
--- systemtap.orig/tapset/vfs.stp
+++ systemtap/tapset/vfs.stp
@@ -57,6 +57,18 @@ function __page_ino:long (page:long) %{ 
 	CATCH_DEREF_FAULT();
 %}
 
+function __address_inode:long (page:long) %{ /* pure */
+	struct page *page = (struct page *)(long)THIS->page;
+	struct address_space *mapping =
+			(struct address_space *)(long)THIS;
+	if (mapping == NULL) {
+		THIS->__retvalue = -1;
+	} else {
+		THIS->__retvalue = (long)kread(&(mapping->host));
+	}
+	CATCH_DEREF_FAULT();
+%}
+
 function __page_dev:long (page:long) %{ /* pure */
 	struct page *page = (struct page *)(long)THIS->page;
 	struct address_space *mapping = page? kread(&(page->mapping)) : NULL;
@@ -152,11 +164,47 @@ function __file_filename:string (file:lo
 	CATCH_DEREF_FAULT();
 %}
 
+function __inode_num:long(file:long)
+%{
+	struct file *file = NULL;
+	struct dentry *dentry = NULL;
+	struct inode *inode = NULL;
+
+	file = (struct file *)(long)THIS->file;
+	dentry = file? kread(&(file->f_dentry)) : NULL;
+	inode = dentry? kread(&(dentry->d_inode)) : NULL;
+	THIS->__retvalue = inode? (long)(kread(&(inode->i_ino))) : 0;
+	CATCH_DEREF_FAULT();
+%}
+
+function _get_fopv_size:long (iov:long, nr_segs:long)
+%{
+	struct iovec *iovp = (struct iovec *)(long)THIS->iov;
+	if (iovp) {
+		int i;
+		THIS->__retvalue = 0;
+		for (i = 0 ; i < THIS->nr_segs ; i++)
+			THIS->__retvalue += kread(&(iovp[i].iov_len));
+	} else
+		THIS->__retvalue = -1;
+
+	CATCH_DEREF_FAULT();
+%}
+
+function _dev_minor:long (dev:long) %{ /* pure */
+	THIS->__retvalue = (long)MINOR((dev_t)THIS->dev);
+%}
+
+function _dev_major:long (dev:long) %{ /* pure */
+	THIS->__retvalue = (long)MAJOR((dev_t)THIS->dev);
+%}
+
 probe generic.fop.llseek = kernel.function ("generic_file_llseek")
 {
 	dev = __file_dev($file)
 	devname = __find_bdevname(dev, __file_bdev($file))
 	ino = __file_ino($file)
+	file = $file
 
 	offset = $offset
 	origin = $origin
@@ -168,11 +216,19 @@ probe generic.fop.llseek = kernel.functi
 probe generic.fop.llseek.return = kernel.function ("generic_file_llseek").return
 {
 	name = "generic_file_llseek"
-	retstr = returnstr(1)
+	name = "generic_file_llseek"
+	retstr = $return
+	file = $file
+	offset = $offset
+	origin = $origin
+
+	error = $return < 0 ? $return : 0
+	error_str = error ? errno_str(error) : ""
 }
 
 probe generic.fop.aio_read = kernel.function ("generic_file_aio_read")
 {
+	file = $iocb->ki_filp
 	dev = __file_dev($iocb->ki_filp)
 	devname = __find_bdevname(dev, __file_bdev($iocb->ki_filp))
 	ino = __file_ino($iocb->ki_filp)
@@ -194,9 +250,15 @@ probe generic.fop.aio_read = kernel.func
 }
 probe generic.fop.aio_read.return = kernel.function ("generic_file_aio_read").return
 {
+	file = $iocb->ki_filp
+	nr_segs = $nr_segs
 	name = "generic_file_aio_read"
 	retstr = sprintf("%d", $return)
 
+	bytes_read = $return > 0 ? $return : 0
+	error = $return < 0 ? $return : 0
+ 	error_str = error ? errno_str(error) : ""
+
 	if ($return > 0) {
 		size = $return
 		units = "bytes"
@@ -205,6 +267,7 @@ probe generic.fop.aio_read.return = kern
 
 probe generic.fop.aio_write = kernel.function ("generic_file_aio_write")
 {
+	file = $iocb->ki_filp
 	dev = __file_dev($iocb->ki_filp)
 	devname = __find_bdevname(dev, __file_bdev($iocb->ki_filp))
 	ino = __file_ino($iocb->ki_filp)
@@ -226,6 +289,7 @@ probe generic.fop.aio_write = kernel.fun
 }
 probe generic.fop.aio_write.return = kernel.function ("generic_file_aio_write").return
 {
+	file = $iocb->ki_filp
 	name = "generic_file_aio_write"
 	retstr = sprintf("%d", $return)
 
@@ -280,9 +344,14 @@ probe generic.fop.writev = kernel.functi
 }
 probe generic.fop.writev.return = kernel.function ("generic_file_writev").return ?
 {
+	file = $file
 	name = "generic_file_writev"
 	retstr = sprintf("%d", $return)
 
+	bytes_written = $return > 0 ? $return : 0
+	error = $return < 0 ? $return : 0
+	error_str = error ? errno_str(error) : ""
+
 	if ($return > 0) {
 		size = $return
 		units = "bytes"
@@ -296,6 +365,7 @@ probe generic.fop.writev.return = kernel
    add filemap_nopage, filemap_populate */
 probe generic.fop.mmap = kernel.function ("generic_file_mmap")
 {
+	file = $file
 	dev = __file_dev($file)
 	devname = __find_bdevname(dev, __file_bdev($file))
 	ino = __file_ino($file)
@@ -309,8 +379,12 @@ probe generic.fop.mmap = kernel.function
 }
 probe generic.fop.mmap.return = kernel.function ("generic_file_mmap").return
 {
+	file = $file
 	name = "generic_file_mmap"
 	retstr = sprintf("%d", $return)
+
+	error = $return < 0 ? $return : 0
+	error_str = error ? errno_str(error) : ""
 }
 
 probe generic.fop.open = kernel.function ("generic_file_open")
@@ -365,6 +439,7 @@ probe generic.fop.splice_read = kernel.f
 	dev = __file_dev($in)
 	devname = __find_bdevname(dev, __file_bdev($in))
 	ino = __file_ino($in)
+	file = $in
 
 	len = $len
 	flags = $flags
@@ -379,9 +454,17 @@ probe generic.fop.splice_read.return = k
 {
 	name = "generic_file_splice_read"
 	retstr = sprintf("%d", $return)
+	file = $in
+	ino = __file_ino($in)
+	dev_major = _dev_major(_dev)
+	dev_minor = _dev_minor(_dev)
 
-	if ($return > 0) {
-		size = $return
+	ret = $return
+	error = ret < 0 ? ret : 0
+	error_str = error ? errno_str(error) : ""
+
+	if (error) {
+		size = ret
 		units = "bytes"
 	}
 }
@@ -391,6 +474,7 @@ probe generic.fop.splice_write = kernel.
 	dev = __file_dev($out)
 	devname = __find_bdevname(dev, __file_bdev($out))
 	ino = __file_ino($out)
+	file = $out
 
 	len = $len
 	flags = $flags
@@ -406,7 +490,12 @@ probe generic.fop.splice_write.return = 
 	name = "generic_file_splice_write"
 	retstr = sprintf("%d", $return)
 
-	if ($return > 0) {
+	file = $out
+
+	error = $return < 0 ? $return : 0
+	error_str = error ? errno_str(error) : ""
+
+	if (error) {
 		size = $return
 		units = "bytes"
 	}
@@ -499,12 +588,19 @@ probe vfs.do_sync_read = kernel.function
 
 	size = len
 	units = "bytes"
+	bytes_to_read = len
 }
 probe vfs.do_sync_read.return = kernel.function ("do_sync_read").return
 {
 	name = "do_sync_read"
 	retstr = sprintf("%d", $return)
 
+	bytes_to_read = $len
+	ret = $return
+	bytes_read = ret > 0 ? ret : 0
+	error = ret < 0 ? ret : 0
+	error_str = error ? errno_str(error) : ""
+
 	if ($return > 0) {
 		size = $return
 		units = "bytes"
@@ -520,6 +616,7 @@ probe vfs.do_sync_write = kernel.functio
 	len = $len
 	pos = ppos_pos($ppos)
 	buf = $buf
+	bytes_to_write = len
 
 	name = "do_sync_write"
 	argstr = sprintf("%d, %d , %p", len, pos, buf)
@@ -532,8 +629,15 @@ probe vfs.do_sync_write.return = kernel.
 	name = "do_sync_write"
 	retstr = sprintf("%d", $return)
 
-	if ($return > 0) {
-		size = $return
+	bytes_to_write = $len
+	ppos = $ppos
+	ret = $return
+	bytes_written = ret > 0 ? ret : 0
+	error = $return < 0 ? ret : 0
+ 	error_str = error ? errno_str(error) : ""
+
+	if (error) {
+		size = ret
 		units = "bytes"
 	}
 }
@@ -682,3 +786,185 @@ probe vfs.remove_from_page_cache.return 
 	retstr = sprintf("N/A")
 }
 
+probe vfs.read = kernel.function ("vfs_read")
+{
+	file = $file
+	pos = $pos
+	buf = $buf
+	bytes_to_read = $count
+}
+
+probe vfs.read.return = kernel.function ("vfs_read").return
+{
+	file = $file
+	pos = $pos
+	buf = $buf
+	bytes_to_read = $count
+
+	ret = $return
+	bytes_read = ret > 0 ? ret : 0
+	error = ret < 0 ? ret : 0
+	error_str = error ? errno_str(error) : ""
+}
+
+probe vfs.readv = kernel.function ("vfs_readv")
+{
+	file = $file
+	pos = $pos
+	vec = $vec
+	vlen = $vlen
+	bytes_to_read = _get_fopv_size($vec, $vlen)
+}
+
+probe vfs.readv.return = kernel.function ("vfs_readv").return
+{
+	file = $file
+	pos = $pos
+	vec = $vec
+	vlen = $vlen
+	bytes_to_read = _get_fopv_size($vec, $vlen)
+
+	ret = $return
+	bytes_read = ret > 0 ? ret : 0
+	error = ret < 0 ? ret : 0
+	error_str = error ? errno_str(error) : ""
+}
+
+probe vfs.write = kernel.function ("vfs_write")
+{
+	file = $file
+	pos = $pos
+	buf = $buf
+	bytes_to_write = $count
+}
+
+probe vfs.write.return = kernel.function ("vfs_write").return
+{
+	file = $file
+	pos = $pos
+	buf = $buf
+	bytes_to_write = $count
+
+	ret = $return
+	bytes_written = ret > 0 ? ret : 0
+	error = ret < 0 ? ret : 0
+	error_str = error ? errno_str(error) : ""
+}
+
+probe vfs.writev = kernel.function("vfs_writev")
+{
+	file = $file
+	pos = $pos
+	vlen = $vlen
+	vec = $vec
+	bytes_to_write = _get_fopv_size($vec, $vlen)
+}
+
+probe vfs.writev.return = kernel.function ("vfs_writev").return
+{
+	file = $file
+	pos = $pos
+	vlen = $vlen
+	vec = $vec
+	bytes_to_write = _get_fopv_size($vec, $vlen)
+
+	ret = $return
+	bytes_written = ret > 0 ? ret : 0
+	error = ret < 0 ? ret : 0
+	error_str = error ? errno_str(error) : ""
+}
+
+probe _vfs.generic_file_readonly_mmap =
+kernel.function("generic_file_readonly_mmap")
+{
+	file = $file
+	vma = $vma
+}
+
+probe _vfs.generic_file_readonly_mmap.return = kernel.function ("generic_file_readonly_mmap").return
+{
+	file = $file
+	vma = $vma
+
+	ret = $return
+	error = ret < 0 ? ret : 0
+	error_str = error ? errno_str(error) : ""
+}
+
+probe _vfs.generic_block_bmap = kernel.function ("generic_block_bmap")
+{
+	mapping = $mapping
+	block = $block
+	get_block = $get_block
+}
+
+probe _vfs.generic_commit_write = kernel.function ("generic_commit_write")
+{
+	file = $file
+	page = $page
+	from = $from
+	to = $to
+}
+
+probe _vfs.block_prepare_write = kernel.function ("__block_prepare_write")
+{
+	_inode = $inode
+	page = $page
+	write_from = $from
+	write_upto = $to
+}
+
+probe _vfs.block_prepare_write.return = kernel.function("__block_prepare_write").return
+{
+	_inode = $inode
+	page = $page
+	write_from = $from
+	write_upto = $to
+
+	ret = $return
+	error = ret < 0 ? ret : 0
+	error_str = error ? errno_str(error) : ""
+}
+
+probe _vfs.block_write_begin = kernel.function ("block_write_begin")
+{
+	file = $file
+	pos = $pos
+	len = $len
+	flags = $flags
+
+	_inode = __address_inode($mapping)
+}
+
+probe _vfs.block_write_begin.return = kernel.function ("block_write_begin").return
+{
+	file = $file
+	pos = $pos
+	len = $len
+	flags = $flags
+
+	_inode = __address_inode($mapping)
+
+	ret = $return
+	error = ret < 0 ? ret : 0
+	error_str = error ? errno_str(error) : ""
+}
+
+probe _vfs.block_write_end = kernel.function ("block_write_end")
+{
+	file = $file
+	pos = $pos
+	len = $len
+	page = $page
+	_inode = __address_inode($mapping)
+}
+
+probe _vfs.block_write_end.return = kernel.function ("block_write_end").return
+{
+	file = $file
+	pos = $pos
+	len = $len
+	page = $page
+	_inode = __address_inode($mapping)
+	ret = $return
+}

VFS Tapset testcase

[K.Prasad]

#! stap -up4
probe generic.fop.llseek
{
	print("Probe hit the function: %s\n", name);
	print("Probe function argstr: %s\n", argstr);
	print("dev = %l\n", dev);
	print("devname = %s\n", devname);
	print("ino = %l\n", ino);
	print("file = %p\n", file);
	print("offset = %ll\n", offset);
	print("origin = %d\n", origin);
	print("maxbyte = %l\n", maxbyte);
}

probe generic.fop.llseek.return
{
	print("Probe return from function: %s with return value = %s\n", name, retstr);
}

probe generic.fop.aio_read
{
	print("Probe hit the function: %s\n", name);
	print("Probe function argstr: %s\n", argstr);
	print("file = %p\n", file);
	print("devname = %s\n", devname);
	print("ino = %l\n", ino);
	print("pos = %ll\n", pos);
	print("size = %l\n", size);
	print("buf = %p\n", buf);
}

probe generic.fop.aio_read.return
{
	print("Probe return from function: %s with return value = %s\n", name, retstr);
}

probe generic.fop.aio_write
{
	print("Probe hit the function: %s\n", name);
	print("Probe function argstr: %s\n", argstr);
	print("file = %p\n", file);
	print("devname = %s\n", devname);
	print("ino = %l\n", ino);
	print("pos = %ll\n", pos);
	print("size = %l\n", size);
	print("buf = %p\n", buf);
}

probe generic.fop.aio_write.return
{
	print("Probe return from function: %s with return value = %s\n", name, retstr);
}

%( kernel_v < "2.6.19" %?
probe generic.fop.readv
{
	print("Probe hit the function: %s\n", name);
	print("Probe function argstr: %s\n", argstr);
	print("dev = %l\n", dev);
	print("devname = %s\n", devname);
	print("ino = %l\n", ino);
	print("size = %lu\n", size);
	print("pos = %ll\n", pos);
}

probe generic.fop.readv.return
{
	print("Probe return from function: %s with return value = %s\n", name, retstr);
}

probe generic.fop.writev
{
	print("Probe hit the function: %s\n", name);
	print("Probe function argstr: %s\n", argstr);
	print("dev = %l\n", dev);
	print("devname = %s\n", devname);
	print("ino = %l\n", ino);
	print("size = %lu\n", size);
	print("pos = %ll\n", pos);
}

probe generic.fop.writev.return
{
	print("Probe return from function: %s with return value = %s\n", name, retstr);
}
%:
%)

probe generic.fop.mmap
{
	print("Probe hit the function: %s\n", name);
	print("Probe function argstr: %s\n", argstr);
	print("file = %p\n", file);
	print("dev = %l\n", dev);
	print("devname = %s\n", devname);
	print("ino = %l\n", ino);
	print("vm_start = %lu\n", vm_start);
	print("vm_end = %lu\n", vm_end);
	print("vm_flags = %lu\n", vm_flags);
}

probe generic.fop.mmap.return
{
	print("Probe return from function: %s with return value = %s\n", name, retstr);
}

probe generic.fop.open
{
	print("Probe hit the function: %s\n", name);
	print("Probe function argstr: %s\n", argstr);
	print("dev = %l\n", dev);
	print("devname = %s\n", devname);
	print("ino = %l\n", ino);
	print("size = %lu\n", size);
	print("filename: %s\n", filename);
	print("flag = %u\n", flag);
}

probe generic.fop.open.return
{
	print("Probe return from function: %s with return value = %s\n", name, retstr);
}

%( kernel_v < "2.6.23" %?
probe generic.fop.sendfile
{
	print("Probe hit the function: %s\n", name);
	print("Probe function argstr: %s\n", argstr);
	print("file = %p\n", file);
	print("dev = %l\n", dev);
	print("devname = %s\n", devname);
	print("ino = %l\n", ino);
	print("pos = %ll\n", pos);
	print("size = %l\n", size);
}

probe generic.fop.sendfile.return
{
	print("Probe return from function: %s with return value = %s\n", name, retstr);
}
%)


probe generic.fop.splice_read
{
	print("Probe hit the function: %s\n", name);
	print("Probe function argstr: %s\n", argstr);
	print("file = %p\n", file);
	print("dev = %l\n", dev);
	print("devname = %s\n", devname);
	print("ino = %l\n", ino);
	print("size = %l\n", size);
	print("flags = %u\n", flags);
}

probe generic.fop.splice_read.return
{
	print("Probe return from function: %s with return value = %s\n", name, retstr);
}

probe generic.fop.splice_write
{
	print("Probe hit the function: %s\n", name);
	print("Probe function argstr: %s\n", argstr);
	print("file = %p\n", file);
	print("dev = %l\n", dev);
	print("devname = %s\n", devname);
	print("ino = %l\n", ino);
	print("size = %l\n", size);
	print("flags = %u\n", flags);
}

probe generic.fop.splice_write.return
{
	print("Probe return from function: %s with return value = %s\n", name, retstr);
}

%( kernel_v < "2.6.19" %?
probe generic.fop.read
{
	print("Probe hit the function: %s\n", name);
	print("Probe function argstr: %s\n", argstr);
	print("file = %p\n", file);
	print("dev = %l\n", dev);
	print("devname = %s\n", devname);
	print("ino = %l\n", ino);
	print("size = %l\n", size);
}

probe generic.fop.read.return
{
	print("Probe return from function: %s with return value = %s\n", name, retstr);
}

probe generic.fop.write
{
	print("Probe hit the function: %s\n", name);
	print("Probe function argstr: %s\n", argstr);
	print("dev = %l\n", dev);
	print("devname = %s\n", devname);
	print("ino = %l\n", ino);
	print("size = %l\n", size);
}

probe generic.fop.write.return
{
	print("Probe return from function: %s with return value = %s\n", name, retstr);
}
%)

probe generic.aop.writepages
{
	print("Probe hit the function: %s\n", name);
	print("Probe function argstr: %s\n", argstr);
	print("dev = %l\n", dev);
	print("devname = %s\n", devname);
	print("ino = %l\n", ino);
	print("size = %l\n", size);
}

probe generic.aop.writepages.return
{
	print("Probe return from function: %s with return value = %s\n", name, retstr);
}

probe vfs.do_sync_read
{
	print("Probe hit the function: %s\n", name);
	print("Probe function argstr: %s\n", argstr);
	print("dev = %l\n", dev);
	print("ino = %l\n", ino);
	print("size = %l\n", size);
	print("pos = %ll\n", pos);
	print("buf = %u\n", buf);
}

probe vfs.do_sync_read.return
{
	print("Probe return from function: %s with return value = %s\n", name, retstr);
}

probe vfs.do_sync_write
{
	print("Probe hit the function: %s\n", name);
	print("Probe function argstr: %s\n", argstr);
	print("dev = %l\n", dev);
	print("devname = %s\n", devname);
	print("ino = %l\n", ino);
	print("size = %l\n", size);
	print("pos = %ll\n", pos);
	print("buf = %u\n", buf);
}

probe vfs.do_sync_write.return
{
	print("Probe return from function: %s with return value = %s\n", name, retstr);
}

probe vfs.block_sync_page
{
	print("Probe hit the function: %s\n", name);
	print("Probe function argstr: %s\n", argstr);
	print("dev = %l\n", dev);
	print("devname = %s\n", devname);
	print("ino = %l\n", ino);
	print("size = %l\n", size);
	print("page_index = %l\n", page_index);
}

probe vfs.block_sync_page.return
{
	print("Probe return from function: %s with return value = %s\n", name, retstr);
}


probe vfs.__set_page_dirty_buffers
{
	print("Probe hit the function: %s\n", name);
	print("Probe function argstr: %s\n", argstr);
	print("dev = %l\n", dev);
	print("devname = %s\n", devname);
	print("ino = %l\n", ino);
	print("size = %l\n", size);
	print("index = %l\n", index);
}

probe vfs.__set_page_dirty_buffers.return
{
	print("Probe return from function: %s with return value = %s\n", name, retstr);
}

probe vfs.do_mpage_readpage
{
	print("Probe hit the function: %s\n", name);
	print("Probe function argstr: %s\n", argstr);
	print("dev = %l\n", dev);
	print("devname = %s\n", devname);
	print("ino = %l\n", ino);
	print("size = %l\n", size);
	print("index = %l\n", index);
}

probe vfs.do_mpage_readpage.return
{
	print("Probe return from function: %s with return value = %s\n", name, retstr);
}

probe vfs.add_to_page_cache
{
	print("Probe hit the function: %s\n", name);
	print("Probe function argstr: %s\n", argstr);
	print("dev = %l\n", dev);
	print("devname = %s\n", devname);
	print("ino = %l\n", ino);
	print("index = %ll\n", index);
	print("nrpages = %lu\n", nrpages);
}

probe vfs.add_to_page_cache.return
{
	print("Probe return from function: %s with return value = %s\n", name, retstr);
}

probe vfs.remove_from_page_cache
{
	print("Probe hit the function: %s\n", name);
	print("Probe function argstr: %s\n", argstr);
	print("dev = %l\n", dev);
	print("devname = %s\n", devname);
	print("ino = %l\n", ino);
	print("index = %ll\n", index);
}

probe vfs.remove_from_page_cache.return
{
	print("Probe return from function: %s with return value = %s\n", name, retstr);
}

probe vfs.read
{
	print("Probe hit the function: %s\n", probefunc());
	print("file = %p\n", file);
	print("pos = %p\n", pos);
	print("buf = %p\n", buf);
}

probe vfs.read.return
{
	print("Probe return from function: %s with return value = %s\n", probefunc(), ret);
}

probe vfs.readv
{
	print("Probe hit the function: %s\n", probefunc());
	print("file = %p\n", file);
	print("pos = %p\n", pos);
	print("vec = %p\n", vec);
	print("vlen = %lu\n", vlen);
}

probe vfs.readv.return
{
	print("Probe return from function: %s with return value = %s\n", probefunc(), ret);
}

probe vfs.write
{
	print("Probe hit the function: %s\n", probefunc());
	print("file = %p\n", file);
	print("pos = %p\n", pos);
	print("buf = %p\n", buf);
}

probe vfs.write.return
{
	print("Probe return from function: %s with return value = %s\n", probefunc(), ret);
}

probe vfs.writev
{
	print("Probe hit the function: %s\n", probefunc());
	print("file = %p\n", file);
	print("pos = %p\n", pos);
	print("vec = %p\n", vec);
	print("vlen = %lu\n", vlen);
}

probe vfs.writev.return
{
	print("Probe return from function: %s with return value = %s\n", probefunc(), ret);
}

probe _vfs.generic_file_readonly_mmap
{
	print("Probe hit the function: %s\n", probefunc());
	print("file = %p\n", file);
	print("vma = %p\n", vma);
}

probe _vfs.generic_file_readonly_mmap.return
{
	print("Probe return from function: %s with return value = %s\n", probefunc(), ret);
}

probe _vfs.generic_block_bmap
{
	print("Probe hit the function: %s\n", probefunc());
	print("mapping = %p\n", mapping);
	print("block = %llu\n", block);
	print("get_block = %p\n", get_block);
}

probe _vfs.generic_commit_write
{
	print("Probe hit the function: %s\n", probefunc());
	print("file = %p\n", file);
	print("page = %p\n", page);
	print("from = %u to=%u\n", from, to);
}

probe _vfs.block_prepare_write
{
	print("Probe hit the function: %s\n", probefunc());
	print("_inode = %p\n", _inode);
	print("page = %p\n", page);
	print("write_from = %u write_upto=%u\n", write_from, write_upto);
}
probe _vfs.block_prepare_write.return
{
	print("Probe return from function: %s with return value = %s\n", probefunc(), ret);
}

probe _vfs.block_write_begin
{
	print("Probe hit the function: %s\n", probefunc());
	print("file = %p\n", file);
	print("pos = %llu\n", pos);
	print("len = %u\n", len);
	print("flags = %u\n", flags);
	print("_inode = %l\n", _inode);
}
probe _vfs.block_write_begin.return
{
	print("Probe return from function: %s with return value = %s\n", probefunc(), ret);
}

probe _vfs.block_write_end
{
	print("Probe hit the function: %s\n", probefunc());
	print("file = %p\n", file);
	print("pos = %llu\n", pos);
	print("len = %u\n", len);
	print("page = %p\n", page);
	print("_inode = %l\n", _inode);
}

probe _vfs.block_write_end.return
{
	print("Probe return from function: %s with return value = %s\n", probefunc(), ret);
}

RE: [Patch 2/2] Enhancements to vfs.stp (with minor modifications)

[Stone, Joshua I]

K.Prasad wrote:
> +function __address_inode:long (page:long) %{ /* pure */
> +	struct page *page = (struct page *)(long)THIS->page;
> +	struct address_space *mapping =
> +			(struct address_space *)(long)THIS;

This typecast looks extremely suspect...

Josh

Re: [Patch 2/2] Enhancements to vfs.stp (with minor modifications)

[K.Prasad]

On Mon, Jun 09, 2008 at 11:10:08AM -0700, Stone, Joshua I wrote:
> K.Prasad wrote:
> > +function __address_inode:long (page:long) %{ /* pure */
> > +	struct page *page = (struct page *)(long)THIS->page;
> > +	struct address_space *mapping =
> > +			(struct address_space *)(long)THIS;
> 
> This typecast looks extremely suspect...

Given that the same assignment sequence is done in __page_bdev without a
typecast for address_space I will change the above two lines to become:
+   struct page *page = (struct page *)(long)THIS->page;
+   struct address_space *mapping = (long)THIS;

Thanks,
K.Prasad

output unknown bits in _stp_lookup_or_str

[Zhaolei]

Hi, everyone

We are using _stp_lookup_or_str to translate flags into string now.
When flags include some unknown bits, they are ignored by _stp_lookup_or_str.

For example:
If fork_flags is set to CLONE_CHILD_CLEARTID | 0x00001000, It is translated
into:
  "CLONE_CHILD_CLEARTID".
Maybe it is better to show the unknown bits too, For example:
  "CLONE_CHILD_CLEARTID|0x00001000".

For the new flags added in latest kernel, I think the best way is to add them
to flag lists in tapset. But for _stp_lookup_or_str() itself, it is better to
show them to user.

This function can be done with following patch.
It will change output of functions that use _stp_lookup_or_str.
I am wondering use it or not. Is there any suggestion?

Signed-off-by: "Zhaolei" zhaolei@cn.fujitsu.com

diff --git a/tapset/aux_syscalls.stp b/tapset/aux_syscalls.stp
index 2bd2ced..5fd3440 100644
--- a/tapset/aux_syscalls.stp
+++ b/tapset/aux_syscalls.stp
@@ -1548,7 +1548,7 @@ void _stp_lookup_str(const _stp_val_array * const array, long val, char *ptr, in
 }
 void _stp_lookup_or_str(const _stp_val_array * const array, long val, char *ptr, int len)
 {
- int i = 0, flag = 0;
+ int i = 0, flag = 0, slen;

  if (val == 0) {
   _stp_lookup_str(array, val, ptr, len);
@@ -1560,13 +1560,16 @@ void _stp_lookup_or_str(const _stp_val_array * const array, long val, char *ptr,
    if (flag)
     strlcat(ptr, "|", len);
    strlcat(ptr, array[i].name, len);
+   val = val & (~array[i].val);
    flag = 1;
   }
   i++;
  }
- if (flag == 0) {
-  int slen = strlen(ptr);
-  _stp_snprintf(ptr + slen, len - slen, "0x%lx", val);
+ if (val) {
+  if (flag)
+   strlcat(ptr, "|", len);
+  slen = strlen(ptr);
+  _stp_snprintf(ptr + slen, len - slen, "0x%lx", val);
  }
 }
 %}

Regards
Zhaolei

[PATCH]add termination-signal in __fork_flags()'s output

[Zhaolei]

Hi -

This patch adds termination-signal in __fork_flags()'s output.

For example:
syscall.fork's argstr before patch:
  CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID
syscall.fork's argstr after patch:
  CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD

If no objection, I will commit it.

Signed-off-by: "Zhaolei" zhaolei@cn.fujitsu.com

diff --git a/tapset/aux_syscalls.stp b/tapset/aux_syscalls.stp
index 2bd2ced..0a02271 100644
--- a/tapset/aux_syscalls.stp
+++ b/tapset/aux_syscalls.stp
@@ -1705,7 +1705,13 @@ const _stp_val_array const _stp_fork_list[] = {

 function __fork_flags:string(flags:long)
 %{ /* pure */
- _stp_lookup_or_str(_stp_fork_list, THIS->flags, THIS->__retvalue, MAXSTRINGLEN);
+ _stp_lookup_or_str(_stp_fork_list, THIS->flags & ~0xff, THIS->__retvalue, MAXSTRINGLEN);
+ if ( THIS->flags & 0xff ) {
+  /* flags contains the termination signal */
+  if (*THIS->__retvalue)
+   strlcat(THIS->__retvalue, "|", MAXSTRINGLEN);
+  _stp_lookup_str(_stp_signal_list, THIS->flags & 0xff, THIS->__retvalue, MAXSTRINGLEN);
+ }
 %}

 %{

Regards
Zhaolei

RE: [Patch 2/2] Enhancements to vfs.stp (with minor modifications)

[Stone, Joshua I]

K.Prasad wrote:
> On Mon, Jun 09, 2008 at 11:10:08AM -0700, Stone, Joshua I wrote:
>> K.Prasad wrote:
>>> +function __address_inode:long (page:long) %{ /* pure */
>>> +	struct page *page = (struct page *)(long)THIS->page;
>>> +	struct address_space *mapping =
>>> +			(struct address_space *)(long)THIS;
>> 
>> This typecast looks extremely suspect...
>  Given that the same assignment sequence is done in __page_bdev
> without a typecast for address_space I will change the above two
> lines to become:
> +   struct page *page = (struct page *)(long)THIS->page;
> +   struct address_space *mapping = (long)THIS;

Sorry I wasn't clear.  I have no issue with the syntax of the cast.  The
problem is that you're casting the THIS pointer to a completely
different type.

In __page_bdev() it uses "kread(&(page->mapping))", which seems more
like what you would want here.

Josh

Re: output unknown bits in _stp_lookup_or_str

[Zhaolei]

Hi, everyone

If no objection, I will commit this patch.

Regards
Zhaolei

> Hi, everyone
> 
> We are using _stp_lookup_or_str to translate flags into string now.
> When flags include some unknown bits, they are ignored by _stp_lookup_or_str.
> 
> For example:
> If fork_flags is set to CLONE_CHILD_CLEARTID | 0x00001000, It is translated
> into:
>  "CLONE_CHILD_CLEARTID".
> Maybe it is better to show the unknown bits too, For example:
>  "CLONE_CHILD_CLEARTID|0x00001000".
> 
> For the new flags added in latest kernel, I think the best way is to add them
> to flag lists in tapset. But for _stp_lookup_or_str() itself, it is better to
> show them to user.
> 
> This function can be done with following patch.
> It will change output of functions that use _stp_lookup_or_str.
> I am wondering use it or not. Is there any suggestion?
> 
> Signed-off-by: "Zhaolei" zhaolei@cn.fujitsu.com
> 
> diff --git a/tapset/aux_syscalls.stp b/tapset/aux_syscalls.stp
> index 2bd2ced..5fd3440 100644
> --- a/tapset/aux_syscalls.stp
> +++ b/tapset/aux_syscalls.stp
> @@ -1548,7 +1548,7 @@ void _stp_lookup_str(const _stp_val_array * const array, long val, char *ptr, in
> }
> void _stp_lookup_or_str(const _stp_val_array * const array, long val, char *ptr, int len)
> {
> - int i = 0, flag = 0;
> + int i = 0, flag = 0, slen;
> 
>  if (val == 0) {
>   _stp_lookup_str(array, val, ptr, len);
> @@ -1560,13 +1560,16 @@ void _stp_lookup_or_str(const _stp_val_array * const array, long val, char *ptr,
>    if (flag)
>     strlcat(ptr, "|", len);
>    strlcat(ptr, array[i].name, len);
> +   val = val & (~array[i].val);
>    flag = 1;
>   }
>   i++;
>  }
> - if (flag == 0) {
> -  int slen = strlen(ptr);
> -  _stp_snprintf(ptr + slen, len - slen, "0x%lx", val);
> + if (val) {
> +  if (flag)
> +   strlcat(ptr, "|", len);
> +  slen = strlen(ptr);
> +  _stp_snprintf(ptr + slen, len - slen, "0x%lx", val);
>  }
> }
> %}
> 
> Regards
> Zhaolei