nfs/blocklayout: SCSI layout trace points for reservation key reg/unreg

An administrator cannot take action on these messages, but the
reported errors might be helpful for troubleshooting. Transition
them to trace points so these events appear in the trace log and
can be easily lined up with other traced NFS client operations.

Examples:

   append_writer-6147  [000]    80.247393: bl_pr_key_reg:        dev=8,0 (sda) key=0x6675bfcf59112e98
   append_writer-6147  [000]    80.247842: bl_pr_key_unreg:      dev=8,0 (sda) key=0x6675bfcf59112e98

     umount.nfs4-6172  [002]    84.950409: bl_pr_key_unreg_err:  dev=8,0 (sda) key=0x6675bfcf59112e98 status=RESERVATION_CONFLICT

Reviewed-by: Benjamin Coddington <bcodding@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Chuck Lever <chuck.lever@oracle.com>
Signed-off-by: Anna Schumaker <Anna.Schumaker@Netapp.com>

diff --git a/fs/nfs/blocklayout/dev.c b/fs/nfs/blocklayout/dev.c
index e2b9e8d1ac4d619ae53c326a9977ec9a19f0b834..221781fb9cf14b93a72ea8ab27329bf1c4ea70d2 100644 (file)
--- a/fs/nfs/blocklayout/dev.c
+++ b/fs/nfs/blocklayout/dev.c
@@ -10,6 +10,7 @@
 #include <linux/pr.h>
 
 #include "blocklayout.h"
+#include "../nfs4trace.h"
 
 #define NFSDBG_FACILITY                NFSDBG_PNFS_LD
 
@@ -17,12 +18,16 @@ static void bl_unregister_scsi(struct pnfs_block_dev *dev)
 {
        struct block_device *bdev = file_bdev(dev->bdev_file);
        const struct pr_ops *ops = bdev->bd_disk->fops->pr_ops;
+       int status;
 
        if (!test_and_clear_bit(PNFS_BDEV_REGISTERED, &dev->flags))
                return;
 
-       if (ops->pr_register(bdev, dev->pr_key, 0, false))
-               pr_err("failed to unregister PR key.\n");
+       status = ops->pr_register(bdev, dev->pr_key, 0, false);
+       if (status)
+               trace_bl_pr_key_unreg_err(bdev, dev->pr_key, status);
+       else
+               trace_bl_pr_key_unreg(bdev, dev->pr_key);
 }
 
 static bool bl_register_scsi(struct pnfs_block_dev *dev)
@@ -36,10 +41,10 @@ static bool bl_register_scsi(struct pnfs_block_dev *dev)
 
        status = ops->pr_register(bdev, 0, dev->pr_key, true);
        if (status) {
-               pr_err("pNFS: failed to register key for block device %s.",
-                      bdev->bd_disk->disk_name);
+               trace_bl_pr_key_reg_err(bdev, dev->pr_key, status);
                return false;
        }
+       trace_bl_pr_key_reg(bdev, dev->pr_key);
        return true;
 }
 
@@ -382,8 +387,9 @@ bl_parse_scsi(struct nfs_server *server, struct pnfs_block_dev *d,
                struct pnfs_block_volume *volumes, int idx, gfp_t gfp_mask)
 {
        struct pnfs_block_volume *v = &volumes[idx];
-       struct file *bdev_file;
+       struct block_device *bdev;
        const struct pr_ops *ops;
+       struct file *bdev_file;
        int error;
 
        if (!bl_validate_designator(v))
@@ -404,21 +410,19 @@ bl_parse_scsi(struct nfs_server *server, struct pnfs_block_dev *d,
                return PTR_ERR(bdev_file);
        }
        d->bdev_file = bdev_file;
+       bdev = file_bdev(bdev_file);
 
-       d->len = bdev_nr_bytes(file_bdev(d->bdev_file));
+       d->len = bdev_nr_bytes(bdev);
        d->map = bl_map_simple;
        d->pr_key = v->scsi.pr_key;
 
        if (d->len == 0)
                return -ENODEV;
 
-       pr_info("pNFS: using block device %s (reservation key 0x%llx)\n",
-               file_bdev(d->bdev_file)->bd_disk->disk_name, d->pr_key);
-
-       ops = file_bdev(d->bdev_file)->bd_disk->fops->pr_ops;
+       ops = bdev->bd_disk->fops->pr_ops;
        if (!ops) {
                pr_err("pNFS: block device %s does not support reservations.",
-                               file_bdev(d->bdev_file)->bd_disk->disk_name);
+                               bdev->bd_disk->disk_name);
                error = -EINVAL;
                goto out_blkdev_put;
        }

diff --git a/fs/nfs/nfs4trace.c b/fs/nfs/nfs4trace.c
index d22c6670f770f18949ed908e8e64572c174aeb41..389941ccc9c9c44545ba58130177d260ef5b291a 100644 (file)
--- a/fs/nfs/nfs4trace.c
+++ b/fs/nfs/nfs4trace.c
@@ -2,6 +2,8 @@
 /*
  * Copyright (c) 2013 Trond Myklebust <Trond.Myklebust@netapp.com>
  */
+#include <uapi/linux/pr.h>
+#include <linux/blkdev.h>
 #include <linux/nfs_fs.h>
 #include "nfs4_fs.h"
 #include "internal.h"
@@ -29,5 +31,10 @@ EXPORT_TRACEPOINT_SYMBOL_GPL(ff_layout_read_error);
 EXPORT_TRACEPOINT_SYMBOL_GPL(ff_layout_write_error);
 EXPORT_TRACEPOINT_SYMBOL_GPL(ff_layout_commit_error);
 
+EXPORT_TRACEPOINT_SYMBOL_GPL(bl_pr_key_reg);
+EXPORT_TRACEPOINT_SYMBOL_GPL(bl_pr_key_reg_err);
+EXPORT_TRACEPOINT_SYMBOL_GPL(bl_pr_key_unreg);
+EXPORT_TRACEPOINT_SYMBOL_GPL(bl_pr_key_unreg_err);
+
 EXPORT_TRACEPOINT_SYMBOL_GPL(fl_getdevinfo);
 #endif

diff --git a/fs/nfs/nfs4trace.h b/fs/nfs/nfs4trace.h
index 4de8780a7c486f038fc9736e6b04702bf8f74aad..22c973316f0bdd83bddf324e9a78bdfab76c5847 100644 (file)
--- a/fs/nfs/nfs4trace.h
+++ b/fs/nfs/nfs4trace.h
@@ -2153,6 +2153,94 @@ TRACE_EVENT(ff_layout_commit_error,
                )
 );
 
+DECLARE_EVENT_CLASS(pnfs_bl_pr_key_class,
+       TP_PROTO(
+               const struct block_device *bdev,
+               u64 key
+       ),
+       TP_ARGS(bdev, key),
+       TP_STRUCT__entry(
+               __field(u64, key)
+               __field(dev_t, dev)
+               __string(device, bdev->bd_disk->disk_name)
+       ),
+       TP_fast_assign(
+               __entry->key = key;
+               __entry->dev = bdev->bd_dev;
+               __assign_str(device);
+       ),
+       TP_printk("dev=%d,%d (%s) key=0x%016llx",
+               MAJOR(__entry->dev), MINOR(__entry->dev),
+               __get_str(device), __entry->key
+       )
+);
+
+#define DEFINE_NFS4_BLOCK_PRKEY_EVENT(name) \
+       DEFINE_EVENT(pnfs_bl_pr_key_class, name, \
+               TP_PROTO( \
+                       const struct block_device *bdev, \
+                       u64 key \
+               ), \
+               TP_ARGS(bdev, key))
+DEFINE_NFS4_BLOCK_PRKEY_EVENT(bl_pr_key_reg);
+DEFINE_NFS4_BLOCK_PRKEY_EVENT(bl_pr_key_unreg);
+
+/*
+ * From uapi/linux/pr.h
+ */
+TRACE_DEFINE_ENUM(PR_STS_SUCCESS);
+TRACE_DEFINE_ENUM(PR_STS_IOERR);
+TRACE_DEFINE_ENUM(PR_STS_RESERVATION_CONFLICT);
+TRACE_DEFINE_ENUM(PR_STS_RETRY_PATH_FAILURE);
+TRACE_DEFINE_ENUM(PR_STS_PATH_FAST_FAILED);
+TRACE_DEFINE_ENUM(PR_STS_PATH_FAILED);
+
+#define show_pr_status(x) \
+       __print_symbolic(x, \
+               { PR_STS_SUCCESS,               "SUCCESS" }, \
+               { PR_STS_IOERR,                 "IOERR" }, \
+               { PR_STS_RESERVATION_CONFLICT,  "RESERVATION_CONFLICT" }, \
+               { PR_STS_RETRY_PATH_FAILURE,    "RETRY_PATH_FAILURE" }, \
+               { PR_STS_PATH_FAST_FAILED,      "PATH_FAST_FAILED" }, \
+               { PR_STS_PATH_FAILED,           "PATH_FAILED" })
+
+DECLARE_EVENT_CLASS(pnfs_bl_pr_key_err_class,
+       TP_PROTO(
+               const struct block_device *bdev,
+               u64 key,
+               int status
+       ),
+       TP_ARGS(bdev, key, status),
+       TP_STRUCT__entry(
+               __field(u64, key)
+               __field(dev_t, dev)
+               __field(unsigned long, status)
+               __string(device, bdev->bd_disk->disk_name)
+       ),
+       TP_fast_assign(
+               __entry->key = key;
+               __entry->dev = bdev->bd_dev;
+               __entry->status = status;
+               __assign_str(device);
+       ),
+       TP_printk("dev=%d,%d (%s) key=0x%016llx status=%s",
+               MAJOR(__entry->dev), MINOR(__entry->dev),
+               __get_str(device), __entry->key,
+               show_pr_status(__entry->status)
+       )
+);
+
+#define DEFINE_NFS4_BLOCK_PRKEY_ERR_EVENT(name) \
+       DEFINE_EVENT(pnfs_bl_pr_key_err_class, name, \
+               TP_PROTO( \
+                       const struct block_device *bdev, \
+                       u64 key, \
+                       int status \
+               ), \
+               TP_ARGS(bdev, key, status))
+DEFINE_NFS4_BLOCK_PRKEY_ERR_EVENT(bl_pr_key_reg_err);
+DEFINE_NFS4_BLOCK_PRKEY_ERR_EVENT(bl_pr_key_unreg_err);
+
 #ifdef CONFIG_NFS_V4_2
 TRACE_DEFINE_ENUM(NFS4_CONTENT_DATA);
 TRACE_DEFINE_ENUM(NFS4_CONTENT_HOLE);