// nfs tapset
// Copyright (C) 2006-2007 IBM Corp.
// Copyright (C) 2007 Intel Corporation.
// Copyright (C) 2007 Bull S.A.S
//
// 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.

%{
#include <linux/kernel.h>
#include <linux/nfs_fs.h>
%}

/*Get cache_validity flag from struct inode*/
function __nfsi_cache_valid:long(inode:long) %{ /* pure */
    struct inode * inode = (struct inode *)(long)(THIS->inode);

    if(inode == NULL) 
        THIS->__retvalue = -1;
    else {
        struct nfs_inode * nfsi = NFS_I(inode);
        THIS->__retvalue = kread(&(nfsi->cache_validity));
    }
    CATCH_DEREF_FAULT();
%}

/*Get read_cache_jiffies from struct inode*/
function __nfsi_rcache_time :long (inode:long) %{ /* pure */
    struct inode * inode = (struct inode *)(long)(THIS->inode);

    if(inode == NULL) 
        THIS->__retvalue = -1;
    else {
        struct nfs_inode * nfsi = NFS_I(inode);
        THIS->__retvalue = kread(&(nfsi->read_cache_jiffies));
    }
    CATCH_DEREF_FAULT();
%}

/*Get attrtimeo from struct inode*/
function __nfsi_attr_time :long (inode:long) %{ /* pure */
    struct inode * inode = (struct inode *)(long)(THIS->inode);

    if(inode == NULL) 
        THIS->__retvalue = -1;
    else {
        struct nfs_inode * nfsi = NFS_I(inode);
        THIS->__retvalue = kread(&(nfsi->attrtimeo));
    }
    CATCH_DEREF_FAULT();
%}

/*Get ndirty from struct inode*/
function __nfsi_ndirty:long (inode:long) %{ /* pure */
    struct inode * inode = (struct inode *)(long)(THIS->inode);

    if(inode == NULL) 
        THIS->__retvalue = -1;
    else {
        struct nfs_inode * nfsi = NFS_I(inode);
#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,22)
        THIS->__retvalue = kread(&(nfsi->ndirty));
#else
        THIS->__retvalue = -1;
#endif
    }
    CATCH_DEREF_FAULT();
%}

/*Get rsize from struct inode*/
function __nfs_server_rsize:long (inode:long) %{ /* pure */
    struct inode * inode = (struct inode *)(long)(THIS->inode);

    if(inode == NULL) 
        THIS->__retvalue = -1;
    else {
        struct nfs_server * nfs_srv = NFS_SERVER(inode); /* FIXME: deref hazard! */
        THIS->__retvalue = kread(&(nfs_srv->rsize));
    }
    CATCH_DEREF_FAULT();
%}

/*Get version from struct inode*/
function __nfs_version:long (inode:long) %{ /* pure */
    struct inode * inode = (struct inode *)(long)(THIS->inode);

    if(inode == NULL) 
        THIS->__retvalue = -1;
    else {
        const struct nfs_rpc_ops *rpc_ops = NFS_PROTO(inode); /* FIXME: deref hazard! */
        THIS->__retvalue = kread(&(rpc_ops->version));
    }
    CATCH_DEREF_FAULT();
%}

/*Get wsize from struct inode*/
function __nfs_server_wsize:long (inode:long) %{ /* pure */
    struct inode * inode = (struct inode *)(long)(THIS->inode);

    if(inode == NULL) 
        THIS->__retvalue = -1;
    else {
        struct nfs_server * nfs_srv = NFS_SERVER(inode); /* FIXME: deref hazard! */
        THIS->__retvalue = kread(&(nfs_srv->wsize));
    }
    CATCH_DEREF_FAULT();
%}

/*Get rpages from struct inode*/
function __nfs_rpages:long (inode:long) %{ /* pure */
    struct inode * inode = (struct inode *)(long)(THIS->inode);

    if(inode == NULL) 
        THIS->__retvalue = -1;
    else {
        struct nfs_server * nfs_srv = NFS_SERVER(inode); /* FIXME: deref hazard! */
        THIS->__retvalue = kread(&(nfs_srv->rpages));
    }
    CATCH_DEREF_FAULT();
%}

/*Get wpages from struct inode*/
function __nfs_wpages:long(inode:long) %{ /* pure */
    struct inode * inode = (struct inode *)(long)(THIS->inode);

    if(inode == NULL) 
        THIS->__retvalue = -1;
    else {
        struct nfs_server * nfs_srv = NFS_SERVER(inode); /* FIXME: deref hazard! */
        THIS->__retvalue = kread(&(nfs_srv->wpages));
    }
    CATCH_DEREF_FAULT();
%}

/*Get struct inode from struct page*/
function __p2i :long(page:long) %{ /* pure */
    struct page *page = (struct page *)((long)THIS->page);
    struct address_space *mapping = page? kread(&(page->mapping)) : NULL;

    if (mapping == NULL)
        THIS->__retvalue = 0;
    else
        THIS->__retvalue = (long)kread(&(mapping->host));
    CATCH_DEREF_FAULT();
%}

/*Get i_flags from struct page*/
function __p2i_flag : long (page:long) %{ /* pure */
    struct page *page = (struct page *)((long)THIS->page);
    struct address_space *mapping = page? kread(&(page->mapping)) : NULL;
    struct inode *host = mapping? kread(&(mapping->host)) : NULL;

    if (host == NULL)
        THIS->__retvalue = -1;
    else
        THIS->__retvalue = kread(&(host->i_flags));
    CATCH_DEREF_FAULT();
%}

/*Get i_state from struct page*/
function __p2i_state :long (page:long) %{ /* pure */
    struct page *page = (struct page *)((long)THIS->page);
    struct address_space *mapping = page? kread(&(page->mapping)) : NULL;
    struct inode *host = mapping? kread(&(mapping->host)) : NULL;

    if (host == NULL)
        THIS->__retvalue = -1;
    else
        THIS->__retvalue = kread(&(host->i_state));
    CATCH_DEREF_FAULT();
%}

/*Get i_size from struct page*/
function __p2i_size :long (page:long) %{ /* pure */
    struct page *page = (struct page *)((long)THIS->page);
    struct address_space *mapping = page? kread(&(page->mapping)) : NULL;
    struct inode *host = mapping? kread(&(mapping->host)) : NULL;

    if (host == NULL)
        THIS->__retvalue = -1;
    else
        THIS->__retvalue = kread(&(host->i_size));
    CATCH_DEREF_FAULT();
%}

/*Get s_flags from struct page*/
function __p2sb_flag:long (page:long) %{ /* pure */
    struct page *page = (struct page *)((long)THIS->page);
    struct address_space *mapping = page? kread(&(page->mapping)) : NULL;
    struct inode *host = mapping? kread(&(mapping->host)) : NULL;
	struct super_block *i_sb = host? kread(&(host->i_sb)) : NULL;

    if (i_sb == NULL)
        THIS->__retvalue = -1;
    else
        THIS->__retvalue = kread(&(i_sb->s_flags));
    CATCH_DEREF_FAULT();
%}

function __d_loff_t :long (ppos :long) %{ /* pure */
    loff_t * ppos = (loff_t *) ((long)THIS->ppos);

    if (ppos == NULL)
        THIS->__retvalue = -1;
    else
        THIS->__retvalue = kread(ppos);
    CATCH_DEREF_FAULT();
%}

function __file_inode:long (file:long) %{ /* pure */
    struct file *file = (struct file *)(long)THIS->file;
    struct dentry *dentry = file? kread(&(file->f_dentry)) : NULL;
    if (dentry == NULL)
        THIS->__retvalue = 0;
    else
        THIS->__retvalue = (long)kread(&(dentry->d_inode));
    CATCH_DEREF_FAULT();
%}

function __file_id:long (file:long) %{ /* pure */
    struct file *file = (struct file *)(long)THIS->file;
    struct dentry *dentry = file? kread(&(file->f_dentry)) : NULL;
    if (dentry == NULL)
        THIS->__retvalue = 0;
    else {
        struct inode *d_inode = kread(&(dentry->d_inode));
        struct super_block *i_sb = kread(&(d_inode->i_sb));
        THIS->__retvalue = (long)&(i_sb->s_id);
    }
    CATCH_DEREF_FAULT();
%}

function __file_mode:long (file:long) %{ /* pure */
    struct file *file = (struct file *)(long)THIS->file;
    struct dentry *dentry = file? kread(&(file->f_dentry)) : NULL;
    if (dentry == NULL)
        THIS->__retvalue = 0;
    else {
        struct inode *d_inode = kread(&(dentry->d_inode));
        THIS->__retvalue = kread(&(d_inode->i_mode));
    }
    CATCH_DEREF_FAULT();
%}

function __file_parentname:string (file:long) %{ /* pure */
    struct file *file = (struct file *)(long)THIS->file;
    struct dentry *dentry = file? kread(&(file->f_dentry)) : NULL;
    struct dentry *d_parent = dentry? kread(&(dentry->d_parent)) : NULL;
    if (d_parent == NULL)
        strlcpy(THIS->__retvalue, "NULL", MAXSTRINGLEN);
    else {
        const unsigned char *name = kread(&(d_parent->d_name.name));
        deref_string(THIS->__retvalue, name, MAXSTRINGLEN);
    }
    CATCH_DEREF_FAULT();
%}

/*
 * Combination of generic_segment_checks and iov_length functions
 * @iov:        io vector request
 * @nr_segs:    number of segments in the iovec
 * @check_flag:  whether to check (0 as iov_length, 1 as generic_segment_checks)
 * @access_flags: valid when check_flag >0, type of access: VERIFY_READ - 0 or VERIFY_WRITE - 1
 *
 * @return:      number of bytes to write/read
*/
function __iov_length:long(iov:long, nr_segs:long, check_flag:long, access_flags:long) %{ /* pure */
        unsigned long seg;
        size_t ret = 0;
        const struct iovec *iov = (const struct iovec *)(long)THIS->iov;
        unsigned long nr_segs = (unsigned long)THIS->nr_segs;

        for (seg = 0; seg < nr_segs; seg++)
	{   __kernel_size_t iov_len  = kread(&(iov[seg].iov_len));
            ret += iov_len;
		
	    if (THIS->check_flag) {

                if (unlikely((ssize_t)(ret|iov_len) < 0)) {
			THIS->__retvalue = -EINVAL;
			return;
		}
                if (access_ok((int)THIS->access_flags, kread(&(iov[seg].iov_base)), iov_len))
                        continue;
                if (seg == 0) {
        		THIS->__retvalue = -EFAULT;
			return;
		}
                ret-= iov_len;     /* This segment is no good */
                break;
	   }
	}
        THIS->__retvalue = (long)ret;
        CATCH_DEREF_FAULT();
%}

probe nfs.fop.entries = nfs.fop.llseek,
                        nfs.fop.read,
                        nfs.fop.write,
                        nfs.fop.aio_read,
                        nfs.fop.aio_write,
                        nfs.fop.mmap,
                        nfs.fop.open,
                        nfs.fop.flush,
                        nfs.fop.release,
                        %( kernel_v <= "2.6.18" %? nfs.fop.sendfile, %)
                        nfs.fop.fsync,
                        nfs.fop.lock
{
}

probe nfs.fop.return = nfs.fop.llseek.return,
                        nfs.fop.read.return,
                        nfs.fop.write.return,
                        nfs.fop.aio_read.return,
                        nfs.fop.aio_write.return,
                        nfs.fop.mmap.return,
                        nfs.fop.open.return,
                        nfs.fop.flush.return,
                        nfs.fop.release.return,
                        %( kernel_v <= "2.6.18" %? nfs.fop.sendfile.return, %)
                        nfs.fop.fsync.return,
                        nfs.fop.lock.return
{
}

/*probe nfs.fop.llseek
 *
 *  Fires when do a llseek operation on nfs,it probes
 *  llseek file operation of nfs
 *
 *  Arguments:
 *     dev : device identifier
 *     ino : inode number
 *     offset : the offset of the file will be repositioned
 *     origin : the original position. The possible value could be:
 *         SEEK_SET
 *               The offset is set to offset bytes.
 *         SEEK_CUR
 *               The offset is set to its current location plus offset bytes.
 *         SEEK_END
 *               The offset is set to the size of the file plus offset bytes.
 *
*/
probe nfs.fop.llseek = kernel.function ("nfs_file_llseek") !,
                       module("nfs").function("nfs_file_llseek")
{
        dev = __file_dev($filp)
        ino = __file_ino($filp)
	s_id = __file_id($filp)
	devname = kernel_string(s_id)

        maxbyte = __file_maxbytes($filp)
        offset = $offset
        origin = $origin

        name = "nfs.fop.llseek"
        argstr = sprintf("%d, %d", offset, origin)
}

probe nfs.fop.llseek.return = kernel.function ("nfs_file_llseek").return !,
                              module("nfs").function("nfs_file_llseek").return
{
        name = "nfs.fop.llseek.return"
        retstr = sprintf("%d", $return)
}
/*probe nfs.fop.read
 *
 * Fires when do a read operation on nfs,it probes
 * read file operation of nfs
 * 
 * Arguments:
 *        
 *
*/
probe nfs.fop.read = vfs.do_sync_read
{
	s_id = __file_id($filp)
	devname = kernel_string(s_id)
        name = "nfs.fop.read"
}

probe nfs.fop.read.return = vfs.do_sync_read.return
{
        name = "nfs.fop.read.return"
}

/*probe nfs.fop.write
 *
 * Fires when do a write operation on nfs,it probes
 * write file operation of nfs
 * 
 * Arguments:
 *        
 *
*/

probe nfs.fop.write = vfs.do_sync_write
{
	s_id = __file_id($filp)
	devname = kernel_string(s_id)
        name = "nfs.fop.write"
}

probe nfs.fop.write.return = vfs.do_sync_write.return
{
        name = "nfs.fop.write.return"
}

/*probe nfs.fop.aio_read
 *
 * It probes aio_read file operation of nfs
 * 
 * Arguments:
 *    dev : device identifier
 *    ino : inode number        
 *    count : read bytes
 *    pos   : current position of file   
 *    buf   : the address of buf in user space
 *    parent_name : parent dir name
 *    file_name : file name
 *    cache_valid : cache related bit mask flag
 *    cache_time : when we started read-caching this inode
 *    attrtimeo :  how long the cached information is assumed
 *                 to be valid.
 *   We need to revalidate the cached attrs for this inode if
 *
 *      jiffies - read_cache_jiffies > attrtimeo
*/
probe nfs.fop.aio_read = kernel.function ("nfs_file_read") !,
                       module("nfs").function("nfs_file_read")
{
        dev = __file_dev($iocb->ki_filp)
        ino = __file_ino($iocb->ki_filp)
	s_id = __file_id($iocb->ki_filp)
	devname = kernel_string(s_id)

        pos = $pos

%( kernel_v >= "2.6.19" %?
	buf = $iov->iov_base
        count = __iov_length($iov,$nr_segs,0,-1)
%:
        buf = $buf
        count = $count
%)

        parent_name = __file_parentname($iocb->ki_filp)
        file_name = __file_filename($iocb->ki_filp)


        cache_valid = __nfsi_cache_valid(__file_inode($iocb->ki_filp))
        cache_time  = __nfsi_rcache_time(__file_inode($iocb->ki_filp))
        attr_time   = __nfsi_attr_time(__file_inode($iocb->ki_filp))


        name = "nfs.fop.aio_read"
        argstr = sprintf("%p,%d, %d",buf,count, pos)

        size = count
        units = "bytes"
}


probe nfs.fop.aio_read.return = kernel.function ("nfs_file_read").return !,
                                module("nfs").function("nfs_file_read").return
{
        name = "nfs.fop.aio_read.return"
        retstr = sprintf("%d", $return)

        if ($return > 0) {
                size = $return
                units = "bytes"
        }
}

/*probe nfs.fop.aio_write
 *
 * It probes aio_write file operation of nfs
 * 
 * Arguments:
 *    dev : device identifier
 *    ino : inode number        
 *    count : read bytes
 *    pos   : offset of the file 
 *    buf   : the address of buf in user space
 *    parent_name : parent dir name
 *    file_name : file name
 *
*/
probe nfs.fop.aio_write = kernel.function("nfs_file_write") !,
                          module("nfs").function("nfs_file_write")
{
        dev = __file_dev($iocb->ki_filp)
        ino = __file_ino($iocb->ki_filp)
	s_id = __file_id($iocb->ki_filp)
	devname = kernel_string(s_id)

        pos = $pos
%( kernel_v >= "2.6.19" %?
	buf = $iov->iov_base
        count = __iov_length($iov,$nr_segs,0,-1)
%:
        buf = $buf
        count = $count
%)
               
        parent_name = __file_parentname($iocb->ki_filp)
        file_name = __file_filename($iocb->ki_filp)

        name = "nfs.fop.aio_write"
        argstr = sprintf("%p, %d, %d", buf, count, pos)

        size = count
        units = "bytes"
}

probe nfs.fop.aio_write.return =  kernel.function("nfs_file_write").return !,
                          module("nfs").function("nfs_file_write").return
{
        name = "nfs.fop.aio_write.return"
        retstr = sprintf("%d", $return)

        if ($return > 0) {
                size = $return
                units = "bytes"
        }
}

/*probe nfs.fop.mmap
 *
 * Fires when do an mmap operation on nfs,
 * it probes mmap operation of nfs
 * 
 * Arguments:
 *    dev : device identifier
 *    ino : inode number        
 *    vm_start :  start address within vm_mm 
 *    vm_end   :  the first byte after end address within vm_mm
 *    vm_flag  :  vm flags
 *    buf   : the address of buf in user space
 *    parent_name : parent dir name
 *    file_name : file name
 *    cache_valid : cache related bit mask flag
 *    cache_time : when we started read-caching this inode
 *    attrtimeo :  how long the cached information is assumed
 *                 to be valid.
 *   We need to revalidate the cached attrs for this inode if
 *
 *      jiffies - read_cache_jiffies > attrtimeo
*/
probe nfs.fop.mmap = kernel.function("nfs_file_mmap") !,
                     module("nfs").function("nfs_file_mmap")
{
        dev = __file_dev($file)
        ino = __file_ino($file)
	s_id = __file_id($file)
	devname = kernel_string(s_id)

        vm_start = $vma->vm_start
        vm_end = $vma->vm_end
        vm_flags = $vma->vm_flags

        parent_name = __file_parentname($file)
        file_name = __file_filename($file)

        cache_valid = __nfsi_cache_valid(__file_inode($file))
        cache_time  = __nfsi_rcache_time(__file_inode($file))
        attr_time   = __nfsi_attr_time(__file_inode($file))

        name = "nfs.fop.mmap"
        argstr = sprintf("0x%x, 0x%x, 0x%x", vm_start, vm_end, vm_flags)
}

probe nfs.fop.mmap.return = kernel.function("nfs_file_mmap").return !,
                     module("nfs").function("nfs_file_mmap").return
{
        name = "nfs.fop.mmap.return"
        retstr = sprintf("%d", $return)
}

/*probe nfs.fop.open
 *
 * Fires when do an open operation on nfs,
 * it probes open file operation of nfs
 * 
 * Arguments:
 *    dev : device identifier
 *    ino : inode number        
 *    file_name : file name
 *    flag : file flag
 *    i_size : file length in bytes 
*/
probe nfs.fop.open = kernel.function("nfs_file_open") !,
                     module("nfs").function("nfs_file_open")
{
        dev = __file_dev($filp)
        ino = $inode->i_ino
	s_id = $inode->i_sb->s_id
	devname = kernel_string(s_id)

        filename = __file_filename($filp)
        flag = $filp->f_flags   

        i_size = $inode->i_size
   
        name = "nfs.fop.open"
        argstr = sprintf("%d,%d, %s", flag, ino, filename)
}

probe nfs.fop.open.return = kernel.function("nfs_file_open").return !,
                            module("nfs").function("nfs_file_open").return
{
        name = "nfs.fop.open.return"
        retstr = sprintf("%d", $return)        
}

/*probe nfs.fop.flush
 *
 * Fires when do a flush file operation on nfs,
 * it probes flush file operation of nfs
 * 
 * Arguments:
 *    dev : device identifier
 *    ino : inode number        
 *    mode : file mode
 *    ndirty : number of dirty page
*/
probe nfs.fop.flush = kernel.function("nfs_file_flush") !,
                      module("nfs").function("nfs_file_flush")
{
        dev = __file_dev($file)
        ino = __file_ino($file)
	s_id = __file_id($file)
	devname = kernel_string(s_id)

        mode = $file->f_mode
        ndirty = __nfsi_ndirty(__file_inode($file))

        name = "nfs.fop.flush"
        argstr = sprintf("%d",ino)
}

probe nfs.fop.flush.return = kernel.function("nfs_file_flush").return !,
                      module("nfs").function("nfs_file_flush").return
{
        name = "nfs.fop.flush.return"
        retstr = sprintf("%d",$return)
}

/*probe nfs.fop.release
 *
 * Fires when do a release page operation on nfs,
 * it probes release file operation of nfs
 * 
 * Arguments:
 *    dev : device identifier
 *    ino : inode number        
 *    mode : file mode
*/
probe nfs.fop.release = kernel.function("nfs_file_release") !,
                      module("nfs").function("nfs_file_release")
{
        dev = __file_dev($filp)
        ino = $inode->i_ino
	s_id = $inode->i_sb->s_id
	devname = kernel_string(s_id)

        mode = $filp->f_mode

        name = "nfs.fop.release"
        argstr = sprintf("%d" , ino)
}

probe nfs.fop.release.return = kernel.function("nfs_file_release").return !,
                               module("nfs").function("nfs_file_release").return
{
        name = "nfs.fop.release.return"
        retstr = sprintf("%d", $return)
}

/*probe nfs.fop.fsync
 *
 * Fires when do a fsync operation on nfs,
 * it probes fsync file operation of nfs
 * 
 * Arguments:
 *    dev : device identifier
 *    ino : inode number       
 *    ndirty : number of dirty pages 
*/
probe nfs.fop.fsync = kernel.function("nfs_fsync") !,
                      module("nfs").function("nfs_fsync")
{
        dev = __file_dev($file)
        ino = __file_ino($file)
	s_id = __file_id($file)
	devname = kernel_string(s_id)

        ndirty = __nfsi_ndirty(__file_inode($file))

        name = "nfs.fop.fsync"
	argstr = sprintf("%d",ino)  
}

probe nfs.fop.fsync.return = kernel.function("nfs_fsync").return !,
                             module("nfs").function("nfs_fsync").return
{
        name = "nfs.fop.fsync.return"
        retstr = sprintf("%d", $return)
}

/*probe nfs.fop.lock
 *
 * Fires when do a file lock operation on nfs,
 * it probes lock file operation of nfs
 * 
 * Arguments:
 *    dev : device identifier
 *    ino : inode number      
 *    i_mode : file type and access rights
 *    cmd : cmd arguments
 *    fl_type :lock type
 *    fl_flag : lock flags
 *    fl_start : starting offset of locked region 
 *    fl_end   : ending offset of locked region  
*/
probe nfs.fop.lock = kernel.function("nfs_lock") !,
                     module("nfs").function("nfs_lock")
{
        dev = __file_dev($filp)
        ino = __file_ino($filp)
	s_id = __file_id($filp)
	devname = kernel_string(s_id)
 
        i_mode = __file_mode($filp)
        cmd = $cmd
 
        fl_type = $fl->fl_type
        fl_flag = $fl->fl_flags
        fl_start = $fl->fl_start
        fl_end  = $fl->fl_end

        name = "nfs.fop.lock"
        argstr = sprintf("%d,%d",cmd,i_mode)
}

probe nfs.fop.lock.return = kernel.function("nfs_lock").return !,
                             module("nfs").function("nfs_lock").return
{
         name = "nfs.fop.lock.return"
         retstr = sprintf("%d",$return)
}


/*probe nfs.fop.sendfile
 *
 * Fires when do a send file  operation on nfs,
 * it probes sendfile file operation of nfs
 * 
 * Arguments:
 *    dev : device identifier
 *    ino : inode number     
 *    count : read bytes
 *    ppos : current position of file
 *    cache_valid : cache related bit mask flag
 *    cache_time : when we started read-caching this inode
 *    attrtimeo :  how long the cached information is assumed
 *                 to be valid.
 *   We need to revalidate the cached attrs for this inode if
 *
 *      jiffies - read_cache_jiffies > attrtimeo
*/
%( kernel_v <= "2.6.18" %?
probe nfs.fop.sendfile = kernel.function("nfs_file_sendfile") !,
                              module("nfs").function("nfs_file_sendfile")
{

        dev = __file_dev($filp)
        ino = __file_ino($filp)
	s_id = __file_id($filp)
	devname = kernel_string(s_id)

        count = $count
        ppos  = __d_loff_t($ppos)

        cache_valid = __nfsi_cache_valid(__file_inode($filp))
        cache_time  = __nfsi_rcache_time(__file_inode($filp))
        attr_time   = __nfsi_attr_time(__file_inode($filp))

        name = "nfs.fop.sendfile"
        argstr = sprintf("%d,%d", count,ppos)

        size = count
        units = "bytes"
}

probe nfs.fop.sendfile.return = kernel.function("nfs_file_sendfile").return !,
                              module("nfs").function("nfs_file_sendfile").return
{
        name = "nfs.fop.sendfile.return"
        retstr = sprintf("%d", $return)

        if ($return > 0) {
                size = $return
                units = "bytes"
        }
}
%)

/*probe nfs.fop.check_flags
 *
 * Fires when do a checking flag  operation on nfs,
 * it probes check_flag file operation of nfs
 * 
 * Arguments:
 *    flag : file flag
*/
probe nfs.fop.check_flags =  kernel.function("nfs_check_flags") !,
                             module("nfs").function("nfs_check_flags")
{
        flag = $flags
        
        name = "nfs.fop.check_flags"
        argstr = sprintf("%d",flag)
}

probe nfs.fop.check_flags.return =  kernel.function("nfs_check_flags").return !,
                             module("nfs").function("nfs_check_flags").return
{
        name = "nfs.fop.check_flags.return"
        retstr = sprintf("%d",$return)
}

probe nfs.aop.entries = nfs.aop.readpage,
                        nfs.aop.readpages,
                        nfs.aop.writepage,
                        nfs.aop.writepages,
                        nfs.aop.release_page ?,
                        nfs.aop.prepare_write,
                        nfs.aop.commit_write
{
}
 
probe nfs.aop.return = nfs.aop.readpage.return,
                        nfs.aop.readpages.return,
                        nfs.aop.writepage.return,
                        nfs.aop.writepages.return,
                        nfs.aop.release_page.return ?,
                        nfs.aop.prepare_write.return,
                        nfs.aop.commit_write.return
{
}

/* probe nfs.aop.readpage
 *
 *   Read the page ,only fies when a previous async
 *   read operation failed
 *
 * Arguments:
 *   __page : the address of page
 *   dev : device identifier
 *   ino : inode number    
 *   i_flag : file flags
 *   i_size : file length in bytes
 *   sb_flag : super block flags
 *   file  : file argument
 *   page_index : offset within mapping, can used a 
                  page identifier and position identifier
                  in the page frame
 *   rsize :  read size  (in bytes)
 *   size :  number of pages to be read in this execution 
 */
probe nfs.aop.readpage = kernel.function ("nfs_readpage") !,
        module("nfs").function ("nfs_readpage")
{
        __page = $page
        dev = __page_dev(__page)
        ino = __page_ino(__page)

        i_flag = __p2i_flag($page) 
        i_size = __p2i_size($page)
 
        sb_flag = __p2sb_flag($page) 

        file = $file
        page_index = $page->index
        
        __inode = __p2i($page) 
        rsize = __nfs_server_rsize(__inode)

        name = "nfs.aop.readpage"
        argstr = sprintf("%d,%d" , page_index,rsize)

        size = 1
        units = "pages"
}

probe nfs.aop.readpage.return = kernel.function ("nfs_readpage").return !,
        module("nfs").function ("nfs_readpage").return
{
        name = "nfs.aop.readpage.return"
        retstr = sprintf("%d", $return)

        size = 1
        units = "pages"
}

/* probe nfs.aop.readpages
 *
 * Fies when in readahead way,read several pages once
 * Arguments:
 *   dev : device identifier
 *   ino : inode number   
 *   nr_pages :  number of pages attempted to read in this execution 
 *   file : filp argument
 *   rpages : read size (in pages) 
 *   rsize  : read size (in bytes)
 *   size :  number of pages attempted to read in this execution 
 */
probe nfs.aop.readpages =  kernel.function ("nfs_readpages") !,
        module("nfs").function ("nfs_readpages")
{
        dev = $mapping->host->i_sb->s_dev
        ino = $mapping->host->i_ino

        nr_pages = $nr_pages
        file = $filp

        rpages = __nfs_rpages($mapping->host)
        rsize  = __nfs_server_rsize($mapping->host)

        name = "nfs.aop.readpages"
        argstr = sprintf("%d" , nr_pages)

        size = nr_pages
        units = "pages"
}

probe nfs.aop.readpages.return = kernel.function ("nfs_readpages").return !,
        module("nfs").function ("nfs_readpages").return
{
        name = "nfs.aop.readpages.return"
        retstr = sprintf("%d", $return)


        if($return > 0 )
        {
            size = retstr
        }
        units = "pages"
}
/*probe nfs.aop.set_page_dirty
 *
 *   __set_page_dirty_nobuffers is used to set a page dirty,but
 *   not all the buffers.
 *
 *  Arguments:
 *     __page : the address of page
 *      page_flag : page flags
*/
probe nfs.aop.set_page_dirty =
            kernel.function ("__set_page_dirty_nobuffers") !,
             module("nfs").function ("__set_page_dirty_nobuffers")
{
 /*       dev = $mapping->host->i_sb->s_dev
        devname = __find_bdevname(dev, $mapping->host->i_sb->s_bdev)
        ino = $mapping->host->i_ino
*/
        __page = $page
        page_flag = $page->flags

        name = "nfs.aop.set_page_dirty"
        argstr = sprintf("%d",page_flag)
}

probe nfs.aop.set_page_dirty.return =
            kernel.function ("__set_page_dirty_nobuffers") .return !,
            module("nfs").function ("__set_page_dirty_nobuffers").return
{
        name = "nfs.aop.set_page_dirty.return"
        retstr = sprintf("%d", $return)
}

/*probe nfs.aop.writepage
 *
 *   Write an mapped page to the server
 *
 *  Arguments:
 *     __page : the address of page
 *     dev : device identifier
 *     ino : inode number  
 *     for_reclaim : a flag of writeback_control, indicates if it's invoked from the page allocator 
 *     for_kupdate : a flag of writeback_control, indicates if it's a kupdate writeback
 *      The priority of wb is decided by above two flags
 *     i_flag : file flags
 *     i_size : file length in bytes
 *     i_state : inode state flags
 *     sb_flag : super block flags
 *     page_index : offset within mapping, can used a 
                    page identifier and position identifier
                    in the page frame
 *     wsize :  write size
 *     size  :  number of pages to be written in this execution 
*/
probe nfs.aop.writepage =  kernel.function ("nfs_writepage") !,
             module("nfs").function ("nfs_writepage")
{
        __page = $page
        dev = __page_dev(__page)
        ino = __page_ino(__page)
        

        for_reclaim = $wbc->for_reclaim
        for_kupdate = $wbc->for_kupdate

        i_flag = __p2i_flag($page) 
        i_state = __p2i_state($page)
        i_size = __p2i_size($page)

        sb_flag = __p2sb_flag($page) 


        page_index = $page->index

        __inode = __p2i($page)
        wsize = __nfs_server_wsize(__inode)            
 
        name = "nfs.aop.writepage"
        argstr = sprintf("%d",page_index)

        size = 1
        units = "pages"
}

probe nfs.aop.writepage.return =  kernel.function ("nfs_writepage").return !,
             module("nfs").function ("nfs_writepage").return
{
        name = "nfs.aop.writepage.return"
        retstr = sprintf("%d", $return)
}

/*probe nfs.aop.writepages
 *  Write several dirty pages to the serve
 *Arguments:
 *     dev : device identifier
 *     ino : inode number  
 *     for_reclaim : a flag of writeback_control, indicates if it's invoked from the page allocator 
 *     for_kupdate : a flag of writeback_control, indicates if it's a kupdate writeback
 *      The priority of wb is decided by above two flags
 *      wsize :  write size
 *      wpages : write size (in pages)
 *      nr_to_write : number of pages attempted to be written in this execution  
 *      size : number of pages attempted to be written in this execution  
*/
probe nfs.aop.writepages =  kernel.function ("nfs_writepages") !,
             module("nfs").function ("nfs_writepages")
{
        dev = $mapping->host->i_sb->s_dev
        ino = $mapping->host->i_ino

        for_reclaim = $wbc->for_reclaim
        for_kupdate = $wbc->for_kupdate
        nr_to_write = $wbc->nr_to_write

        wsize = __nfs_server_wsize($mapping->host)
        wpages = __nfs_wpages($mapping->host)

        name = "nfs.aop.writepages"
        argstr = sprintf("%d",nr_to_write)

        size = nr_to_write
        units = "pages"         
}

probe nfs.aop.writepages.return =  kernel.function ("nfs_writepages").return !,
             module("nfs").function ("nfs_writepages").return
{
        name = "nfs.aop.writepages.return"
        retstr = sprintf("%d", $return)
}
/*probe nfs.aop.prepare_write
 *  Fires when do write operation on nfs.
 *     Prepare a page for writing
 *     Look for a request corresponding to the page. If there
 *     is one, and it belongs to another file, we flush it out
 *     before we try to copy anything into the page. 
 *     Also do the same if we find a request from an existing
 *     dropped page
 *
 *  Arguments:
 *     __page : the address of page
 *     dev : device identifier
 *     ino : inode number 
 *     offset : start address of this write operation 
 *     to     : end address of this write operation 
 *     page_index : offset within mapping, can used a 
                     page identifier and position identifier
                     in the page frame
 *     size   : write bytes
*/
probe nfs.aop.prepare_write=  kernel.function ("nfs_prepare_write") !,
             module("nfs").function ("nfs_prepare_write")
{
        __page = $page
        dev = __page_dev(__page)
        devname = __find_bdevname(dev, __page_bdev(__page))
        ino = __page_ino(__page)      
  
        offset = $offset
        to = $to
       
        page_index = $page->index

        name = "nfs.aop.prepare_write"
        argstr = sprintf("%d", page_index)

        size = to - offset
        units = "bytes"        
}

probe nfs.aop.prepare_write.return = 
                 kernel.function ("nfs_prepare_write").return !,
                 module("nfs").function ("nfs_prepare_write").return
{
        name = "nfs.aop.prepare_write.return"
        retstr = sprintf("%d", $return)
}

/*probe nfs.aop.commit_write
 *  Fires when do a write operation on nfs,
 *  often after prepare_write
 *
 *  Update and possibly write a cached page of an NFS file
 *
 *  Arguments:
 *     __page : the address of page
 *     dev : device identifier
 *     ino : inode number
 *     offset : start address of this write operation 
 *     to     : end address of this write operation
 *     i_flag : file flags
 *     i_size : file length in bytes
 *     sb_flag : super block flags
 *     page_index : offset within mapping, can used a 
                    page identifier and position identifier
                    in the page frame
 *     size   : write bytes
 */ 
probe nfs.aop.commit_write=  kernel.function ("nfs_commit_write") !,
             module("nfs").function ("nfs_commit_write")
{
         __page = $page
        dev = __page_dev(__page)
        ino = __page_ino(__page)

        offset = $offset
        to = $to
      

        i_flag = __p2i_flag($page) 
        i_size = __p2i_size($page)

        sb_flag = __p2sb_flag($page) 

        page_index = $page->index
     
        name = "nfs.aop.commit_write"
        argstr = sprintf("%d, %d",offset , to)

        size = to - offset
        units = "bytes"
}


probe nfs.aop.commit_write.return=  
             kernel.function ("nfs_commit_write").return !,
             module("nfs").function ("nfs_commit_write").return
{
        name = "nfs.aop.commit_write.return"
        retstr = sprintf("%d", $return)
}

/*probe nfs.aop.release_page
 *  Fires when do a release operation on nfs,
 *  
 *
 *  Arguments:
 *     __page : the address of page
 *     dev : device identifier
 *     ino : inode number
 *     page_index : offset within mapping, can used a 
                    page identifier and position identifier
                    in the page frame
 *     size : release pages
*/
probe nfs.aop.release_page =  kernel.function ("nfs_release_page") !,
             module("nfs").function ("nfs_release_page")
{
        __page = $page
        dev = __page_dev(__page)
        ino = __page_ino(__page)

//        gfp = $gfp
        page_index = $page->index

        name = "nfs.aop.release_page"
        argstr = sprintf("%d", page_index)

        size = 1
        units = "pages"

}  

probe nfs.aop.release_page.return =  kernel.function ("nfs_release_page").return !,
             module("nfs").function ("nfs_release_page").return
{
        name = "nfs.aop.release_page.return"
        retstr = sprintf("%d", $return)
}