module/zfs/zfs_debug.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
  23  * Copyright (c) 2012, 2014 by Delphix. All rights reserved.
  24  */
  25
  26 #include <sys/zfs_context.h>
  27 #include <sys/kstat.h>
  28
  29 list_t zfs_dbgmsgs;
  30 int zfs_dbgmsg_size = 0;
  31 kmutex_t zfs_dbgmsgs_lock;
  32 int zfs_dbgmsg_maxsize = 4<<20; /* 4MB */
  33 kstat_t *zfs_dbgmsg_kstat;
  34
  35 /*
  36  * Internal ZFS debug messages are enabled by default.
  37  *
  38  * # Print debug messages
  39  * cat /proc/spl/kstat/zfs/dbgmsg
  40  *
  41  * # Disable the kernel debug message log.
  42  * echo 0 > /sys/module/zfs/parameters/zfs_dbgmsg_enable
  43  *
  44  * # Clear the kernel debug message log.
  45  * echo 0 >/proc/spl/kstat/zfs/dbgmsg
  46  */
  47 int zfs_dbgmsg_enable = 1;
  48
  49 static int
  50 zfs_dbgmsg_headers(char *buf, size_t size)
  51 {
  52         (void) snprintf(buf, size, "%-12s %-8s\n", "timestamp", "message");
  53
  54         return (0);
  55 }
  56
  57 static int
  58 zfs_dbgmsg_data(char *buf, size_t size, void *data)
  59 {
  60         zfs_dbgmsg_t *zdm = (zfs_dbgmsg_t *)data;
  61
  62         (void) snprintf(buf, size, "%-12llu %-s\n",
  63             (u_longlong_t)zdm->zdm_timestamp, zdm->zdm_msg);
  64
  65         return (0);
  66 }
  67
  68 static void *
  69 zfs_dbgmsg_addr(kstat_t *ksp, loff_t n)
  70 {
  71         zfs_dbgmsg_t *zdm = (zfs_dbgmsg_t *)ksp->ks_private;
  72
  73         ASSERT(MUTEX_HELD(&zfs_dbgmsgs_lock));
  74
  75         if (n == 0)
  76                 ksp->ks_private = list_head(&zfs_dbgmsgs);
  77         else if (zdm)
  78                 ksp->ks_private = list_next(&zfs_dbgmsgs, zdm);
  79
  80         return (ksp->ks_private);
  81 }
  82
  83 static void
  84 zfs_dbgmsg_purge(int max_size)
  85 {
  86         zfs_dbgmsg_t *zdm;
  87         int size;
  88
  89         ASSERT(MUTEX_HELD(&zfs_dbgmsgs_lock));
  90
  91         while (zfs_dbgmsg_size > max_size) {
  92                 zdm = list_remove_head(&zfs_dbgmsgs);
  93                 if (zdm == NULL)
  94                         return;
  95
  96                 size = zdm->zdm_size;
  97                 kmem_free(zdm, size);
  98                 zfs_dbgmsg_size -= size;
  99         }
 100 }
 101
 102 static int
 103 zfs_dbgmsg_update(kstat_t *ksp, int rw)
 104 {
 105         if (rw == KSTAT_WRITE)
 106                 zfs_dbgmsg_purge(0);
 107
 108         return (0);
 109 }
 110
 111 void
 112 zfs_dbgmsg_init(void)
 113 {
 114         list_create(&zfs_dbgmsgs, sizeof (zfs_dbgmsg_t),
 115             offsetof(zfs_dbgmsg_t, zdm_node));
 116         mutex_init(&zfs_dbgmsgs_lock, NULL, MUTEX_DEFAULT, NULL);
 117
 118         zfs_dbgmsg_kstat = kstat_create("zfs", 0, "dbgmsg", "misc",
 119             KSTAT_TYPE_RAW, 0, KSTAT_FLAG_VIRTUAL);
 120         if (zfs_dbgmsg_kstat) {
 121                 zfs_dbgmsg_kstat->ks_lock = &zfs_dbgmsgs_lock;
 122                 zfs_dbgmsg_kstat->ks_ndata = UINT32_MAX;
 123                 zfs_dbgmsg_kstat->ks_private = NULL;
 124                 zfs_dbgmsg_kstat->ks_update = zfs_dbgmsg_update;
 125                 kstat_set_raw_ops(zfs_dbgmsg_kstat, zfs_dbgmsg_headers,
 126                     zfs_dbgmsg_data, zfs_dbgmsg_addr);
 127                 kstat_install(zfs_dbgmsg_kstat);
 128         }
 129 }
 130
 131 void
 132 zfs_dbgmsg_fini(void)
 133 {
 134         if (zfs_dbgmsg_kstat)
 135                 kstat_delete(zfs_dbgmsg_kstat);
 136         /*
 137          * TODO - decide how to make this permanent
 138          */
 139 #ifdef _KERNEL
 140         mutex_enter(&zfs_dbgmsgs_lock);
 141         zfs_dbgmsg_purge(0);
 142         mutex_exit(&zfs_dbgmsgs_lock);
 143         mutex_destroy(&zfs_dbgmsgs_lock);
 144 #endif
 145 }
 146
 147 void
 148 __zfs_dbgmsg(char *buf)
 149 {
 150         zfs_dbgmsg_t *zdm;
 151         int size;
 152
 153         size = sizeof (zfs_dbgmsg_t) + strlen(buf);
 154         zdm = kmem_zalloc(size, KM_SLEEP);
 155         zdm->zdm_size = size;
 156         zdm->zdm_timestamp = gethrestime_sec();
 157         strcpy(zdm->zdm_msg, buf);
 158
 159         mutex_enter(&zfs_dbgmsgs_lock);
 160         list_insert_tail(&zfs_dbgmsgs, zdm);
 161         zfs_dbgmsg_size += size;
 162         zfs_dbgmsg_purge(MAX(zfs_dbgmsg_maxsize, 0));
 163         mutex_exit(&zfs_dbgmsgs_lock);
 164 }
 165
 166 void
 167 __set_error(const char *file, const char *func, int line, int err)
 168 {
 169         /*
 170          * To enable this:
 171          *
 172          * $ echo 512 >/sys/module/zfs/parameters/zfs_flags
 173          */
 174         if (zfs_flags & ZFS_DEBUG_SET_ERROR)
 175                 __dprintf(file, func, line, "error %lu", err);
 176 }
 177
 178 #ifdef _KERNEL
 179 void
 180 __dprintf(const char *file, const char *func, int line, const char *fmt, ...)
 181 {
 182         const char *newfile;
 183         va_list adx;
 184         size_t size;
 185         char *buf;
 186         char *nl;
 187         int i;
 188
 189         size = 1024;
 190         buf = kmem_alloc(size, KM_SLEEP);
 191
 192         /*
 193          * Get rid of annoying prefix to filename.
 194          */
 195         newfile = strrchr(file, '/');
 196         if (newfile != NULL) {
 197                 newfile = newfile + 1; /* Get rid of leading / */
 198         } else {
 199                 newfile = file;
 200         }
 201
 202         i = snprintf(buf, size, "%s:%d:%s(): ", newfile, line, func);
 203
 204         if (i < size) {
 205                 va_start(adx, fmt);
 206                 (void) vsnprintf(buf + i, size - i, fmt, adx);
 207                 va_end(adx);
 208         }
 209
 210         /*
 211          * Get rid of trailing newline.
 212          */
 213         nl = strrchr(buf, '\n');
 214         if (nl != NULL)
 215                 *nl = '\0';
 216
 217         /*
 218          * To get this data enable the zfs__dprintf trace point as shown:
 219          *
 220          * # Enable zfs__dprintf tracepoint, clear the tracepoint ring buffer
 221          * $ echo 1 > /sys/kernel/debug/tracing/events/zfs/enable
 222          * $ echo 0 > /sys/kernel/debug/tracing/trace
 223          *
 224          * # Dump the ring buffer.
 225          * $ cat /sys/kernel/debug/tracing/trace
 226          */
 227         DTRACE_PROBE1(zfs__dprintf, char *, buf);
 228
 229         /*
 230          * To get this data:
 231          *
 232          * $ cat /proc/spl/kstat/zfs/dbgmsg
 233          *
 234          * To clear the buffer:
 235          * $ echo 0 > /proc/spl/kstat/zfs/dbgmsg
 236          */
 237         __zfs_dbgmsg(buf);
 238
 239         kmem_free(buf, size);
 240 }
 241
 242 #else
 243
 244 void
 245 zfs_dbgmsg_print(const char *tag)
 246 {
 247         zfs_dbgmsg_t *zdm;
 248
 249         (void) printf("ZFS_DBGMSG(%s):\n", tag);
 250         mutex_enter(&zfs_dbgmsgs_lock);
 251         for (zdm = list_head(&zfs_dbgmsgs); zdm;
 252             zdm = list_next(&zfs_dbgmsgs, zdm))
 253                 (void) printf("%s\n", zdm->zdm_msg);
 254         mutex_exit(&zfs_dbgmsgs_lock);
 255 }
 256 #endif /* _KERNEL */
 257
 258 #ifdef _KERNEL
 259 module_param(zfs_dbgmsg_enable, int, 0644);
 260 MODULE_PARM_DESC(zfs_dbgmsg_enable, "Enable ZFS debug message log");
 261
 262 module_param(zfs_dbgmsg_maxsize, int, 0644);
 263 MODULE_PARM_DESC(zfs_dbgmsg_maxsize, "Maximum ZFS debug log size");
 264 #endif