xfs: drop dmapi hooks

Dmapi support was never merged upstream, but we still have a lot of hooks
bloating XFS for it, all over the fast pathes of the filesystem.

This patch drops over 700 lines of dmapi overhead.  If we'll ever get HSM
support in mainline at least the namespace events can be done much saner
in the VFS instead of the individual filesystem, so it's not like this
is much help for future work.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Dave Chinner <dchinner@redhat.com>

1 files changed, 0 insertions, 85 deletions

diff --git a/fs/xfs/linux-2.6/xfs_file.c b/fs/xfs/linux-2.6/xfs_file.c
index 257a56b127cf..dca06131551a 100644
--- a/fs/xfs/linux-2.6/xfs_file.c
+++ b/fs/xfs/linux-2.6/xfs_file.c
@@ -24,7 +24,6 @@
 #include "xfs_ag.h"
 #include "xfs_dir2.h"
 #include "xfs_trans.h"
-#include "xfs_dmapi.h"
 #include "xfs_mount.h"
 #include "xfs_bmap_btree.h"
 #include "xfs_alloc_btree.h"
@@ -275,20 +274,6 @@ xfs_file_aio_read(
                 mutex_lock(&inode->i_mutex);
         xfs_ilock(ip, XFS_IOLOCK_SHARED);
 
-        if (DM_EVENT_ENABLED(ip, DM_EVENT_READ) && !(ioflags & IO_INVIS)) {
-                int dmflags = FILP_DELAY_FLAG(file) | DM_SEM_FLAG_RD(ioflags);
-                int iolock = XFS_IOLOCK_SHARED;
-
-                ret = -XFS_SEND_DATA(mp, DM_EVENT_READ, ip, iocb->ki_pos, size,
-                                        dmflags, &iolock);
-                if (ret) {
-                        xfs_iunlock(ip, XFS_IOLOCK_SHARED);
-                        if (unlikely(ioflags & IO_ISDIRECT))
-                                mutex_unlock(&inode->i_mutex);
-                        return ret;
-                }
-        }
-
         if (unlikely(ioflags & IO_ISDIRECT)) {
                 if (inode->i_mapping->nrpages) {
                         ret = -xfs_flushinval_pages(ip,
@@ -321,7 +306,6 @@ xfs_file_splice_read(
         unsigned int            flags)
 {
         struct xfs_inode        *ip = XFS_I(infilp->f_mapping->host);
-        struct xfs_mount        *mp = ip->i_mount;
         int                     ioflags = 0;
         ssize_t                 ret;
 
@@ -335,18 +319,6 @@ xfs_file_splice_read(
 
         xfs_ilock(ip, XFS_IOLOCK_SHARED);
 
-        if (DM_EVENT_ENABLED(ip, DM_EVENT_READ) && !(ioflags & IO_INVIS)) {
-                int iolock = XFS_IOLOCK_SHARED;
-                int error;
-
-                error = XFS_SEND_DATA(mp, DM_EVENT_READ, ip, *ppos, count,
-                                        FILP_DELAY_FLAG(infilp), &iolock);
-                if (error) {
-                        xfs_iunlock(ip, XFS_IOLOCK_SHARED);
-                        return -error;
-                }
-        }
-
         trace_xfs_file_splice_read(ip, count, *ppos, ioflags);
 
         ret = generic_file_splice_read(infilp, ppos, pipe, count, flags);
@@ -367,7 +339,6 @@ xfs_file_splice_write(
 {
         struct inode            *inode = outfilp->f_mapping->host;
         struct xfs_inode        *ip = XFS_I(inode);
-        struct xfs_mount        *mp = ip->i_mount;
         xfs_fsize_t             isize, new_size;
         int                     ioflags = 0;
         ssize_t                 ret;
@@ -382,18 +353,6 @@ xfs_file_splice_write(
 
         xfs_ilock(ip, XFS_IOLOCK_EXCL);
 
-        if (DM_EVENT_ENABLED(ip, DM_EVENT_WRITE) && !(ioflags & IO_INVIS)) {
-                int iolock = XFS_IOLOCK_EXCL;
-                int error;
-
-                error = XFS_SEND_DATA(mp, DM_EVENT_WRITE, ip, *ppos, count,
-                                        FILP_DELAY_FLAG(outfilp), &iolock);
-                if (error) {
-                        xfs_iunlock(ip, XFS_IOLOCK_EXCL);
-                        return -error;
-                }
-        }
-
         new_size = *ppos + count;
 
         xfs_ilock(ip, XFS_ILOCK_EXCL);
@@ -627,7 +586,6 @@ xfs_file_aio_write(
         int                     ioflags = 0;
         xfs_fsize_t             isize, new_size;
         int                     iolock;
-        int                     eventsent = 0;
         size_t                  ocount = 0, count;
         int                     need_i_mutex;
 
@@ -673,33 +631,6 @@ start:
                 goto out_unlock_mutex;
         }
 
-        if ((DM_EVENT_ENABLED(ip, DM_EVENT_WRITE) &&
-            !(ioflags & IO_INVIS) && !eventsent)) {
-                int             dmflags = FILP_DELAY_FLAG(file);
-
-                if (need_i_mutex)
-                        dmflags |= DM_FLAGS_IMUX;
-
-                xfs_iunlock(ip, XFS_ILOCK_EXCL);
-                error = XFS_SEND_DATA(ip->i_mount, DM_EVENT_WRITE, ip,
-                                      pos, count, dmflags, &iolock);
-                if (error) {
-                        goto out_unlock_internal;
-                }
-                xfs_ilock(ip, XFS_ILOCK_EXCL);
-                eventsent = 1;
-
-                /*
-                 * The iolock was dropped and reacquired in XFS_SEND_DATA
-                 * so we have to recheck the size when appending.
-                 * We will only "goto start;" once, since having sent the
-                 * event prevents another call to XFS_SEND_DATA, which is
-                 * what allows the size to change in the first place.
-                 */
-                if ((file->f_flags & O_APPEND) && pos != ip->i_size)
-                        goto start;
-        }
-
         if (ioflags & IO_ISDIRECT) {
                 xfs_buftarg_t   *target =
                         XFS_IS_REALTIME_INODE(ip) ?
@@ -830,22 +761,6 @@ write_retry:
                 xfs_iunlock(ip, XFS_ILOCK_EXCL);
         }
 
-        if (ret == -ENOSPC &&
-            DM_EVENT_ENABLED(ip, DM_EVENT_NOSPACE) && !(ioflags & IO_INVIS)) {
-                xfs_iunlock(ip, iolock);
-                if (need_i_mutex)
-                        mutex_unlock(&inode->i_mutex);
-                error = XFS_SEND_NAMESP(ip->i_mount, DM_EVENT_NOSPACE, ip,
-                                DM_RIGHT_NULL, ip, DM_RIGHT_NULL, NULL, NULL,
-                                0, 0, 0); /* Delay flag intentionally  unused */
-                if (need_i_mutex)
-                        mutex_lock(&inode->i_mutex);
-                xfs_ilock(ip, iolock);
-                if (error)
-                        goto out_unlock_internal;
-                goto start;
-        }
-
         error = -ret;
         if (ret <= 0)
                 goto out_unlock_internal;