Merge branch 'xfs-4.10-misc-fixes-4' into for-next

11 files changed, 60 insertions, 173 deletions

diff --git a/Documentation/filesystems/xfs.txt b/Documentation/filesystems/xfs.txt
index c2d44e6e117b..3b9b5c149f32 100644
--- a/Documentation/filesystems/xfs.txt
+++ b/Documentation/filesystems/xfs.txt
@@ -51,13 +51,6 @@ default behaviour.
         CRC enabled filesystems always use the attr2 format, and so
         will reject the noattr2 mount option if it is set.
 
-  barrier (*)
-  nobarrier
-        Enables/disables the use of block layer write barriers for
-        writes into the journal and for data integrity operations.
-        This allows for drive level write caching to be enabled, for
-        devices that support write barriers.
-
   discard
   nodiscard (*)
         Enable/disable the issuing of commands to let the block
@@ -228,7 +221,10 @@ default behaviour.
 Deprecated Mount Options
 ========================
 
-None at present.
+  Name                          Removal Schedule
+  ----                          ----------------
+  barrier                       no earlier than v4.15
+  nobarrier                     no earlier than v4.15
 
 
 Removed Mount Options
diff --git a/fs/xfs/libxfs/xfs_alloc_btree.c b/fs/xfs/libxfs/xfs_alloc_btree.c
index 44cfcd03c451..efb467b10a71 100644
--- a/fs/xfs/libxfs/xfs_alloc_btree.c
+++ b/fs/xfs/libxfs/xfs_alloc_btree.c
@@ -421,7 +421,7 @@ xfs_allocbt_init_cursor(
 
         ASSERT(btnum == XFS_BTNUM_BNO || btnum == XFS_BTNUM_CNT);
 
-        cur = kmem_zone_zalloc(xfs_btree_cur_zone, KM_SLEEP);
+        cur = kmem_zone_zalloc(xfs_btree_cur_zone, KM_NOFS);
 
         cur->bc_tp = tp;
         cur->bc_mp = mp;
diff --git a/fs/xfs/libxfs/xfs_attr_leaf.c b/fs/xfs/libxfs/xfs_attr_leaf.c
index 8ea91f363093..2852521fc8ec 100644
--- a/fs/xfs/libxfs/xfs_attr_leaf.c
+++ b/fs/xfs/libxfs/xfs_attr_leaf.c
@@ -253,6 +253,7 @@ xfs_attr3_leaf_verify(
 {
         struct xfs_mount        *mp = bp->b_target->bt_mount;
         struct xfs_attr_leafblock *leaf = bp->b_addr;
+        struct xfs_perag *pag = bp->b_pag;
         struct xfs_attr3_icleaf_hdr ichdr;
 
         xfs_attr3_leaf_hdr_from_disk(mp->m_attr_geo, &ichdr, leaf);
@@ -273,7 +274,12 @@ xfs_attr3_leaf_verify(
                 if (ichdr.magic != XFS_ATTR_LEAF_MAGIC)
                         return false;
         }
-        if (ichdr.count == 0)
+        /*
+         * In recovery there is a transient state where count == 0 is valid
+         * because we may have transitioned an empty shortform attr to a leaf
+         * if the attr didn't fit in shortform.
+         */
+        if (pag && pag->pagf_init && ichdr.count == 0)
                 return false;
 
         /* XXX: need to range check rest of attr header values */
diff --git a/fs/xfs/libxfs/xfs_bmap_btree.c b/fs/xfs/libxfs/xfs_bmap_btree.c
index 94ad31d372ab..d6330c297ca0 100644
--- a/fs/xfs/libxfs/xfs_bmap_btree.c
+++ b/fs/xfs/libxfs/xfs_bmap_btree.c
@@ -796,7 +796,7 @@ xfs_bmbt_init_cursor(
         struct xfs_btree_cur    *cur;
         ASSERT(whichfork != XFS_COW_FORK);
 
-        cur = kmem_zone_zalloc(xfs_btree_cur_zone, KM_SLEEP);
+        cur = kmem_zone_zalloc(xfs_btree_cur_zone, KM_NOFS);
 
         cur->bc_tp = tp;
         cur->bc_mp = mp;
diff --git a/fs/xfs/libxfs/xfs_ialloc_btree.c b/fs/xfs/libxfs/xfs_ialloc_btree.c
index e7ff8ef0e5a7..0fd086d03d41 100644
--- a/fs/xfs/libxfs/xfs_ialloc_btree.c
+++ b/fs/xfs/libxfs/xfs_ialloc_btree.c
@@ -357,7 +357,7 @@ xfs_inobt_init_cursor(
         struct xfs_agi          *agi = XFS_BUF_TO_AGI(agbp);
         struct xfs_btree_cur    *cur;
 
-        cur = kmem_zone_zalloc(xfs_btree_cur_zone, KM_SLEEP);
+        cur = kmem_zone_zalloc(xfs_btree_cur_zone, KM_NOFS);
 
         cur->bc_tp = tp;
         cur->bc_mp = mp;
diff --git a/fs/xfs/xfs_buf.c b/fs/xfs/xfs_buf.c
index 516109424c96..509dd6cc1331 100644
--- a/fs/xfs/xfs_buf.c
+++ b/fs/xfs/xfs_buf.c
@@ -1737,8 +1737,7 @@ xfs_free_buftarg(
         percpu_counter_destroy(&btp->bt_io_count);
         list_lru_destroy(&btp->bt_lru);
 
-        if (mp->m_flags & XFS_MOUNT_BARRIER)
-                xfs_blkdev_issue_flush(btp);
+        xfs_blkdev_issue_flush(btp);
 
         kmem_free(btp);
 }
diff --git a/fs/xfs/xfs_file.c b/fs/xfs/xfs_file.c
index b837ad8a63e4..65d27a502909 100644
--- a/fs/xfs/xfs_file.c
+++ b/fs/xfs/xfs_file.c
@@ -149,19 +149,16 @@ xfs_file_fsync(
 
         xfs_iflags_clear(ip, XFS_ITRUNCATED);
 
-        if (mp->m_flags & XFS_MOUNT_BARRIER) {
-                /*
-                 * If we have an RT and/or log subvolume we need to make sure
-                 * to flush the write cache the device used for file data
-                 * first.  This is to ensure newly written file data make
-                 * it to disk before logging the new inode size in case of
-                 * an extending write.
-                 */
-                if (XFS_IS_REALTIME_INODE(ip))
-                        xfs_blkdev_issue_flush(mp->m_rtdev_targp);
-                else if (mp->m_logdev_targp != mp->m_ddev_targp)
-                        xfs_blkdev_issue_flush(mp->m_ddev_targp);
-        }
+        /*
+         * If we have an RT and/or log subvolume we need to make sure to flush
+         * the write cache the device used for file data first.  This is to
+         * ensure newly written file data make it to disk before logging the new
+         * inode size in case of an extending write.
+         */
+        if (XFS_IS_REALTIME_INODE(ip))
+                xfs_blkdev_issue_flush(mp->m_rtdev_targp);
+        else if (mp->m_logdev_targp != mp->m_ddev_targp)
+                xfs_blkdev_issue_flush(mp->m_ddev_targp);
 
         /*
          * All metadata updates are logged, which means that we just have to
@@ -196,10 +193,8 @@ xfs_file_fsync(
          * an already allocated file and thus do not have any metadata to
          * commit.
          */
-        if ((mp->m_flags & XFS_MOUNT_BARRIER) &&
-            mp->m_logdev_targp == mp->m_ddev_targp &&
-            !XFS_IS_REALTIME_INODE(ip) &&
-            !log_flushed)
+        if (!log_flushed && !XFS_IS_REALTIME_INODE(ip) &&
+            mp->m_logdev_targp == mp->m_ddev_targp)
                 xfs_blkdev_issue_flush(mp->m_ddev_targp);
 
         return error;
diff --git a/fs/xfs/xfs_iops.c b/fs/xfs/xfs_iops.c
index c962999a87ab..b930be0b1596 100644
--- a/fs/xfs/xfs_iops.c
+++ b/fs/xfs/xfs_iops.c
@@ -988,7 +988,7 @@ xfs_vn_setattr(
                         return error;
 
                 xfs_ilock(ip, XFS_MMAPLOCK_EXCL);
-                error = xfs_setattr_size(ip, iattr);
+                error = xfs_vn_setattr_size(dentry, iattr);
                 xfs_iunlock(ip, XFS_MMAPLOCK_EXCL);
         } else {
                 error = xfs_vn_setattr_nonsize(dentry, iattr);
diff --git a/fs/xfs/xfs_log.c b/fs/xfs/xfs_log.c
index 3ebe444eb60f..c39ac14ff540 100644
--- a/fs/xfs/xfs_log.c
+++ b/fs/xfs/xfs_log.c
@@ -1862,26 +1862,21 @@ xlog_sync(
 
         bp->b_io_length = BTOBB(count);
         bp->b_fspriv = iclog;
-        bp->b_flags &= ~(XBF_FUA | XBF_FLUSH);
-        bp->b_flags |= (XBF_ASYNC | XBF_SYNCIO | XBF_WRITE);
+        bp->b_flags &= ~XBF_FLUSH;
+        bp->b_flags |= (XBF_ASYNC | XBF_SYNCIO | XBF_WRITE | XBF_FUA);
 
-        if (log->l_mp->m_flags & XFS_MOUNT_BARRIER) {
-                bp->b_flags |= XBF_FUA;
-
-                /*
-                 * Flush the data device before flushing the log to make
-                 * sure all meta data written back from the AIL actually made
-                 * it to disk before stamping the new log tail LSN into the
-                 * log buffer.  For an external log we need to issue the
-                 * flush explicitly, and unfortunately synchronously here;
-                 * for an internal log we can simply use the block layer
-                 * state machine for preflushes.
-                 */
-                if (log->l_mp->m_logdev_targp != log->l_mp->m_ddev_targp)
-                        xfs_blkdev_issue_flush(log->l_mp->m_ddev_targp);
-                else
-                        bp->b_flags |= XBF_FLUSH;
-        }
+        /*
+         * Flush the data device before flushing the log to make sure all meta
+         * data written back from the AIL actually made it to disk before
+         * stamping the new log tail LSN into the log buffer.  For an external
+         * log we need to issue the flush explicitly, and unfortunately
+         * synchronously here; for an internal log we can simply use the block
+         * layer state machine for preflushes.
+         */
+        if (log->l_mp->m_logdev_targp != log->l_mp->m_ddev_targp)
+                xfs_blkdev_issue_flush(log->l_mp->m_ddev_targp);
+        else
+                bp->b_flags |= XBF_FLUSH;
 
         ASSERT(XFS_BUF_ADDR(bp) <= log->l_logBBsize-1);
         ASSERT(XFS_BUF_ADDR(bp) + BTOBB(count) <= log->l_logBBsize);
@@ -1906,10 +1901,8 @@ xlog_sync(
                 xfs_buf_associate_memory(bp,
                                 (char *)&iclog->ic_header + count, split);
                 bp->b_fspriv = iclog;
-                bp->b_flags &= ~(XBF_FUA | XBF_FLUSH);
-                bp->b_flags |= (XBF_ASYNC | XBF_SYNCIO | XBF_WRITE);
-                if (log->l_mp->m_flags & XFS_MOUNT_BARRIER)
-                        bp->b_flags |= XBF_FUA;
+                bp->b_flags &= ~XBF_FLUSH;
+                bp->b_flags |= (XBF_ASYNC | XBF_SYNCIO | XBF_WRITE | XBF_FUA);
 
                 ASSERT(XFS_BUF_ADDR(bp) <= log->l_logBBsize-1);
                 ASSERT(XFS_BUF_ADDR(bp) + BTOBB(count) <= log->l_logBBsize);
diff --git a/fs/xfs/xfs_super.c b/fs/xfs/xfs_super.c
index 563d1d146b8c..eecbaac08eba 100644
--- a/fs/xfs/xfs_super.c
+++ b/fs/xfs/xfs_super.c
@@ -104,9 +104,6 @@ static const match_table_t tokens = {
         {Opt_sysvgroups,"sysvgroups"},  /* group-ID from current process */
         {Opt_allocsize, "allocsize=%s"},/* preferred allocation size */
         {Opt_norecovery,"norecovery"},  /* don't run XFS recovery */
-        {Opt_barrier,   "barrier"},     /* use writer barriers for log write and
-                                         * unwritten extent conversion */
-        {Opt_nobarrier, "nobarrier"},   /* .. disable */
         {Opt_inode64,   "inode64"},     /* inodes can be allocated anywhere */
         {Opt_inode32,   "inode32"},     /* inode allocation limited to
                                          * XFS_MAXINUMBER_32 */
@@ -134,6 +131,12 @@ static const match_table_t tokens = {
         {Opt_nodiscard, "nodiscard"},   /* Do not discard unused blocks */
 
         {Opt_dax,       "dax"},         /* Enable direct access to bdev pages */
+
+        /* Deprecated mount options scheduled for removal */
+        {Opt_barrier,   "barrier"},     /* use writer barriers for log write and
+                                         * unwritten extent conversion */
+        {Opt_nobarrier, "nobarrier"},   /* .. disable */
+
         {Opt_err,       NULL},
 };
 
@@ -301,12 +304,6 @@ xfs_parseargs(
                 case Opt_nouuid:
                         mp->m_flags |= XFS_MOUNT_NOUUID;
                         break;
-                case Opt_barrier:
-                        mp->m_flags |= XFS_MOUNT_BARRIER;
-                        break;
-                case Opt_nobarrier:
-                        mp->m_flags &= ~XFS_MOUNT_BARRIER;
-                        break;
                 case Opt_ikeep:
                         mp->m_flags |= XFS_MOUNT_IKEEP;
                         break;
@@ -374,6 +371,14 @@ xfs_parseargs(
                         mp->m_flags |= XFS_MOUNT_DAX;
                         break;
 #endif
+                case Opt_barrier:
+                        xfs_warn(mp, "%s option is deprecated, ignoring.", p);
+                        mp->m_flags |= XFS_MOUNT_BARRIER;
+                        break;
+                case Opt_nobarrier:
+                        xfs_warn(mp, "%s option is deprecated, ignoring.", p);
+                        mp->m_flags &= ~XFS_MOUNT_BARRIER;
+                        break;
                 default:
                         xfs_warn(mp, "unknown mount option [%s].", p);
                         return -EINVAL;
@@ -1238,9 +1243,11 @@ xfs_fs_remount(
                 token = match_token(p, tokens, args);
                 switch (token) {
                 case Opt_barrier:
+                        xfs_warn(mp, "%s option is deprecated, ignoring.", p);
                         mp->m_flags |= XFS_MOUNT_BARRIER;
                         break;
                 case Opt_nobarrier:
+                        xfs_warn(mp, "%s option is deprecated, ignoring.", p);
                         mp->m_flags &= ~XFS_MOUNT_BARRIER;
                         break;
                 case Opt_inode64:
diff --git a/fs/xfs/xfs_trace.h b/fs/xfs/xfs_trace.h
index 0907752be62d..69c5bcd9a51b 100644
--- a/fs/xfs/xfs_trace.h
+++ b/fs/xfs/xfs_trace.h
@@ -355,7 +355,6 @@ DEFINE_BUF_EVENT(xfs_buf_rele);
 DEFINE_BUF_EVENT(xfs_buf_iodone);
 DEFINE_BUF_EVENT(xfs_buf_submit);
 DEFINE_BUF_EVENT(xfs_buf_submit_wait);
-DEFINE_BUF_EVENT(xfs_buf_bawrite);
 DEFINE_BUF_EVENT(xfs_buf_lock);
 DEFINE_BUF_EVENT(xfs_buf_lock_done);
 DEFINE_BUF_EVENT(xfs_buf_trylock_fail);
@@ -367,19 +366,15 @@ DEFINE_BUF_EVENT(xfs_buf_delwri_queue);
 DEFINE_BUF_EVENT(xfs_buf_delwri_queued);
 DEFINE_BUF_EVENT(xfs_buf_delwri_split);
 DEFINE_BUF_EVENT(xfs_buf_get_uncached);
-DEFINE_BUF_EVENT(xfs_bdstrat_shut);
 DEFINE_BUF_EVENT(xfs_buf_item_relse);
 DEFINE_BUF_EVENT(xfs_buf_item_iodone_async);
 DEFINE_BUF_EVENT(xfs_buf_error_relse);
 DEFINE_BUF_EVENT(xfs_buf_wait_buftarg);
-DEFINE_BUF_EVENT(xfs_trans_read_buf_io);
 DEFINE_BUF_EVENT(xfs_trans_read_buf_shut);
 
 /* not really buffer traces, but the buf provides useful information */
 DEFINE_BUF_EVENT(xfs_btree_corrupt);
-DEFINE_BUF_EVENT(xfs_da_btree_corrupt);
 DEFINE_BUF_EVENT(xfs_reset_dqcounts);
-DEFINE_BUF_EVENT(xfs_inode_item_push);
 
 /* pass flags explicitly */
 DECLARE_EVENT_CLASS(xfs_buf_flags_class,
@@ -541,7 +536,6 @@ DEFINE_BUF_ITEM_EVENT(xfs_trans_bjoin);
 DEFINE_BUF_ITEM_EVENT(xfs_trans_bhold);
 DEFINE_BUF_ITEM_EVENT(xfs_trans_bhold_release);
 DEFINE_BUF_ITEM_EVENT(xfs_trans_binval);
-DEFINE_BUF_ITEM_EVENT(xfs_trans_buf_ordered);
 
 DECLARE_EVENT_CLASS(xfs_filestream_class,
         TP_PROTO(struct xfs_inode *ip, xfs_agnumber_t agno),
@@ -680,7 +674,6 @@ DEFINE_INODE_EVENT(xfs_ioctl_setattr);
 DEFINE_INODE_EVENT(xfs_dir_fsync);
 DEFINE_INODE_EVENT(xfs_file_fsync);
 DEFINE_INODE_EVENT(xfs_destroy_inode);
-DEFINE_INODE_EVENT(xfs_evict_inode);
 DEFINE_INODE_EVENT(xfs_update_time);
 
 DEFINE_INODE_EVENT(xfs_dquot_dqalloc);
@@ -798,7 +791,6 @@ TRACE_EVENT(xfs_irec_merge_post,
 DEFINE_EVENT(xfs_iref_class, name, \
         TP_PROTO(struct xfs_inode *ip, unsigned long caller_ip), \
         TP_ARGS(ip, caller_ip))
-DEFINE_IREF_EVENT(xfs_ihold);
 DEFINE_IREF_EVENT(xfs_irele);
 DEFINE_IREF_EVENT(xfs_inode_pin);
 DEFINE_IREF_EVENT(xfs_inode_unpin);
@@ -939,7 +931,6 @@ DEFINE_DQUOT_EVENT(xfs_dqget_miss);
 DEFINE_DQUOT_EVENT(xfs_dqget_freeing);
 DEFINE_DQUOT_EVENT(xfs_dqget_dup);
 DEFINE_DQUOT_EVENT(xfs_dqput);
-DEFINE_DQUOT_EVENT(xfs_dqput_wait);
 DEFINE_DQUOT_EVENT(xfs_dqput_free);
 DEFINE_DQUOT_EVENT(xfs_dqrele);
 DEFINE_DQUOT_EVENT(xfs_dqflush);
@@ -1815,7 +1806,6 @@ DEFINE_ATTR_EVENT(xfs_attr_sf_addname);
 DEFINE_ATTR_EVENT(xfs_attr_sf_create);
 DEFINE_ATTR_EVENT(xfs_attr_sf_lookup);
 DEFINE_ATTR_EVENT(xfs_attr_sf_remove);
-DEFINE_ATTR_EVENT(xfs_attr_sf_removename);
 DEFINE_ATTR_EVENT(xfs_attr_sf_to_leaf);
 
 DEFINE_ATTR_EVENT(xfs_attr_leaf_add);
@@ -1844,7 +1834,6 @@ DEFINE_ATTR_EVENT(xfs_attr_leaf_toosmall);
 
 DEFINE_ATTR_EVENT(xfs_attr_node_addname);
 DEFINE_ATTR_EVENT(xfs_attr_node_get);
-DEFINE_ATTR_EVENT(xfs_attr_node_lookup);
 DEFINE_ATTR_EVENT(xfs_attr_node_replace);
 DEFINE_ATTR_EVENT(xfs_attr_node_removename);
 
@@ -2440,11 +2429,9 @@ DEFINE_DEFER_EVENT(xfs_defer_finish_done);
 
 DEFINE_DEFER_ERROR_EVENT(xfs_defer_trans_roll_error);
 DEFINE_DEFER_ERROR_EVENT(xfs_defer_finish_error);
-DEFINE_DEFER_ERROR_EVENT(xfs_defer_op_finish_error);
 
 DEFINE_DEFER_PENDING_EVENT(xfs_defer_intake_work);
 DEFINE_DEFER_PENDING_EVENT(xfs_defer_intake_cancel);
-DEFINE_DEFER_PENDING_EVENT(xfs_defer_pending_commit);
 DEFINE_DEFER_PENDING_EVENT(xfs_defer_pending_cancel);
 DEFINE_DEFER_PENDING_EVENT(xfs_defer_pending_finish);
 DEFINE_DEFER_PENDING_EVENT(xfs_defer_pending_abort);
@@ -3092,87 +3079,6 @@ DEFINE_EVENT(xfs_double_io_class, name,	\
                  struct xfs_inode *dest, xfs_off_t doffset), \
         TP_ARGS(src, soffset, len, dest, doffset))
 
-/* two-file vfs io tracepoint class */
-DECLARE_EVENT_CLASS(xfs_double_vfs_io_class,
-        TP_PROTO(struct inode *src, u64 soffset, u64 len,
-                 struct inode *dest, u64 doffset),
-        TP_ARGS(src, soffset, len, dest, doffset),
-        TP_STRUCT__entry(
-                __field(dev_t, dev)
-                __field(unsigned long, src_ino)
-                __field(loff_t, src_isize)
-                __field(loff_t, src_offset)
-                __field(size_t, len)
-                __field(unsigned long, dest_ino)
-                __field(loff_t, dest_isize)
-                __field(loff_t, dest_offset)
-        ),
-        TP_fast_assign(
-                __entry->dev = src->i_sb->s_dev;
-                __entry->src_ino = src->i_ino;
-                __entry->src_isize = i_size_read(src);
-                __entry->src_offset = soffset;
-                __entry->len = len;
-                __entry->dest_ino = dest->i_ino;
-                __entry->dest_isize = i_size_read(dest);
-                __entry->dest_offset = doffset;
-        ),
-        TP_printk("dev %d:%d count %zd "
-                  "ino 0x%lx isize 0x%llx offset 0x%llx -> "
-                  "ino 0x%lx isize 0x%llx offset 0x%llx",
-                  MAJOR(__entry->dev), MINOR(__entry->dev),
-                  __entry->len,
-                  __entry->src_ino,
-                  __entry->src_isize,
-                  __entry->src_offset,
-                  __entry->dest_ino,
-                  __entry->dest_isize,
-                  __entry->dest_offset)
-)
-
-#define DEFINE_DOUBLE_VFS_IO_EVENT(name)        \
-DEFINE_EVENT(xfs_double_vfs_io_class, name,     \
-        TP_PROTO(struct inode *src, u64 soffset, u64 len, \
-                 struct inode *dest, u64 doffset), \
-        TP_ARGS(src, soffset, len, dest, doffset))
-
-/* CoW write tracepoint */
-DECLARE_EVENT_CLASS(xfs_copy_on_write_class,
-        TP_PROTO(struct xfs_inode *ip, xfs_fileoff_t lblk, xfs_fsblock_t pblk,
-                 xfs_extlen_t len, xfs_fsblock_t new_pblk),
-        TP_ARGS(ip, lblk, pblk, len, new_pblk),
-        TP_STRUCT__entry(
-                __field(dev_t, dev)
-                __field(xfs_ino_t, ino)
-                __field(xfs_fileoff_t, lblk)
-                __field(xfs_fsblock_t, pblk)
-                __field(xfs_extlen_t, len)
-                __field(xfs_fsblock_t, new_pblk)
-        ),
-        TP_fast_assign(
-                __entry->dev = VFS_I(ip)->i_sb->s_dev;
-                __entry->ino = ip->i_ino;
-                __entry->lblk = lblk;
-                __entry->pblk = pblk;
-                __entry->len = len;
-                __entry->new_pblk = new_pblk;
-        ),
-        TP_printk("dev %d:%d ino 0x%llx lblk 0x%llx pblk 0x%llx "
-                  "len 0x%x new_pblk %llu",
-                  MAJOR(__entry->dev), MINOR(__entry->dev),
-                  __entry->ino,
-                  __entry->lblk,
-                  __entry->pblk,
-                  __entry->len,
-                  __entry->new_pblk)
-)
-
-#define DEFINE_COW_EVENT(name)  \
-DEFINE_EVENT(xfs_copy_on_write_class, name,     \
-        TP_PROTO(struct xfs_inode *ip, xfs_fileoff_t lblk, xfs_fsblock_t pblk, \
-                 xfs_extlen_t len, xfs_fsblock_t new_pblk), \
-        TP_ARGS(ip, lblk, pblk, len, new_pblk))
-
 /* inode/irec events */
 DECLARE_EVENT_CLASS(xfs_inode_irec_class,
         TP_PROTO(struct xfs_inode *ip, struct xfs_bmbt_irec *irec),
@@ -3292,8 +3198,6 @@ DEFINE_DOUBLE_IO_EVENT(xfs_reflink_remap_range);
 DEFINE_INODE_ERROR_EVENT(xfs_reflink_remap_range_error);
 DEFINE_INODE_ERROR_EVENT(xfs_reflink_set_inode_flag_error);
 DEFINE_INODE_ERROR_EVENT(xfs_reflink_update_inode_size_error);
-DEFINE_INODE_ERROR_EVENT(xfs_reflink_reflink_main_loop_error);
-DEFINE_INODE_ERROR_EVENT(xfs_reflink_read_iomap_error);
 DEFINE_INODE_ERROR_EVENT(xfs_reflink_remap_blocks_error);
 DEFINE_INODE_ERROR_EVENT(xfs_reflink_remap_extent_error);
 
@@ -3302,9 +3206,6 @@ DEFINE_DOUBLE_IO_EVENT(xfs_reflink_compare_extents);
 DEFINE_INODE_ERROR_EVENT(xfs_reflink_compare_extents_error);
 
 /* ioctl tracepoints */
-DEFINE_DOUBLE_VFS_IO_EVENT(xfs_ioctl_reflink);
-DEFINE_DOUBLE_VFS_IO_EVENT(xfs_ioctl_clone_range);
-DEFINE_DOUBLE_VFS_IO_EVENT(xfs_ioctl_file_extent_same);
 TRACE_EVENT(xfs_ioctl_clone,
         TP_PROTO(struct inode *src, struct inode *dest),
         TP_ARGS(src, dest),
@@ -3334,11 +3235,7 @@ TRACE_EVENT(xfs_ioctl_clone,
 
 /* unshare tracepoints */
 DEFINE_SIMPLE_IO_EVENT(xfs_reflink_unshare);
-DEFINE_SIMPLE_IO_EVENT(xfs_reflink_cow_eof_block);
-DEFINE_PAGE_EVENT(xfs_reflink_unshare_page);
 DEFINE_INODE_ERROR_EVENT(xfs_reflink_unshare_error);
-DEFINE_INODE_ERROR_EVENT(xfs_reflink_cow_eof_block_error);
-DEFINE_INODE_ERROR_EVENT(xfs_reflink_dirty_page_error);
 
 /* copy on write */
 DEFINE_INODE_IREC_EVENT(xfs_reflink_trim_around_shared);
@@ -3361,14 +3258,8 @@ DEFINE_INODE_ERROR_EVENT(xfs_reflink_allocate_cow_range_error);
 DEFINE_INODE_ERROR_EVENT(xfs_reflink_cancel_cow_range_error);
 DEFINE_INODE_ERROR_EVENT(xfs_reflink_end_cow_error);
 
-DEFINE_COW_EVENT(xfs_reflink_fork_buf);
-DEFINE_COW_EVENT(xfs_reflink_finish_fork_buf);
-DEFINE_INODE_ERROR_EVENT(xfs_reflink_fork_buf_error);
-DEFINE_INODE_ERROR_EVENT(xfs_reflink_finish_fork_buf_error);
 
-DEFINE_INODE_EVENT(xfs_reflink_cancel_pending_cow);
 DEFINE_INODE_IREC_EVENT(xfs_reflink_cancel_cow);
-DEFINE_INODE_ERROR_EVENT(xfs_reflink_cancel_pending_cow_error);
 
 /* rmap swapext tracepoints */
 DEFINE_INODE_IREC_EVENT(xfs_swap_extent_rmap_remap);