drivers/md/bcache/sysfs.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * bcache sysfs interfaces
   4  *
   5  * Copyright 2010, 2011 Kent Overstreet <kent.overstreet@gmail.com>
   6  * Copyright 2012 Google, Inc.
   7  */
   8
   9 #include "bcache.h"
  10 #include "sysfs.h"
  11 #include "btree.h"
  12 #include "request.h"
  13 #include "writeback.h"
  14
  15 #include <linux/blkdev.h>
  16 #include <linux/sort.h>
  17 #include <linux/sched/clock.h>
  18
  19 static const char * const cache_replacement_policies[] = {
  20         "lru",
  21         "fifo",
  22         "random",
  23         NULL
  24 };
  25
  26 static const char * const error_actions[] = {
  27         "unregister",
  28         "panic",
  29         NULL
  30 };
  31
  32 write_attribute(attach);
  33 write_attribute(detach);
  34 write_attribute(unregister);
  35 write_attribute(stop);
  36 write_attribute(clear_stats);
  37 write_attribute(trigger_gc);
  38 write_attribute(prune_cache);
  39 write_attribute(flash_vol_create);
  40
  41 read_attribute(bucket_size);
  42 read_attribute(block_size);
  43 read_attribute(nbuckets);
  44 read_attribute(tree_depth);
  45 read_attribute(root_usage_percent);
  46 read_attribute(priority_stats);
  47 read_attribute(btree_cache_size);
  48 read_attribute(btree_cache_max_chain);
  49 read_attribute(cache_available_percent);
  50 read_attribute(written);
  51 read_attribute(btree_written);
  52 read_attribute(metadata_written);
  53 read_attribute(active_journal_entries);
  54
  55 sysfs_time_stats_attribute(btree_gc,    sec, ms);
  56 sysfs_time_stats_attribute(btree_split, sec, us);
  57 sysfs_time_stats_attribute(btree_sort,  ms,  us);
  58 sysfs_time_stats_attribute(btree_read,  ms,  us);
  59
  60 read_attribute(btree_nodes);
  61 read_attribute(btree_used_percent);
  62 read_attribute(average_key_size);
  63 read_attribute(dirty_data);
  64 read_attribute(bset_tree_stats);
  65
  66 read_attribute(state);
  67 read_attribute(cache_read_races);
  68 read_attribute(reclaim);
  69 read_attribute(flush_write);
  70 read_attribute(retry_flush_write);
  71 read_attribute(writeback_keys_done);
  72 read_attribute(writeback_keys_failed);
  73 read_attribute(io_errors);
  74 read_attribute(congested);
  75 rw_attribute(congested_read_threshold_us);
  76 rw_attribute(congested_write_threshold_us);
  77
  78 rw_attribute(sequential_cutoff);
  79 rw_attribute(data_csum);
  80 rw_attribute(cache_mode);
  81 rw_attribute(stop_when_cache_set_failed);
  82 rw_attribute(writeback_metadata);
  83 rw_attribute(writeback_running);
  84 rw_attribute(writeback_percent);
  85 rw_attribute(writeback_delay);
  86 rw_attribute(writeback_rate);
  87
  88 rw_attribute(writeback_rate_update_seconds);
  89 rw_attribute(writeback_rate_i_term_inverse);
  90 rw_attribute(writeback_rate_p_term_inverse);
  91 rw_attribute(writeback_rate_minimum);
  92 read_attribute(writeback_rate_debug);
  93
  94 read_attribute(stripe_size);
  95 read_attribute(partial_stripes_expensive);
  96
  97 rw_attribute(synchronous);
  98 rw_attribute(journal_delay_ms);
  99 rw_attribute(io_disable);
 100 rw_attribute(discard);
 101 rw_attribute(running);
 102 rw_attribute(label);
 103 rw_attribute(readahead);
 104 rw_attribute(errors);
 105 rw_attribute(io_error_limit);
 106 rw_attribute(io_error_halflife);
 107 rw_attribute(verify);
 108 rw_attribute(bypass_torture_test);
 109 rw_attribute(key_merging_disabled);
 110 rw_attribute(gc_always_rewrite);
 111 rw_attribute(expensive_debug_checks);
 112 rw_attribute(cache_replacement_policy);
 113 rw_attribute(btree_shrinker_disabled);
 114 rw_attribute(copy_gc_enabled);
 115 rw_attribute(size);
 116
 117 SHOW(__bch_cached_dev)
 118 {
 119         struct cached_dev *dc = container_of(kobj, struct cached_dev,
 120                                              disk.kobj);
 121         const char *states[] = { "no cache", "clean", "dirty", "inconsistent" };
 122
 123 #define var(stat)               (dc->stat)
 124
 125         if (attr == &sysfs_cache_mode)
 126                 return bch_snprint_string_list(buf, PAGE_SIZE,
 127                                                bch_cache_modes + 1,
 128                                                BDEV_CACHE_MODE(&dc->sb));
 129
 130         if (attr == &sysfs_stop_when_cache_set_failed)
 131                 return bch_snprint_string_list(buf, PAGE_SIZE,
 132                                                bch_stop_on_failure_modes + 1,
 133                                                dc->stop_when_cache_set_failed);
 134
 135
 136         sysfs_printf(data_csum,         "%i", dc->disk.data_csum);
 137         var_printf(verify,              "%i");
 138         var_printf(bypass_torture_test, "%i");
 139         var_printf(writeback_metadata,  "%i");
 140         var_printf(writeback_running,   "%i");
 141         var_print(writeback_delay);
 142         var_print(writeback_percent);
 143         sysfs_hprint(writeback_rate,    dc->writeback_rate.rate << 9);
 144         sysfs_hprint(io_errors,         atomic_read(&dc->io_errors));
 145         sysfs_printf(io_error_limit,    "%i", dc->error_limit);
 146         sysfs_printf(io_disable,        "%i", dc->io_disable);
 147         var_print(writeback_rate_update_seconds);
 148         var_print(writeback_rate_i_term_inverse);
 149         var_print(writeback_rate_p_term_inverse);
 150         var_print(writeback_rate_minimum);
 151
 152         if (attr == &sysfs_writeback_rate_debug) {
 153                 char rate[20];
 154                 char dirty[20];
 155                 char target[20];
 156                 char proportional[20];
 157                 char integral[20];
 158                 char change[20];
 159                 s64 next_io;
 160
 161                 bch_hprint(rate,        dc->writeback_rate.rate << 9);
 162                 bch_hprint(dirty,       bcache_dev_sectors_dirty(&dc->disk) << 9);
 163                 bch_hprint(target,      dc->writeback_rate_target << 9);
 164                 bch_hprint(proportional,dc->writeback_rate_proportional << 9);
 165                 bch_hprint(integral,    dc->writeback_rate_integral_scaled << 9);
 166                 bch_hprint(change,      dc->writeback_rate_change << 9);
 167
 168                 next_io = div64_s64(dc->writeback_rate.next - local_clock(),
 169                                     NSEC_PER_MSEC);
 170
 171                 return sprintf(buf,
 172                                "rate:\t\t%s/sec\n"
 173                                "dirty:\t\t%s\n"
 174                                "target:\t\t%s\n"
 175                                "proportional:\t%s\n"
 176                                "integral:\t%s\n"
 177                                "change:\t\t%s/sec\n"
 178                                "next io:\t%llims\n",
 179                                rate, dirty, target, proportional,
 180                                integral, change, next_io);
 181         }
 182
 183         sysfs_hprint(dirty_data,
 184                      bcache_dev_sectors_dirty(&dc->disk) << 9);
 185
 186         sysfs_hprint(stripe_size,        ((uint64_t)dc->disk.stripe_size) << 9);
 187         var_printf(partial_stripes_expensive,   "%u");
 188
 189         var_hprint(sequential_cutoff);
 190         var_hprint(readahead);
 191
 192         sysfs_print(running,            atomic_read(&dc->running));
 193         sysfs_print(state,              states[BDEV_STATE(&dc->sb)]);
 194
 195         if (attr == &sysfs_label) {
 196                 memcpy(buf, dc->sb.label, SB_LABEL_SIZE);
 197                 buf[SB_LABEL_SIZE + 1] = '\0';
 198                 strcat(buf, "\n");
 199                 return strlen(buf);
 200         }
 201
 202 #undef var
 203         return 0;
 204 }
 205 SHOW_LOCKED(bch_cached_dev)
 206
 207 STORE(__cached_dev)
 208 {
 209         struct cached_dev *dc = container_of(kobj, struct cached_dev,
 210                                              disk.kobj);
 211         ssize_t v;
 212         struct cache_set *c;
 213         struct kobj_uevent_env *env;
 214
 215 #define d_strtoul(var)          sysfs_strtoul(var, dc->var)
 216 #define d_strtoul_nonzero(var)  sysfs_strtoul_clamp(var, dc->var, 1, INT_MAX)
 217 #define d_strtoi_h(var)         sysfs_hatoi(var, dc->var)
 218
 219         sysfs_strtoul(data_csum,        dc->disk.data_csum);
 220         d_strtoul(verify);
 221         d_strtoul(bypass_torture_test);
 222         d_strtoul(writeback_metadata);
 223         d_strtoul(writeback_running);
 224         d_strtoul(writeback_delay);
 225
 226         sysfs_strtoul_clamp(writeback_percent, dc->writeback_percent, 0, 40);
 227
 228         sysfs_strtoul_clamp(writeback_rate,
 229                             dc->writeback_rate.rate, 1, INT_MAX);
 230
 231         sysfs_strtoul_clamp(writeback_rate_update_seconds,
 232                             dc->writeback_rate_update_seconds,
 233                             1, WRITEBACK_RATE_UPDATE_SECS_MAX);
 234         d_strtoul(writeback_rate_i_term_inverse);
 235         d_strtoul_nonzero(writeback_rate_p_term_inverse);
 236
 237         sysfs_strtoul_clamp(io_error_limit, dc->error_limit, 0, INT_MAX);
 238
 239         if (attr == &sysfs_io_disable) {
 240                 int v = strtoul_or_return(buf);
 241
 242                 dc->io_disable = v ? 1 : 0;
 243         }
 244
 245         d_strtoi_h(sequential_cutoff);
 246         d_strtoi_h(readahead);
 247
 248         if (attr == &sysfs_clear_stats)
 249                 bch_cache_accounting_clear(&dc->accounting);
 250
 251         if (attr == &sysfs_running &&
 252             strtoul_or_return(buf))
 253                 bch_cached_dev_run(dc);
 254
 255         if (attr == &sysfs_cache_mode) {
 256                 v = bch_read_string_list(buf, bch_cache_modes + 1);
 257
 258                 if (v < 0)
 259                         return v;
 260
 261                 if ((unsigned) v != BDEV_CACHE_MODE(&dc->sb)) {
 262                         SET_BDEV_CACHE_MODE(&dc->sb, v);
 263                         bch_write_bdev_super(dc, NULL);
 264                 }
 265         }
 266
 267         if (attr == &sysfs_stop_when_cache_set_failed) {
 268                 v = bch_read_string_list(buf, bch_stop_on_failure_modes + 1);
 269
 270                 if (v < 0)
 271                         return v;
 272
 273                 dc->stop_when_cache_set_failed = v;
 274         }
 275
 276         if (attr == &sysfs_label) {
 277                 if (size > SB_LABEL_SIZE)
 278                         return -EINVAL;
 279                 memcpy(dc->sb.label, buf, size);
 280                 if (size < SB_LABEL_SIZE)
 281                         dc->sb.label[size] = '\0';
 282                 if (size && dc->sb.label[size - 1] == '\n')
 283                         dc->sb.label[size - 1] = '\0';
 284                 bch_write_bdev_super(dc, NULL);
 285                 if (dc->disk.c) {
 286                         memcpy(dc->disk.c->uuids[dc->disk.id].label,
 287                                buf, SB_LABEL_SIZE);
 288                         bch_uuid_write(dc->disk.c);
 289                 }
 290                 env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL);
 291                 if (!env)
 292                         return -ENOMEM;
 293                 add_uevent_var(env, "DRIVER=bcache");
 294                 add_uevent_var(env, "CACHED_UUID=%pU", dc->sb.uuid),
 295                 add_uevent_var(env, "CACHED_LABEL=%s", buf);
 296                 kobject_uevent_env(
 297                         &disk_to_dev(dc->disk.disk)->kobj, KOBJ_CHANGE, env->envp);
 298                 kfree(env);
 299         }
 300
 301         if (attr == &sysfs_attach) {
 302                 uint8_t         set_uuid[16];
 303
 304                 if (bch_parse_uuid(buf, set_uuid) < 16)
 305                         return -EINVAL;
 306
 307                 v = -ENOENT;
 308                 list_for_each_entry(c, &bch_cache_sets, list) {
 309                         v = bch_cached_dev_attach(dc, c, set_uuid);
 310                         if (!v)
 311                                 return size;
 312                 }
 313
 314                 pr_err("Can't attach %s: cache set not found", buf);
 315                 return v;
 316         }
 317
 318         if (attr == &sysfs_detach && dc->disk.c)
 319                 bch_cached_dev_detach(dc);
 320
 321         if (attr == &sysfs_stop)
 322                 bcache_device_stop(&dc->disk);
 323
 324         return size;
 325 }
 326
 327 STORE(bch_cached_dev)
 328 {
 329         struct cached_dev *dc = container_of(kobj, struct cached_dev,
 330                                              disk.kobj);
 331
 332         mutex_lock(&bch_register_lock);
 333         size = __cached_dev_store(kobj, attr, buf, size);
 334
 335         if (attr == &sysfs_writeback_running)
 336                 bch_writeback_queue(dc);
 337
 338         if (attr == &sysfs_writeback_percent)
 339                 if (!test_and_set_bit(BCACHE_DEV_WB_RUNNING, &dc->disk.flags))
 340                         schedule_delayed_work(&dc->writeback_rate_update,
 341                                       dc->writeback_rate_update_seconds * HZ);
 342
 343         mutex_unlock(&bch_register_lock);
 344         return size;
 345 }
 346
 347 static struct attribute *bch_cached_dev_files[] = {
 348         &sysfs_attach,
 349         &sysfs_detach,
 350         &sysfs_stop,
 351 #if 0
 352         &sysfs_data_csum,
 353 #endif
 354         &sysfs_cache_mode,
 355         &sysfs_stop_when_cache_set_failed,
 356         &sysfs_writeback_metadata,
 357         &sysfs_writeback_running,
 358         &sysfs_writeback_delay,
 359         &sysfs_writeback_percent,
 360         &sysfs_writeback_rate,
 361         &sysfs_writeback_rate_update_seconds,
 362         &sysfs_writeback_rate_i_term_inverse,
 363         &sysfs_writeback_rate_p_term_inverse,
 364         &sysfs_writeback_rate_debug,
 365         &sysfs_errors,
 366         &sysfs_io_error_limit,
 367         &sysfs_io_disable,
 368         &sysfs_dirty_data,
 369         &sysfs_stripe_size,
 370         &sysfs_partial_stripes_expensive,
 371         &sysfs_sequential_cutoff,
 372         &sysfs_clear_stats,
 373         &sysfs_running,
 374         &sysfs_state,
 375         &sysfs_label,
 376         &sysfs_readahead,
 377 #ifdef CONFIG_BCACHE_DEBUG
 378         &sysfs_verify,
 379         &sysfs_bypass_torture_test,
 380 #endif
 381         NULL
 382 };
 383 KTYPE(bch_cached_dev);
 384
 385 SHOW(bch_flash_dev)
 386 {
 387         struct bcache_device *d = container_of(kobj, struct bcache_device,
 388                                                kobj);
 389         struct uuid_entry *u = &d->c->uuids[d->id];
 390
 391         sysfs_printf(data_csum, "%i", d->data_csum);
 392         sysfs_hprint(size,      u->sectors << 9);
 393
 394         if (attr == &sysfs_label) {
 395                 memcpy(buf, u->label, SB_LABEL_SIZE);
 396                 buf[SB_LABEL_SIZE + 1] = '\0';
 397                 strcat(buf, "\n");
 398                 return strlen(buf);
 399         }
 400
 401         return 0;
 402 }
 403
 404 STORE(__bch_flash_dev)
 405 {
 406         struct bcache_device *d = container_of(kobj, struct bcache_device,
 407                                                kobj);
 408         struct uuid_entry *u = &d->c->uuids[d->id];
 409
 410         sysfs_strtoul(data_csum,        d->data_csum);
 411
 412         if (attr == &sysfs_size) {
 413                 uint64_t v;
 414                 strtoi_h_or_return(buf, v);
 415
 416                 u->sectors = v >> 9;
 417                 bch_uuid_write(d->c);
 418                 set_capacity(d->disk, u->sectors);
 419         }
 420
 421         if (attr == &sysfs_label) {
 422                 memcpy(u->label, buf, SB_LABEL_SIZE);
 423                 bch_uuid_write(d->c);
 424         }
 425
 426         if (attr == &sysfs_unregister) {
 427                 set_bit(BCACHE_DEV_DETACHING, &d->flags);
 428                 bcache_device_stop(d);
 429         }
 430
 431         return size;
 432 }
 433 STORE_LOCKED(bch_flash_dev)
 434
 435 static struct attribute *bch_flash_dev_files[] = {
 436         &sysfs_unregister,
 437 #if 0
 438         &sysfs_data_csum,
 439 #endif
 440         &sysfs_label,
 441         &sysfs_size,
 442         NULL
 443 };
 444 KTYPE(bch_flash_dev);
 445
 446 struct bset_stats_op {
 447         struct btree_op op;
 448         size_t nodes;
 449         struct bset_stats stats;
 450 };
 451
 452 static int bch_btree_bset_stats(struct btree_op *b_op, struct btree *b)
 453 {
 454         struct bset_stats_op *op = container_of(b_op, struct bset_stats_op, op);
 455
 456         op->nodes++;
 457         bch_btree_keys_stats(&b->keys, &op->stats);
 458
 459         return MAP_CONTINUE;
 460 }
 461
 462 static int bch_bset_print_stats(struct cache_set *c, char *buf)
 463 {
 464         struct bset_stats_op op;
 465         int ret;
 466
 467         memset(&op, 0, sizeof(op));
 468         bch_btree_op_init(&op.op, -1);
 469
 470         ret = bch_btree_map_nodes(&op.op, c, &ZERO_KEY, bch_btree_bset_stats);
 471         if (ret < 0)
 472                 return ret;
 473
 474         return snprintf(buf, PAGE_SIZE,
 475                         "btree nodes:           %zu\n"
 476                         "written sets:          %zu\n"
 477                         "unwritten sets:                %zu\n"
 478                         "written key bytes:     %zu\n"
 479                         "unwritten key bytes:   %zu\n"
 480                         "floats:                        %zu\n"
 481                         "failed:                        %zu\n",
 482                         op.nodes,
 483                         op.stats.sets_written, op.stats.sets_unwritten,
 484                         op.stats.bytes_written, op.stats.bytes_unwritten,
 485                         op.stats.floats, op.stats.failed);
 486 }
 487
 488 static unsigned bch_root_usage(struct cache_set *c)
 489 {
 490         unsigned bytes = 0;
 491         struct bkey *k;
 492         struct btree *b;
 493         struct btree_iter iter;
 494
 495         goto lock_root;
 496
 497         do {
 498                 rw_unlock(false, b);
 499 lock_root:
 500                 b = c->root;
 501                 rw_lock(false, b, b->level);
 502         } while (b != c->root);
 503
 504         for_each_key_filter(&b->keys, k, &iter, bch_ptr_bad)
 505                 bytes += bkey_bytes(k);
 506
 507         rw_unlock(false, b);
 508
 509         return (bytes * 100) / btree_bytes(c);
 510 }
 511
 512 static size_t bch_cache_size(struct cache_set *c)
 513 {
 514         size_t ret = 0;
 515         struct btree *b;
 516
 517         mutex_lock(&c->bucket_lock);
 518         list_for_each_entry(b, &c->btree_cache, list)
 519                 ret += 1 << (b->keys.page_order + PAGE_SHIFT);
 520
 521         mutex_unlock(&c->bucket_lock);
 522         return ret;
 523 }
 524
 525 static unsigned bch_cache_max_chain(struct cache_set *c)
 526 {
 527         unsigned ret = 0;
 528         struct hlist_head *h;
 529
 530         mutex_lock(&c->bucket_lock);
 531
 532         for (h = c->bucket_hash;
 533              h < c->bucket_hash + (1 << BUCKET_HASH_BITS);
 534              h++) {
 535                 unsigned i = 0;
 536                 struct hlist_node *p;
 537
 538                 hlist_for_each(p, h)
 539                         i++;
 540
 541                 ret = max(ret, i);
 542         }
 543
 544         mutex_unlock(&c->bucket_lock);
 545         return ret;
 546 }
 547
 548 static unsigned bch_btree_used(struct cache_set *c)
 549 {
 550         return div64_u64(c->gc_stats.key_bytes * 100,
 551                          (c->gc_stats.nodes ?: 1) * btree_bytes(c));
 552 }
 553
 554 static unsigned bch_average_key_size(struct cache_set *c)
 555 {
 556         return c->gc_stats.nkeys
 557                 ? div64_u64(c->gc_stats.data, c->gc_stats.nkeys)
 558                 : 0;
 559 }
 560
 561 SHOW(__bch_cache_set)
 562 {
 563         struct cache_set *c = container_of(kobj, struct cache_set, kobj);
 564
 565         sysfs_print(synchronous,                CACHE_SYNC(&c->sb));
 566         sysfs_print(journal_delay_ms,           c->journal_delay_ms);
 567         sysfs_hprint(bucket_size,               bucket_bytes(c));
 568         sysfs_hprint(block_size,                block_bytes(c));
 569         sysfs_print(tree_depth,                 c->root->level);
 570         sysfs_print(root_usage_percent,         bch_root_usage(c));
 571
 572         sysfs_hprint(btree_cache_size,          bch_cache_size(c));
 573         sysfs_print(btree_cache_max_chain,      bch_cache_max_chain(c));
 574         sysfs_print(cache_available_percent,    100 - c->gc_stats.in_use);
 575
 576         sysfs_print_time_stats(&c->btree_gc_time,       btree_gc, sec, ms);
 577         sysfs_print_time_stats(&c->btree_split_time,    btree_split, sec, us);
 578         sysfs_print_time_stats(&c->sort.time,           btree_sort, ms, us);
 579         sysfs_print_time_stats(&c->btree_read_time,     btree_read, ms, us);
 580
 581         sysfs_print(btree_used_percent, bch_btree_used(c));
 582         sysfs_print(btree_nodes,        c->gc_stats.nodes);
 583         sysfs_hprint(average_key_size,  bch_average_key_size(c));
 584
 585         sysfs_print(cache_read_races,
 586                     atomic_long_read(&c->cache_read_races));
 587
 588         sysfs_print(reclaim,
 589                     atomic_long_read(&c->reclaim));
 590
 591         sysfs_print(flush_write,
 592                     atomic_long_read(&c->flush_write));
 593
 594         sysfs_print(retry_flush_write,
 595                     atomic_long_read(&c->retry_flush_write));
 596
 597         sysfs_print(writeback_keys_done,
 598                     atomic_long_read(&c->writeback_keys_done));
 599         sysfs_print(writeback_keys_failed,
 600                     atomic_long_read(&c->writeback_keys_failed));
 601
 602         if (attr == &sysfs_errors)
 603                 return bch_snprint_string_list(buf, PAGE_SIZE, error_actions,
 604                                                c->on_error);
 605
 606         /* See count_io_errors for why 88 */
 607         sysfs_print(io_error_halflife,  c->error_decay * 88);
 608         sysfs_print(io_error_limit,     c->error_limit);
 609
 610         sysfs_hprint(congested,
 611                      ((uint64_t) bch_get_congested(c)) << 9);
 612         sysfs_print(congested_read_threshold_us,
 613                     c->congested_read_threshold_us);
 614         sysfs_print(congested_write_threshold_us,
 615                     c->congested_write_threshold_us);
 616
 617         sysfs_print(active_journal_entries,     fifo_used(&c->journal.pin));
 618         sysfs_printf(verify,                    "%i", c->verify);
 619         sysfs_printf(key_merging_disabled,      "%i", c->key_merging_disabled);
 620         sysfs_printf(expensive_debug_checks,
 621                      "%i", c->expensive_debug_checks);
 622         sysfs_printf(gc_always_rewrite,         "%i", c->gc_always_rewrite);
 623         sysfs_printf(btree_shrinker_disabled,   "%i", c->shrinker_disabled);
 624         sysfs_printf(copy_gc_enabled,           "%i", c->copy_gc_enabled);
 625         sysfs_printf(io_disable,                "%i",
 626                      test_bit(CACHE_SET_IO_DISABLE, &c->flags));
 627
 628         if (attr == &sysfs_bset_tree_stats)
 629                 return bch_bset_print_stats(c, buf);
 630
 631         return 0;
 632 }
 633 SHOW_LOCKED(bch_cache_set)
 634
 635 STORE(__bch_cache_set)
 636 {
 637         struct cache_set *c = container_of(kobj, struct cache_set, kobj);
 638
 639         if (attr == &sysfs_unregister)
 640                 bch_cache_set_unregister(c);
 641
 642         if (attr == &sysfs_stop)
 643                 bch_cache_set_stop(c);
 644
 645         if (attr == &sysfs_synchronous) {
 646                 bool sync = strtoul_or_return(buf);
 647
 648                 if (sync != CACHE_SYNC(&c->sb)) {
 649                         SET_CACHE_SYNC(&c->sb, sync);
 650                         bcache_write_super(c);
 651                 }
 652         }
 653
 654         if (attr == &sysfs_flash_vol_create) {
 655                 int r;
 656                 uint64_t v;
 657                 strtoi_h_or_return(buf, v);
 658
 659                 r = bch_flash_dev_create(c, v);
 660                 if (r)
 661                         return r;
 662         }
 663
 664         if (attr == &sysfs_clear_stats) {
 665                 atomic_long_set(&c->writeback_keys_done,        0);
 666                 atomic_long_set(&c->writeback_keys_failed,      0);
 667
 668                 memset(&c->gc_stats, 0, sizeof(struct gc_stat));
 669                 bch_cache_accounting_clear(&c->accounting);
 670         }
 671
 672         if (attr == &sysfs_trigger_gc) {
 673                 /*
 674                  * Garbage collection thread only works when sectors_to_gc < 0,
 675                  * when users write to sysfs entry trigger_gc, most of time
 676                  * they want to forcibly triger gargage collection. Here -1 is
 677                  * set to c->sectors_to_gc, to make gc_should_run() give a
 678                  * chance to permit gc thread to run. "give a chance" means
 679                  * before going into gc_should_run(), there is still chance
 680                  * that c->sectors_to_gc being set to other positive value. So
 681                  * writing sysfs entry trigger_gc won't always make sure gc
 682                  * thread takes effect.
 683                  */
 684                 atomic_set(&c->sectors_to_gc, -1);
 685                 wake_up_gc(c);
 686         }
 687
 688         if (attr == &sysfs_prune_cache) {
 689                 struct shrink_control sc;
 690                 sc.gfp_mask = GFP_KERNEL;
 691                 sc.nr_to_scan = strtoul_or_return(buf);
 692                 c->shrink.scan_objects(&c->shrink, &sc);
 693         }
 694
 695         sysfs_strtoul(congested_read_threshold_us,
 696                       c->congested_read_threshold_us);
 697         sysfs_strtoul(congested_write_threshold_us,
 698                       c->congested_write_threshold_us);
 699
 700         if (attr == &sysfs_errors) {
 701                 ssize_t v = bch_read_string_list(buf, error_actions);
 702
 703                 if (v < 0)
 704                         return v;
 705
 706                 c->on_error = v;
 707         }
 708
 709         if (attr == &sysfs_io_error_limit)
 710                 c->error_limit = strtoul_or_return(buf);
 711
 712         /* See count_io_errors() for why 88 */
 713         if (attr == &sysfs_io_error_halflife)
 714                 c->error_decay = strtoul_or_return(buf) / 88;
 715
 716         if (attr == &sysfs_io_disable) {
 717                 int v = strtoul_or_return(buf);
 718
 719                 if (v) {
 720                         if (test_and_set_bit(CACHE_SET_IO_DISABLE,
 721                                              &c->flags))
 722                                 pr_warn("CACHE_SET_IO_DISABLE already set");
 723                 } else {
 724                         if (!test_and_clear_bit(CACHE_SET_IO_DISABLE,
 725                                                 &c->flags))
 726                                 pr_warn("CACHE_SET_IO_DISABLE already cleared");
 727                 }
 728         }
 729
 730         sysfs_strtoul(journal_delay_ms,         c->journal_delay_ms);
 731         sysfs_strtoul(verify,                   c->verify);
 732         sysfs_strtoul(key_merging_disabled,     c->key_merging_disabled);
 733         sysfs_strtoul(expensive_debug_checks,   c->expensive_debug_checks);
 734         sysfs_strtoul(gc_always_rewrite,        c->gc_always_rewrite);
 735         sysfs_strtoul(btree_shrinker_disabled,  c->shrinker_disabled);
 736         sysfs_strtoul(copy_gc_enabled,          c->copy_gc_enabled);
 737
 738         return size;
 739 }
 740 STORE_LOCKED(bch_cache_set)
 741
 742 SHOW(bch_cache_set_internal)
 743 {
 744         struct cache_set *c = container_of(kobj, struct cache_set, internal);
 745         return bch_cache_set_show(&c->kobj, attr, buf);
 746 }
 747
 748 STORE(bch_cache_set_internal)
 749 {
 750         struct cache_set *c = container_of(kobj, struct cache_set, internal);
 751         return bch_cache_set_store(&c->kobj, attr, buf, size);
 752 }
 753
 754 static void bch_cache_set_internal_release(struct kobject *k)
 755 {
 756 }
 757
 758 static struct attribute *bch_cache_set_files[] = {
 759         &sysfs_unregister,
 760         &sysfs_stop,
 761         &sysfs_synchronous,
 762         &sysfs_journal_delay_ms,
 763         &sysfs_flash_vol_create,
 764
 765         &sysfs_bucket_size,
 766         &sysfs_block_size,
 767         &sysfs_tree_depth,
 768         &sysfs_root_usage_percent,
 769         &sysfs_btree_cache_size,
 770         &sysfs_cache_available_percent,
 771
 772         &sysfs_average_key_size,
 773
 774         &sysfs_errors,
 775         &sysfs_io_error_limit,
 776         &sysfs_io_error_halflife,
 777         &sysfs_congested,
 778         &sysfs_congested_read_threshold_us,
 779         &sysfs_congested_write_threshold_us,
 780         &sysfs_clear_stats,
 781         NULL
 782 };
 783 KTYPE(bch_cache_set);
 784
 785 static struct attribute *bch_cache_set_internal_files[] = {
 786         &sysfs_active_journal_entries,
 787
 788         sysfs_time_stats_attribute_list(btree_gc, sec, ms)
 789         sysfs_time_stats_attribute_list(btree_split, sec, us)
 790         sysfs_time_stats_attribute_list(btree_sort, ms, us)
 791         sysfs_time_stats_attribute_list(btree_read, ms, us)
 792
 793         &sysfs_btree_nodes,
 794         &sysfs_btree_used_percent,
 795         &sysfs_btree_cache_max_chain,
 796
 797         &sysfs_bset_tree_stats,
 798         &sysfs_cache_read_races,
 799         &sysfs_reclaim,
 800         &sysfs_flush_write,
 801         &sysfs_retry_flush_write,
 802         &sysfs_writeback_keys_done,
 803         &sysfs_writeback_keys_failed,
 804
 805         &sysfs_trigger_gc,
 806         &sysfs_prune_cache,
 807 #ifdef CONFIG_BCACHE_DEBUG
 808         &sysfs_verify,
 809         &sysfs_key_merging_disabled,
 810         &sysfs_expensive_debug_checks,
 811 #endif
 812         &sysfs_gc_always_rewrite,
 813         &sysfs_btree_shrinker_disabled,
 814         &sysfs_copy_gc_enabled,
 815         &sysfs_io_disable,
 816         NULL
 817 };
 818 KTYPE(bch_cache_set_internal);
 819
 820 static int __bch_cache_cmp(const void *l, const void *r)
 821 {
 822         return *((uint16_t *)r) - *((uint16_t *)l);
 823 }
 824
 825 SHOW(__bch_cache)
 826 {
 827         struct cache *ca = container_of(kobj, struct cache, kobj);
 828
 829         sysfs_hprint(bucket_size,       bucket_bytes(ca));
 830         sysfs_hprint(block_size,        block_bytes(ca));
 831         sysfs_print(nbuckets,           ca->sb.nbuckets);
 832         sysfs_print(discard,            ca->discard);
 833         sysfs_hprint(written, atomic_long_read(&ca->sectors_written) << 9);
 834         sysfs_hprint(btree_written,
 835                      atomic_long_read(&ca->btree_sectors_written) << 9);
 836         sysfs_hprint(metadata_written,
 837                      (atomic_long_read(&ca->meta_sectors_written) +
 838                       atomic_long_read(&ca->btree_sectors_written)) << 9);
 839
 840         sysfs_print(io_errors,
 841                     atomic_read(&ca->io_errors) >> IO_ERROR_SHIFT);
 842
 843         if (attr == &sysfs_cache_replacement_policy)
 844                 return bch_snprint_string_list(buf, PAGE_SIZE,
 845                                                cache_replacement_policies,
 846                                                CACHE_REPLACEMENT(&ca->sb));
 847
 848         if (attr == &sysfs_priority_stats) {
 849                 struct bucket *b;
 850                 size_t n = ca->sb.nbuckets, i;
 851                 size_t unused = 0, available = 0, dirty = 0, meta = 0;
 852                 uint64_t sum = 0;
 853                 /* Compute 31 quantiles */
 854                 uint16_t q[31], *p, *cached;
 855                 ssize_t ret;
 856
 857                 cached = p = vmalloc(ca->sb.nbuckets * sizeof(uint16_t));
 858                 if (!p)
 859                         return -ENOMEM;
 860
 861                 mutex_lock(&ca->set->bucket_lock);
 862                 for_each_bucket(b, ca) {
 863                         if (!GC_SECTORS_USED(b))
 864                                 unused++;
 865                         if (GC_MARK(b) == GC_MARK_RECLAIMABLE)
 866                                 available++;
 867                         if (GC_MARK(b) == GC_MARK_DIRTY)
 868                                 dirty++;
 869                         if (GC_MARK(b) == GC_MARK_METADATA)
 870                                 meta++;
 871                 }
 872
 873                 for (i = ca->sb.first_bucket; i < n; i++)
 874                         p[i] = ca->buckets[i].prio;
 875                 mutex_unlock(&ca->set->bucket_lock);
 876
 877                 sort(p, n, sizeof(uint16_t), __bch_cache_cmp, NULL);
 878
 879                 while (n &&
 880                        !cached[n - 1])
 881                         --n;
 882
 883                 unused = ca->sb.nbuckets - n;
 884
 885                 while (cached < p + n &&
 886                        *cached == BTREE_PRIO)
 887                         cached++, n--;
 888
 889                 for (i = 0; i < n; i++)
 890                         sum += INITIAL_PRIO - cached[i];
 891
 892                 if (n)
 893                         do_div(sum, n);
 894
 895                 for (i = 0; i < ARRAY_SIZE(q); i++)
 896                         q[i] = INITIAL_PRIO - cached[n * (i + 1) /
 897                                 (ARRAY_SIZE(q) + 1)];
 898
 899                 vfree(p);
 900
 901                 ret = scnprintf(buf, PAGE_SIZE,
 902                                 "Unused:                %zu%%\n"
 903                                 "Clean:         %zu%%\n"
 904                                 "Dirty:         %zu%%\n"
 905                                 "Metadata:      %zu%%\n"
 906                                 "Average:       %llu\n"
 907                                 "Sectors per Q: %zu\n"
 908                                 "Quantiles:     [",
 909                                 unused * 100 / (size_t) ca->sb.nbuckets,
 910                                 available * 100 / (size_t) ca->sb.nbuckets,
 911                                 dirty * 100 / (size_t) ca->sb.nbuckets,
 912                                 meta * 100 / (size_t) ca->sb.nbuckets, sum,
 913                                 n * ca->sb.bucket_size / (ARRAY_SIZE(q) + 1));
 914
 915                 for (i = 0; i < ARRAY_SIZE(q); i++)
 916                         ret += scnprintf(buf + ret, PAGE_SIZE - ret,
 917                                          "%u ", q[i]);
 918                 ret--;
 919
 920                 ret += scnprintf(buf + ret, PAGE_SIZE - ret, "]\n");
 921
 922                 return ret;
 923         }
 924
 925         return 0;
 926 }
 927 SHOW_LOCKED(bch_cache)
 928
 929 STORE(__bch_cache)
 930 {
 931         struct cache *ca = container_of(kobj, struct cache, kobj);
 932
 933         if (attr == &sysfs_discard) {
 934                 bool v = strtoul_or_return(buf);
 935
 936                 if (blk_queue_discard(bdev_get_queue(ca->bdev)))
 937                         ca->discard = v;
 938
 939                 if (v != CACHE_DISCARD(&ca->sb)) {
 940                         SET_CACHE_DISCARD(&ca->sb, v);
 941                         bcache_write_super(ca->set);
 942                 }
 943         }
 944
 945         if (attr == &sysfs_cache_replacement_policy) {
 946                 ssize_t v = bch_read_string_list(buf, cache_replacement_policies);
 947
 948                 if (v < 0)
 949                         return v;
 950
 951                 if ((unsigned) v != CACHE_REPLACEMENT(&ca->sb)) {
 952                         mutex_lock(&ca->set->bucket_lock);
 953                         SET_CACHE_REPLACEMENT(&ca->sb, v);
 954                         mutex_unlock(&ca->set->bucket_lock);
 955
 956                         bcache_write_super(ca->set);
 957                 }
 958         }
 959
 960         if (attr == &sysfs_clear_stats) {
 961                 atomic_long_set(&ca->sectors_written, 0);
 962                 atomic_long_set(&ca->btree_sectors_written, 0);
 963                 atomic_long_set(&ca->meta_sectors_written, 0);
 964                 atomic_set(&ca->io_count, 0);
 965                 atomic_set(&ca->io_errors, 0);
 966         }
 967
 968         return size;
 969 }
 970 STORE_LOCKED(bch_cache)
 971
 972 static struct attribute *bch_cache_files[] = {
 973         &sysfs_bucket_size,
 974         &sysfs_block_size,
 975         &sysfs_nbuckets,
 976         &sysfs_priority_stats,
 977         &sysfs_discard,
 978         &sysfs_written,
 979         &sysfs_btree_written,
 980         &sysfs_metadata_written,
 981         &sysfs_io_errors,
 982         &sysfs_clear_stats,
 983         &sysfs_cache_replacement_policy,
 984         NULL
 985 };
 986 KTYPE(bch_cache);