fs/xfs/scrub/stats.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Copyright (C) 2023 Oracle.  All Rights Reserved.
   4  * Author: Darrick J. Wong <djwong@kernel.org>
   5  */
   6 #include "xfs.h"
   7 #include "xfs_fs.h"
   8 #include "xfs_shared.h"
   9 #include "xfs_format.h"
  10 #include "xfs_trans_resv.h"
  11 #include "xfs_mount.h"
  12 #include "xfs_sysfs.h"
  13 #include "xfs_btree.h"
  14 #include "xfs_super.h"
  15 #include "scrub/scrub.h"
  16 #include "scrub/stats.h"
  17 #include "scrub/trace.h"
  18
  19 struct xchk_scrub_stats {
  20         /* all 32-bit counters here */
  21
  22         /* checking stats */
  23         uint32_t                invocations;
  24         uint32_t                clean;
  25         uint32_t                corrupt;
  26         uint32_t                preen;
  27         uint32_t                xfail;
  28         uint32_t                xcorrupt;
  29         uint32_t                incomplete;
  30         uint32_t                warning;
  31         uint32_t                retries;
  32
  33         /* repair stats */
  34         uint32_t                repair_invocations;
  35         uint32_t                repair_success;
  36
  37         /* all 64-bit items here */
  38
  39         /* runtimes */
  40         uint64_t                checktime_us;
  41         uint64_t                repairtime_us;
  42
  43         /* non-counter state must go at the end for clearall */
  44         spinlock_t              css_lock;
  45 };
  46
  47 struct xchk_stats {
  48         struct dentry           *cs_debugfs;
  49         struct xchk_scrub_stats cs_stats[XFS_SCRUB_TYPE_NR];
  50 };
  51
  52
  53 static struct xchk_stats        global_stats;
  54
  55 static const char *name_map[XFS_SCRUB_TYPE_NR] = {
  56         [XFS_SCRUB_TYPE_SB]             = "sb",
  57         [XFS_SCRUB_TYPE_AGF]            = "agf",
  58         [XFS_SCRUB_TYPE_AGFL]           = "agfl",
  59         [XFS_SCRUB_TYPE_AGI]            = "agi",
  60         [XFS_SCRUB_TYPE_BNOBT]          = "bnobt",
  61         [XFS_SCRUB_TYPE_CNTBT]          = "cntbt",
  62         [XFS_SCRUB_TYPE_INOBT]          = "inobt",
  63         [XFS_SCRUB_TYPE_FINOBT]         = "finobt",
  64         [XFS_SCRUB_TYPE_RMAPBT]         = "rmapbt",
  65         [XFS_SCRUB_TYPE_REFCNTBT]       = "refcountbt",
  66         [XFS_SCRUB_TYPE_INODE]          = "inode",
  67         [XFS_SCRUB_TYPE_BMBTD]          = "bmapbtd",
  68         [XFS_SCRUB_TYPE_BMBTA]          = "bmapbta",
  69         [XFS_SCRUB_TYPE_BMBTC]          = "bmapbtc",
  70         [XFS_SCRUB_TYPE_DIR]            = "directory",
  71         [XFS_SCRUB_TYPE_XATTR]          = "xattr",
  72         [XFS_SCRUB_TYPE_SYMLINK]        = "symlink",
  73         [XFS_SCRUB_TYPE_PARENT]         = "parent",
  74         [XFS_SCRUB_TYPE_RTBITMAP]       = "rtbitmap",
  75         [XFS_SCRUB_TYPE_RTSUM]          = "rtsummary",
  76         [XFS_SCRUB_TYPE_UQUOTA]         = "usrquota",
  77         [XFS_SCRUB_TYPE_GQUOTA]         = "grpquota",
  78         [XFS_SCRUB_TYPE_PQUOTA]         = "prjquota",
  79         [XFS_SCRUB_TYPE_FSCOUNTERS]     = "fscounters",
  80 };
  81
  82 /* Format the scrub stats into a text buffer, similar to pcp style. */
  83 STATIC ssize_t
  84 xchk_stats_format(
  85         struct xchk_stats       *cs,
  86         char                    *buf,
  87         size_t                  remaining)
  88 {
  89         struct xchk_scrub_stats *css = &cs->cs_stats[0];
  90         unsigned int            i;
  91         ssize_t                 copied = 0;
  92         int                     ret = 0;
  93
  94         for (i = 0; i < XFS_SCRUB_TYPE_NR; i++, css++) {
  95                 if (!name_map[i])
  96                         continue;
  97
  98                 ret = scnprintf(buf, remaining,
  99  "%s %u %u %u %u %u %u %u %u %u %llu %u %u %llu\n",
 100                                 name_map[i],
 101                                 (unsigned int)css->invocations,
 102                                 (unsigned int)css->clean,
 103                                 (unsigned int)css->corrupt,
 104                                 (unsigned int)css->preen,
 105                                 (unsigned int)css->xfail,
 106                                 (unsigned int)css->xcorrupt,
 107                                 (unsigned int)css->incomplete,
 108                                 (unsigned int)css->warning,
 109                                 (unsigned int)css->retries,
 110                                 (unsigned long long)css->checktime_us,
 111                                 (unsigned int)css->repair_invocations,
 112                                 (unsigned int)css->repair_success,
 113                                 (unsigned long long)css->repairtime_us);
 114                 if (ret <= 0)
 115                         break;
 116
 117                 remaining -= ret;
 118                 copied += ret;
 119                 buf +=  ret;
 120         }
 121
 122         return copied > 0 ? copied : ret;
 123 }
 124
 125 /* Estimate the worst case buffer size required to hold the whole report. */
 126 STATIC size_t
 127 xchk_stats_estimate_bufsize(
 128         struct xchk_stats       *cs)
 129 {
 130         struct xchk_scrub_stats *css = &cs->cs_stats[0];
 131         unsigned int            i;
 132         size_t                  field_width;
 133         size_t                  ret = 0;
 134
 135         /* 4294967296 plus one space for each u32 field */
 136         field_width = 11 * (offsetof(struct xchk_scrub_stats, checktime_us) /
 137                             sizeof(uint32_t));
 138
 139         /* 18446744073709551615 plus one space for each u64 field */
 140         field_width += 21 * ((offsetof(struct xchk_scrub_stats, css_lock) -
 141                               offsetof(struct xchk_scrub_stats, checktime_us)) /
 142                              sizeof(uint64_t));
 143
 144         for (i = 0; i < XFS_SCRUB_TYPE_NR; i++, css++) {
 145                 if (!name_map[i])
 146                         continue;
 147
 148                 /* name plus one space */
 149                 ret += 1 + strlen(name_map[i]);
 150
 151                 /* all fields, plus newline */
 152                 ret += field_width + 1;
 153         }
 154
 155         return ret;
 156 }
 157
 158 /* Clear all counters. */
 159 STATIC void
 160 xchk_stats_clearall(
 161         struct xchk_stats       *cs)
 162 {
 163         struct xchk_scrub_stats *css = &cs->cs_stats[0];
 164         unsigned int            i;
 165
 166         for (i = 0; i < XFS_SCRUB_TYPE_NR; i++, css++) {
 167                 spin_lock(&css->css_lock);
 168                 memset(css, 0, offsetof(struct xchk_scrub_stats, css_lock));
 169                 spin_unlock(&css->css_lock);
 170         }
 171 }
 172
 173 #define XFS_SCRUB_OFLAG_UNCLEAN (XFS_SCRUB_OFLAG_CORRUPT | \
 174                                  XFS_SCRUB_OFLAG_PREEN | \
 175                                  XFS_SCRUB_OFLAG_XFAIL | \
 176                                  XFS_SCRUB_OFLAG_XCORRUPT | \
 177                                  XFS_SCRUB_OFLAG_INCOMPLETE | \
 178                                  XFS_SCRUB_OFLAG_WARNING)
 179
 180 STATIC void
 181 xchk_stats_merge_one(
 182         struct xchk_stats               *cs,
 183         const struct xfs_scrub_metadata *sm,
 184         const struct xchk_stats_run     *run)
 185 {
 186         struct xchk_scrub_stats         *css;
 187
 188         ASSERT(sm->sm_type < XFS_SCRUB_TYPE_NR);
 189
 190         css = &cs->cs_stats[sm->sm_type];
 191         spin_lock(&css->css_lock);
 192         css->invocations++;
 193         if (!(sm->sm_flags & XFS_SCRUB_OFLAG_UNCLEAN))
 194                 css->clean++;
 195         if (sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
 196                 css->corrupt++;
 197         if (sm->sm_flags & XFS_SCRUB_OFLAG_PREEN)
 198                 css->preen++;
 199         if (sm->sm_flags & XFS_SCRUB_OFLAG_XFAIL)
 200                 css->xfail++;
 201         if (sm->sm_flags & XFS_SCRUB_OFLAG_XCORRUPT)
 202                 css->xcorrupt++;
 203         if (sm->sm_flags & XFS_SCRUB_OFLAG_INCOMPLETE)
 204                 css->incomplete++;
 205         if (sm->sm_flags & XFS_SCRUB_OFLAG_WARNING)
 206                 css->warning++;
 207         css->retries += run->retries;
 208         css->checktime_us += howmany_64(run->scrub_ns, NSEC_PER_USEC);
 209
 210         if (run->repair_attempted)
 211                 css->repair_invocations++;
 212         if (run->repair_succeeded)
 213                 css->repair_success++;
 214         css->repairtime_us += howmany_64(run->repair_ns, NSEC_PER_USEC);
 215         spin_unlock(&css->css_lock);
 216 }
 217
 218 /* Merge these scrub-run stats into the global and mount stat data. */
 219 void
 220 xchk_stats_merge(
 221         struct xfs_mount                *mp,
 222         const struct xfs_scrub_metadata *sm,
 223         const struct xchk_stats_run     *run)
 224 {
 225         xchk_stats_merge_one(&global_stats, sm, run);
 226         xchk_stats_merge_one(mp->m_scrub_stats, sm, run);
 227 }
 228
 229 /* debugfs boilerplate */
 230
 231 static ssize_t
 232 xchk_scrub_stats_read(
 233         struct file             *file,
 234         char __user             *ubuf,
 235         size_t                  count,
 236         loff_t                  *ppos)
 237 {
 238         struct xchk_stats       *cs = file->private_data;
 239         char                    *buf;
 240         size_t                  bufsize;
 241         ssize_t                 avail, ret;
 242
 243         /*
 244          * This generates stringly snapshot of all the scrub counters, so we
 245          * do not want userspace to receive garbled text from multiple calls.
 246          * If the file position is greater than 0, return a short read.
 247          */
 248         if (*ppos > 0)
 249                 return 0;
 250
 251         bufsize = xchk_stats_estimate_bufsize(cs);
 252
 253         buf = kvmalloc(bufsize, XCHK_GFP_FLAGS);
 254         if (!buf)
 255                 return -ENOMEM;
 256
 257         avail = xchk_stats_format(cs, buf, bufsize);
 258         if (avail < 0) {
 259                 ret = avail;
 260                 goto out;
 261         }
 262
 263         ret = simple_read_from_buffer(ubuf, count, ppos, buf, avail);
 264 out:
 265         kvfree(buf);
 266         return ret;
 267 }
 268
 269 static const struct file_operations scrub_stats_fops = {
 270         .open                   = simple_open,
 271         .read                   = xchk_scrub_stats_read,
 272 };
 273
 274 static ssize_t
 275 xchk_clear_scrub_stats_write(
 276         struct file             *file,
 277         const char __user       *ubuf,
 278         size_t                  count,
 279         loff_t                  *ppos)
 280 {
 281         struct xchk_stats       *cs = file->private_data;
 282         unsigned int            val;
 283         int                     ret;
 284
 285         ret = kstrtouint_from_user(ubuf, count, 0, &val);
 286         if (ret)
 287                 return ret;
 288
 289         if (val != 1)
 290                 return -EINVAL;
 291
 292         xchk_stats_clearall(cs);
 293         return count;
 294 }
 295
 296 static const struct file_operations clear_scrub_stats_fops = {
 297         .open                   = simple_open,
 298         .write                  = xchk_clear_scrub_stats_write,
 299 };
 300
 301 /* Initialize the stats object. */
 302 STATIC int
 303 xchk_stats_init(
 304         struct xchk_stats       *cs,
 305         struct xfs_mount        *mp)
 306 {
 307         struct xchk_scrub_stats *css = &cs->cs_stats[0];
 308         unsigned int            i;
 309
 310         for (i = 0; i < XFS_SCRUB_TYPE_NR; i++, css++)
 311                 spin_lock_init(&css->css_lock);
 312
 313         return 0;
 314 }
 315
 316 /* Connect the stats object to debugfs. */
 317 void
 318 xchk_stats_register(
 319         struct xchk_stats       *cs,
 320         struct dentry           *parent)
 321 {
 322         if (!parent)
 323                 return;
 324
 325         cs->cs_debugfs = xfs_debugfs_mkdir("scrub", parent);
 326         if (!cs->cs_debugfs)
 327                 return;
 328
 329         debugfs_create_file("stats", 0644, cs->cs_debugfs, cs,
 330                         &scrub_stats_fops);
 331         debugfs_create_file("clear_stats", 0400, cs->cs_debugfs, cs,
 332                         &clear_scrub_stats_fops);
 333 }
 334
 335 /* Free all resources related to the stats object. */
 336 STATIC int
 337 xchk_stats_teardown(
 338         struct xchk_stats       *cs)
 339 {
 340         return 0;
 341 }
 342
 343 /* Disconnect the stats object from debugfs. */
 344 void
 345 xchk_stats_unregister(
 346         struct xchk_stats       *cs)
 347 {
 348         debugfs_remove(cs->cs_debugfs);
 349 }
 350
 351 /* Initialize global stats and register them */
 352 int __init
 353 xchk_global_stats_setup(
 354         struct dentry           *parent)
 355 {
 356         int                     error;
 357
 358         error = xchk_stats_init(&global_stats, NULL);
 359         if (error)
 360                 return error;
 361
 362         xchk_stats_register(&global_stats, parent);
 363         return 0;
 364 }
 365
 366 /* Unregister global stats and tear them down */
 367 void
 368 xchk_global_stats_teardown(void)
 369 {
 370         xchk_stats_unregister(&global_stats);
 371         xchk_stats_teardown(&global_stats);
 372 }
 373
 374 /* Allocate per-mount stats */
 375 int
 376 xchk_mount_stats_alloc(
 377         struct xfs_mount        *mp)
 378 {
 379         struct xchk_stats       *cs;
 380         int                     error;
 381
 382         cs = kvzalloc(sizeof(struct xchk_stats), GFP_KERNEL);
 383         if (!cs)
 384                 return -ENOMEM;
 385
 386         error = xchk_stats_init(cs, mp);
 387         if (error)
 388                 goto out_free;
 389
 390         mp->m_scrub_stats = cs;
 391         return 0;
 392 out_free:
 393         kvfree(cs);
 394         return error;
 395 }
 396
 397 /* Free per-mount stats */
 398 void
 399 xchk_mount_stats_free(
 400         struct xfs_mount        *mp)
 401 {
 402         xchk_stats_teardown(mp->m_scrub_stats);
 403         kvfree(mp->m_scrub_stats);
 404         mp->m_scrub_stats = NULL;
 405 }