drivers/lightnvm/pblk-sysfs.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (C) 2016 CNEX Labs
   4  * Initial release: Javier Gonzalez <javier@cnexlabs.com>
   5  *                  Matias Bjorling <matias@cnexlabs.com>
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License version
   9  * 2 as published by the Free Software Foundation.
  10  *
  11  * This program is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *
  16  * Implementation of a physical block-device target for Open-channel SSDs.
  17  *
  18  * pblk-sysfs.c - pblk's sysfs
  19  *
  20  */
  21
  22 #include "pblk.h"
  23
  24 static ssize_t pblk_sysfs_luns_show(struct pblk *pblk, char *page)
  25 {
  26         struct nvm_tgt_dev *dev = pblk->dev;
  27         struct nvm_geo *geo = &dev->geo;
  28         struct pblk_lun *rlun;
  29         ssize_t sz = 0;
  30         int i;
  31
  32         for (i = 0; i < geo->all_luns; i++) {
  33                 int active = 1;
  34
  35                 rlun = &pblk->luns[i];
  36                 if (!down_trylock(&rlun->wr_sem)) {
  37                         active = 0;
  38                         up(&rlun->wr_sem);
  39                 }
  40                 sz += snprintf(page + sz, PAGE_SIZE - sz,
  41                                 "pblk: pos:%d, ch:%d, lun:%d - %d\n",
  42                                         i,
  43                                         rlun->bppa.a.ch,
  44                                         rlun->bppa.a.lun,
  45                                         active);
  46         }
  47
  48         return sz;
  49 }
  50
  51 static ssize_t pblk_sysfs_rate_limiter(struct pblk *pblk, char *page)
  52 {
  53         int free_blocks, free_user_blocks, total_blocks;
  54         int rb_user_max, rb_user_cnt;
  55         int rb_gc_max, rb_gc_cnt, rb_budget, rb_state;
  56
  57         free_blocks = pblk_rl_nr_free_blks(&pblk->rl);
  58         free_user_blocks = pblk_rl_nr_user_free_blks(&pblk->rl);
  59         rb_user_max = pblk->rl.rb_user_max;
  60         rb_user_cnt = atomic_read(&pblk->rl.rb_user_cnt);
  61         rb_gc_max = pblk->rl.rb_gc_max;
  62         rb_gc_cnt = atomic_read(&pblk->rl.rb_gc_cnt);
  63         rb_budget = pblk->rl.rb_budget;
  64         rb_state = pblk->rl.rb_state;
  65
  66         total_blocks = pblk->rl.total_blocks;
  67
  68         return snprintf(page, PAGE_SIZE,
  69                 "u:%u/%u,gc:%u/%u(%u)(stop:<%u,full:>%u,free:%d/%d/%d)-%d\n",
  70                                 rb_user_cnt,
  71                                 rb_user_max,
  72                                 rb_gc_cnt,
  73                                 rb_gc_max,
  74                                 rb_state,
  75                                 rb_budget,
  76                                 pblk->rl.high,
  77                                 free_blocks,
  78                                 free_user_blocks,
  79                                 total_blocks,
  80                                 READ_ONCE(pblk->rl.rb_user_active));
  81 }
  82
  83 static ssize_t pblk_sysfs_gc_state_show(struct pblk *pblk, char *page)
  84 {
  85         int gc_enabled, gc_active;
  86
  87         pblk_gc_sysfs_state_show(pblk, &gc_enabled, &gc_active);
  88         return snprintf(page, PAGE_SIZE, "gc_enabled=%d, gc_active=%d\n",
  89                                         gc_enabled, gc_active);
  90 }
  91
  92 static ssize_t pblk_sysfs_stats(struct pblk *pblk, char *page)
  93 {
  94         ssize_t sz;
  95
  96         sz = snprintf(page, PAGE_SIZE,
  97                         "read_failed=%lu, read_high_ecc=%lu, read_empty=%lu, read_failed_gc=%lu, write_failed=%lu, erase_failed=%lu\n",
  98                         atomic_long_read(&pblk->read_failed),
  99                         atomic_long_read(&pblk->read_high_ecc),
 100                         atomic_long_read(&pblk->read_empty),
 101                         atomic_long_read(&pblk->read_failed_gc),
 102                         atomic_long_read(&pblk->write_failed),
 103                         atomic_long_read(&pblk->erase_failed));
 104
 105         return sz;
 106 }
 107
 108 static ssize_t pblk_sysfs_write_buffer(struct pblk *pblk, char *page)
 109 {
 110         return pblk_rb_sysfs(&pblk->rwb, page);
 111 }
 112
 113 static ssize_t pblk_sysfs_ppaf(struct pblk *pblk, char *page)
 114 {
 115         struct nvm_tgt_dev *dev = pblk->dev;
 116         struct nvm_geo *geo = &dev->geo;
 117         ssize_t sz = 0;
 118
 119         if (geo->version == NVM_OCSSD_SPEC_12) {
 120                 struct nvm_addrf_12 *ppaf = (struct nvm_addrf_12 *)&pblk->addrf;
 121                 struct nvm_addrf_12 *gppaf = (struct nvm_addrf_12 *)&geo->addrf;
 122
 123                 sz = snprintf(page, PAGE_SIZE,
 124                         "g:(b:%d)blk:%d/%d,pg:%d/%d,lun:%d/%d,ch:%d/%d,pl:%d/%d,sec:%d/%d\n",
 125                         pblk->addrf_len,
 126                         ppaf->blk_offset, ppaf->blk_len,
 127                         ppaf->pg_offset, ppaf->pg_len,
 128                         ppaf->lun_offset, ppaf->lun_len,
 129                         ppaf->ch_offset, ppaf->ch_len,
 130                         ppaf->pln_offset, ppaf->pln_len,
 131                         ppaf->sec_offset, ppaf->sec_len);
 132
 133                 sz += snprintf(page + sz, PAGE_SIZE - sz,
 134                         "d:blk:%d/%d,pg:%d/%d,lun:%d/%d,ch:%d/%d,pl:%d/%d,sec:%d/%d\n",
 135                         gppaf->blk_offset, gppaf->blk_len,
 136                         gppaf->pg_offset, gppaf->pg_len,
 137                         gppaf->lun_offset, gppaf->lun_len,
 138                         gppaf->ch_offset, gppaf->ch_len,
 139                         gppaf->pln_offset, gppaf->pln_len,
 140                         gppaf->sec_offset, gppaf->sec_len);
 141         } else {
 142                 struct nvm_addrf *ppaf = &pblk->addrf;
 143                 struct nvm_addrf *gppaf = &geo->addrf;
 144
 145                 sz = snprintf(page, PAGE_SIZE,
 146                         "pblk:(s:%d)ch:%d/%d,lun:%d/%d,chk:%d/%d/sec:%d/%d\n",
 147                         pblk->addrf_len,
 148                         ppaf->ch_offset, ppaf->ch_len,
 149                         ppaf->lun_offset, ppaf->lun_len,
 150                         ppaf->chk_offset, ppaf->chk_len,
 151                         ppaf->sec_offset, ppaf->sec_len);
 152
 153                 sz += snprintf(page + sz, PAGE_SIZE - sz,
 154                         "device:ch:%d/%d,lun:%d/%d,chk:%d/%d,sec:%d/%d\n",
 155                         gppaf->ch_offset, gppaf->ch_len,
 156                         gppaf->lun_offset, gppaf->lun_len,
 157                         gppaf->chk_offset, gppaf->chk_len,
 158                         gppaf->sec_offset, gppaf->sec_len);
 159         }
 160
 161         return sz;
 162 }
 163
 164 static ssize_t pblk_sysfs_lines(struct pblk *pblk, char *page)
 165 {
 166         struct nvm_tgt_dev *dev = pblk->dev;
 167         struct nvm_geo *geo = &dev->geo;
 168         struct pblk_line_meta *lm = &pblk->lm;
 169         struct pblk_line_mgmt *l_mg = &pblk->l_mg;
 170         struct pblk_line *line;
 171         ssize_t sz = 0;
 172         int nr_free_lines;
 173         int cur_data, cur_log;
 174         int free_line_cnt = 0, closed_line_cnt = 0, emeta_line_cnt = 0;
 175         int d_line_cnt = 0, l_line_cnt = 0;
 176         int gc_full = 0, gc_high = 0, gc_mid = 0, gc_low = 0, gc_empty = 0;
 177         int gc_werr = 0;
 178
 179         int bad = 0, cor = 0;
 180         int msecs = 0, cur_sec = 0, vsc = 0, sec_in_line = 0;
 181         int map_weight = 0, meta_weight = 0;
 182
 183         spin_lock(&l_mg->free_lock);
 184         cur_data = (l_mg->data_line) ? l_mg->data_line->id : -1;
 185         cur_log = (l_mg->log_line) ? l_mg->log_line->id : -1;
 186         nr_free_lines = l_mg->nr_free_lines;
 187
 188         list_for_each_entry(line, &l_mg->free_list, list)
 189                 free_line_cnt++;
 190         spin_unlock(&l_mg->free_lock);
 191
 192         spin_lock(&l_mg->close_lock);
 193         list_for_each_entry(line, &l_mg->emeta_list, list)
 194                 emeta_line_cnt++;
 195         spin_unlock(&l_mg->close_lock);
 196
 197         spin_lock(&l_mg->gc_lock);
 198         list_for_each_entry(line, &l_mg->gc_full_list, list) {
 199                 if (line->type == PBLK_LINETYPE_DATA)
 200                         d_line_cnt++;
 201                 else if (line->type == PBLK_LINETYPE_LOG)
 202                         l_line_cnt++;
 203                 closed_line_cnt++;
 204                 gc_full++;
 205         }
 206
 207         list_for_each_entry(line, &l_mg->gc_high_list, list) {
 208                 if (line->type == PBLK_LINETYPE_DATA)
 209                         d_line_cnt++;
 210                 else if (line->type == PBLK_LINETYPE_LOG)
 211                         l_line_cnt++;
 212                 closed_line_cnt++;
 213                 gc_high++;
 214         }
 215
 216         list_for_each_entry(line, &l_mg->gc_mid_list, list) {
 217                 if (line->type == PBLK_LINETYPE_DATA)
 218                         d_line_cnt++;
 219                 else if (line->type == PBLK_LINETYPE_LOG)
 220                         l_line_cnt++;
 221                 closed_line_cnt++;
 222                 gc_mid++;
 223         }
 224
 225         list_for_each_entry(line, &l_mg->gc_low_list, list) {
 226                 if (line->type == PBLK_LINETYPE_DATA)
 227                         d_line_cnt++;
 228                 else if (line->type == PBLK_LINETYPE_LOG)
 229                         l_line_cnt++;
 230                 closed_line_cnt++;
 231                 gc_low++;
 232         }
 233
 234         list_for_each_entry(line, &l_mg->gc_empty_list, list) {
 235                 if (line->type == PBLK_LINETYPE_DATA)
 236                         d_line_cnt++;
 237                 else if (line->type == PBLK_LINETYPE_LOG)
 238                         l_line_cnt++;
 239                 closed_line_cnt++;
 240                 gc_empty++;
 241         }
 242
 243         list_for_each_entry(line, &l_mg->gc_werr_list, list) {
 244                 if (line->type == PBLK_LINETYPE_DATA)
 245                         d_line_cnt++;
 246                 else if (line->type == PBLK_LINETYPE_LOG)
 247                         l_line_cnt++;
 248                 closed_line_cnt++;
 249                 gc_werr++;
 250         }
 251
 252         list_for_each_entry(line, &l_mg->bad_list, list)
 253                 bad++;
 254         list_for_each_entry(line, &l_mg->corrupt_list, list)
 255                 cor++;
 256         spin_unlock(&l_mg->gc_lock);
 257
 258         spin_lock(&l_mg->free_lock);
 259         if (l_mg->data_line) {
 260                 cur_sec = l_mg->data_line->cur_sec;
 261                 msecs = l_mg->data_line->left_msecs;
 262                 vsc = le32_to_cpu(*l_mg->data_line->vsc);
 263                 sec_in_line = l_mg->data_line->sec_in_line;
 264                 meta_weight = bitmap_weight(&l_mg->meta_bitmap,
 265                                                         PBLK_DATA_LINES);
 266
 267                 spin_lock(&l_mg->data_line->lock);
 268                 if (l_mg->data_line->map_bitmap)
 269                         map_weight = bitmap_weight(l_mg->data_line->map_bitmap,
 270                                                         lm->sec_per_line);
 271                 else
 272                         map_weight = 0;
 273                 spin_unlock(&l_mg->data_line->lock);
 274         }
 275         spin_unlock(&l_mg->free_lock);
 276
 277         if (nr_free_lines != free_line_cnt)
 278                 pblk_err(pblk, "corrupted free line list:%d/%d\n",
 279                                                 nr_free_lines, free_line_cnt);
 280
 281         sz = snprintf(page, PAGE_SIZE - sz,
 282                 "line: nluns:%d, nblks:%d, nsecs:%d\n",
 283                 geo->all_luns, lm->blk_per_line, lm->sec_per_line);
 284
 285         sz += snprintf(page + sz, PAGE_SIZE - sz,
 286                 "lines:d:%d,l:%d-f:%d,m:%d/%d,c:%d,b:%d,co:%d(d:%d,l:%d)t:%d\n",
 287                                         cur_data, cur_log,
 288                                         nr_free_lines,
 289                                         emeta_line_cnt, meta_weight,
 290                                         closed_line_cnt,
 291                                         bad, cor,
 292                                         d_line_cnt, l_line_cnt,
 293                                         l_mg->nr_lines);
 294
 295         sz += snprintf(page + sz, PAGE_SIZE - sz,
 296                 "GC: full:%d, high:%d, mid:%d, low:%d, empty:%d, werr: %d, queue:%d\n",
 297                         gc_full, gc_high, gc_mid, gc_low, gc_empty, gc_werr,
 298                         atomic_read(&pblk->gc.read_inflight_gc));
 299
 300         sz += snprintf(page + sz, PAGE_SIZE - sz,
 301                 "data (%d) cur:%d, left:%d, vsc:%d, s:%d, map:%d/%d (%d)\n",
 302                         cur_data, cur_sec, msecs, vsc, sec_in_line,
 303                         map_weight, lm->sec_per_line,
 304                         atomic_read(&pblk->inflight_io));
 305
 306         return sz;
 307 }
 308
 309 static ssize_t pblk_sysfs_lines_info(struct pblk *pblk, char *page)
 310 {
 311         struct nvm_tgt_dev *dev = pblk->dev;
 312         struct nvm_geo *geo = &dev->geo;
 313         struct pblk_line_meta *lm = &pblk->lm;
 314         ssize_t sz = 0;
 315
 316         sz = snprintf(page, PAGE_SIZE - sz,
 317                                 "smeta - len:%d, secs:%d\n",
 318                                         lm->smeta_len, lm->smeta_sec);
 319         sz += snprintf(page + sz, PAGE_SIZE - sz,
 320                                 "emeta - len:%d, sec:%d, bb_start:%d\n",
 321                                         lm->emeta_len[0], lm->emeta_sec[0],
 322                                         lm->emeta_bb);
 323         sz += snprintf(page + sz, PAGE_SIZE - sz,
 324                                 "bitmap lengths: sec:%d, blk:%d, lun:%d\n",
 325                                         lm->sec_bitmap_len,
 326                                         lm->blk_bitmap_len,
 327                                         lm->lun_bitmap_len);
 328         sz += snprintf(page + sz, PAGE_SIZE - sz,
 329                                 "blk_line:%d, sec_line:%d, sec_blk:%d\n",
 330                                         lm->blk_per_line,
 331                                         lm->sec_per_line,
 332                                         geo->clba);
 333
 334         return sz;
 335 }
 336
 337 static ssize_t pblk_sysfs_get_sec_per_write(struct pblk *pblk, char *page)
 338 {
 339         return snprintf(page, PAGE_SIZE, "%d\n", pblk->sec_per_write);
 340 }
 341
 342 static ssize_t pblk_get_write_amp(u64 user, u64 gc, u64 pad,
 343                                   char *page)
 344 {
 345         int sz;
 346
 347         sz = snprintf(page, PAGE_SIZE,
 348                         "user:%lld gc:%lld pad:%lld WA:",
 349                         user, gc, pad);
 350
 351         if (!user) {
 352                 sz += snprintf(page + sz, PAGE_SIZE - sz, "NaN\n");
 353         } else {
 354                 u64 wa_int;
 355                 u32 wa_frac;
 356
 357                 wa_int = (user + gc + pad) * 100000;
 358                 wa_int = div64_u64(wa_int, user);
 359                 wa_int = div_u64_rem(wa_int, 100000, &wa_frac);
 360
 361                 sz += snprintf(page + sz, PAGE_SIZE - sz, "%llu.%05u\n",
 362                                                         wa_int, wa_frac);
 363         }
 364
 365         return sz;
 366 }
 367
 368 static ssize_t pblk_sysfs_get_write_amp_mileage(struct pblk *pblk, char *page)
 369 {
 370         return pblk_get_write_amp(atomic64_read(&pblk->user_wa),
 371                 atomic64_read(&pblk->gc_wa), atomic64_read(&pblk->pad_wa),
 372                 page);
 373 }
 374
 375 static ssize_t pblk_sysfs_get_write_amp_trip(struct pblk *pblk, char *page)
 376 {
 377         return pblk_get_write_amp(
 378                 atomic64_read(&pblk->user_wa) - pblk->user_rst_wa,
 379                 atomic64_read(&pblk->gc_wa) - pblk->gc_rst_wa,
 380                 atomic64_read(&pblk->pad_wa) - pblk->pad_rst_wa, page);
 381 }
 382
 383 static long long bucket_percentage(unsigned long long bucket,
 384                                    unsigned long long total)
 385 {
 386         int p = bucket * 100;
 387
 388         p = div_u64(p, total);
 389
 390         return p;
 391 }
 392
 393 static ssize_t pblk_sysfs_get_padding_dist(struct pblk *pblk, char *page)
 394 {
 395         int sz = 0;
 396         unsigned long long total;
 397         unsigned long long total_buckets = 0;
 398         int buckets = pblk->min_write_pgs - 1;
 399         int i;
 400
 401         total = atomic64_read(&pblk->nr_flush) - pblk->nr_flush_rst;
 402         if (!total) {
 403                 for (i = 0; i < (buckets + 1); i++)
 404                         sz += snprintf(page + sz, PAGE_SIZE - sz,
 405                                 "%d:0 ", i);
 406                 sz += snprintf(page + sz, PAGE_SIZE - sz, "\n");
 407
 408                 return sz;
 409         }
 410
 411         for (i = 0; i < buckets; i++)
 412                 total_buckets += atomic64_read(&pblk->pad_dist[i]);
 413
 414         sz += snprintf(page + sz, PAGE_SIZE - sz, "0:%lld%% ",
 415                 bucket_percentage(total - total_buckets, total));
 416
 417         for (i = 0; i < buckets; i++) {
 418                 unsigned long long p;
 419
 420                 p = bucket_percentage(atomic64_read(&pblk->pad_dist[i]),
 421                                           total);
 422                 sz += snprintf(page + sz, PAGE_SIZE - sz, "%d:%lld%% ",
 423                                 i + 1, p);
 424         }
 425         sz += snprintf(page + sz, PAGE_SIZE - sz, "\n");
 426
 427         return sz;
 428 }
 429
 430 #ifdef CONFIG_NVM_PBLK_DEBUG
 431 static ssize_t pblk_sysfs_stats_debug(struct pblk *pblk, char *page)
 432 {
 433         return snprintf(page, PAGE_SIZE,
 434                 "%lu\t%lu\t%ld\t%llu\t%ld\t%lu\t%lu\t%lu\t%lu\t%lu\t%lu\t%lu\t%lu\n",
 435                         atomic_long_read(&pblk->inflight_writes),
 436                         atomic_long_read(&pblk->inflight_reads),
 437                         atomic_long_read(&pblk->req_writes),
 438                         (u64)atomic64_read(&pblk->nr_flush),
 439                         atomic_long_read(&pblk->padded_writes),
 440                         atomic_long_read(&pblk->padded_wb),
 441                         atomic_long_read(&pblk->sub_writes),
 442                         atomic_long_read(&pblk->sync_writes),
 443                         atomic_long_read(&pblk->recov_writes),
 444                         atomic_long_read(&pblk->recov_gc_writes),
 445                         atomic_long_read(&pblk->recov_gc_reads),
 446                         atomic_long_read(&pblk->cache_reads),
 447                         atomic_long_read(&pblk->sync_reads));
 448 }
 449 #endif
 450
 451 static ssize_t pblk_sysfs_gc_force(struct pblk *pblk, const char *page,
 452                                    size_t len)
 453 {
 454         size_t c_len;
 455         int force;
 456
 457         c_len = strcspn(page, "\n");
 458         if (c_len >= len)
 459                 return -EINVAL;
 460
 461         if (kstrtouint(page, 0, &force))
 462                 return -EINVAL;
 463
 464         pblk_gc_sysfs_force(pblk, force);
 465
 466         return len;
 467 }
 468
 469 static ssize_t pblk_sysfs_set_sec_per_write(struct pblk *pblk,
 470                                              const char *page, size_t len)
 471 {
 472         size_t c_len;
 473         int sec_per_write;
 474
 475         c_len = strcspn(page, "\n");
 476         if (c_len >= len)
 477                 return -EINVAL;
 478
 479         if (kstrtouint(page, 0, &sec_per_write))
 480                 return -EINVAL;
 481
 482         if (sec_per_write < pblk->min_write_pgs
 483                                 || sec_per_write > pblk->max_write_pgs
 484                                 || sec_per_write % pblk->min_write_pgs != 0)
 485                 return -EINVAL;
 486
 487         pblk_set_sec_per_write(pblk, sec_per_write);
 488
 489         return len;
 490 }
 491
 492 static ssize_t pblk_sysfs_set_write_amp_trip(struct pblk *pblk,
 493                         const char *page, size_t len)
 494 {
 495         size_t c_len;
 496         int reset_value;
 497
 498         c_len = strcspn(page, "\n");
 499         if (c_len >= len)
 500                 return -EINVAL;
 501
 502         if (kstrtouint(page, 0, &reset_value))
 503                 return -EINVAL;
 504
 505         if (reset_value !=  0)
 506                 return -EINVAL;
 507
 508         pblk->user_rst_wa = atomic64_read(&pblk->user_wa);
 509         pblk->pad_rst_wa = atomic64_read(&pblk->pad_wa);
 510         pblk->gc_rst_wa = atomic64_read(&pblk->gc_wa);
 511
 512         return len;
 513 }
 514
 515
 516 static ssize_t pblk_sysfs_set_padding_dist(struct pblk *pblk,
 517                         const char *page, size_t len)
 518 {
 519         size_t c_len;
 520         int reset_value;
 521         int buckets = pblk->min_write_pgs - 1;
 522         int i;
 523
 524         c_len = strcspn(page, "\n");
 525         if (c_len >= len)
 526                 return -EINVAL;
 527
 528         if (kstrtouint(page, 0, &reset_value))
 529                 return -EINVAL;
 530
 531         if (reset_value !=  0)
 532                 return -EINVAL;
 533
 534         for (i = 0; i < buckets; i++)
 535                 atomic64_set(&pblk->pad_dist[i], 0);
 536
 537         pblk->nr_flush_rst = atomic64_read(&pblk->nr_flush);
 538
 539         return len;
 540 }
 541
 542 static struct attribute sys_write_luns = {
 543         .name = "write_luns",
 544         .mode = 0444,
 545 };
 546
 547 static struct attribute sys_rate_limiter_attr = {
 548         .name = "rate_limiter",
 549         .mode = 0444,
 550 };
 551
 552 static struct attribute sys_gc_state = {
 553         .name = "gc_state",
 554         .mode = 0444,
 555 };
 556
 557 static struct attribute sys_errors_attr = {
 558         .name = "errors",
 559         .mode = 0444,
 560 };
 561
 562 static struct attribute sys_rb_attr = {
 563         .name = "write_buffer",
 564         .mode = 0444,
 565 };
 566
 567 static struct attribute sys_stats_ppaf_attr = {
 568         .name = "ppa_format",
 569         .mode = 0444,
 570 };
 571
 572 static struct attribute sys_lines_attr = {
 573         .name = "lines",
 574         .mode = 0444,
 575 };
 576
 577 static struct attribute sys_lines_info_attr = {
 578         .name = "lines_info",
 579         .mode = 0444,
 580 };
 581
 582 static struct attribute sys_gc_force = {
 583         .name = "gc_force",
 584         .mode = 0200,
 585 };
 586
 587 static struct attribute sys_max_sec_per_write = {
 588         .name = "max_sec_per_write",
 589         .mode = 0644,
 590 };
 591
 592 static struct attribute sys_write_amp_mileage = {
 593         .name = "write_amp_mileage",
 594         .mode = 0444,
 595 };
 596
 597 static struct attribute sys_write_amp_trip = {
 598         .name = "write_amp_trip",
 599         .mode = 0644,
 600 };
 601
 602 static struct attribute sys_padding_dist = {
 603         .name = "padding_dist",
 604         .mode = 0644,
 605 };
 606
 607 #ifdef CONFIG_NVM_PBLK_DEBUG
 608 static struct attribute sys_stats_debug_attr = {
 609         .name = "stats",
 610         .mode = 0444,
 611 };
 612 #endif
 613
 614 static struct attribute *pblk_attrs[] = {
 615         &sys_write_luns,
 616         &sys_rate_limiter_attr,
 617         &sys_errors_attr,
 618         &sys_gc_state,
 619         &sys_gc_force,
 620         &sys_max_sec_per_write,
 621         &sys_rb_attr,
 622         &sys_stats_ppaf_attr,
 623         &sys_lines_attr,
 624         &sys_lines_info_attr,
 625         &sys_write_amp_mileage,
 626         &sys_write_amp_trip,
 627         &sys_padding_dist,
 628 #ifdef CONFIG_NVM_PBLK_DEBUG
 629         &sys_stats_debug_attr,
 630 #endif
 631         NULL,
 632 };
 633
 634 static ssize_t pblk_sysfs_show(struct kobject *kobj, struct attribute *attr,
 635                                char *buf)
 636 {
 637         struct pblk *pblk = container_of(kobj, struct pblk, kobj);
 638
 639         if (strcmp(attr->name, "rate_limiter") == 0)
 640                 return pblk_sysfs_rate_limiter(pblk, buf);
 641         else if (strcmp(attr->name, "write_luns") == 0)
 642                 return pblk_sysfs_luns_show(pblk, buf);
 643         else if (strcmp(attr->name, "gc_state") == 0)
 644                 return pblk_sysfs_gc_state_show(pblk, buf);
 645         else if (strcmp(attr->name, "errors") == 0)
 646                 return pblk_sysfs_stats(pblk, buf);
 647         else if (strcmp(attr->name, "write_buffer") == 0)
 648                 return pblk_sysfs_write_buffer(pblk, buf);
 649         else if (strcmp(attr->name, "ppa_format") == 0)
 650                 return pblk_sysfs_ppaf(pblk, buf);
 651         else if (strcmp(attr->name, "lines") == 0)
 652                 return pblk_sysfs_lines(pblk, buf);
 653         else if (strcmp(attr->name, "lines_info") == 0)
 654                 return pblk_sysfs_lines_info(pblk, buf);
 655         else if (strcmp(attr->name, "max_sec_per_write") == 0)
 656                 return pblk_sysfs_get_sec_per_write(pblk, buf);
 657         else if (strcmp(attr->name, "write_amp_mileage") == 0)
 658                 return pblk_sysfs_get_write_amp_mileage(pblk, buf);
 659         else if (strcmp(attr->name, "write_amp_trip") == 0)
 660                 return pblk_sysfs_get_write_amp_trip(pblk, buf);
 661         else if (strcmp(attr->name, "padding_dist") == 0)
 662                 return pblk_sysfs_get_padding_dist(pblk, buf);
 663 #ifdef CONFIG_NVM_PBLK_DEBUG
 664         else if (strcmp(attr->name, "stats") == 0)
 665                 return pblk_sysfs_stats_debug(pblk, buf);
 666 #endif
 667         return 0;
 668 }
 669
 670 static ssize_t pblk_sysfs_store(struct kobject *kobj, struct attribute *attr,
 671                                 const char *buf, size_t len)
 672 {
 673         struct pblk *pblk = container_of(kobj, struct pblk, kobj);
 674
 675         if (strcmp(attr->name, "gc_force") == 0)
 676                 return pblk_sysfs_gc_force(pblk, buf, len);
 677         else if (strcmp(attr->name, "max_sec_per_write") == 0)
 678                 return pblk_sysfs_set_sec_per_write(pblk, buf, len);
 679         else if (strcmp(attr->name, "write_amp_trip") == 0)
 680                 return pblk_sysfs_set_write_amp_trip(pblk, buf, len);
 681         else if (strcmp(attr->name, "padding_dist") == 0)
 682                 return pblk_sysfs_set_padding_dist(pblk, buf, len);
 683         return 0;
 684 }
 685
 686 static const struct sysfs_ops pblk_sysfs_ops = {
 687         .show = pblk_sysfs_show,
 688         .store = pblk_sysfs_store,
 689 };
 690
 691 static struct kobj_type pblk_ktype = {
 692         .sysfs_ops      = &pblk_sysfs_ops,
 693         .default_attrs  = pblk_attrs,
 694 };
 695
 696 int pblk_sysfs_init(struct gendisk *tdisk)
 697 {
 698         struct pblk *pblk = tdisk->private_data;
 699         struct device *parent_dev = disk_to_dev(pblk->disk);
 700         int ret;
 701
 702         ret = kobject_init_and_add(&pblk->kobj, &pblk_ktype,
 703                                         kobject_get(&parent_dev->kobj),
 704                                         "%s", "pblk");
 705         if (ret) {
 706                 pblk_err(pblk, "could not register\n");
 707                 return ret;
 708         }
 709
 710         kobject_uevent(&pblk->kobj, KOBJ_ADD);
 711         return 0;
 712 }
 713
 714 void pblk_sysfs_exit(struct gendisk *tdisk)
 715 {
 716         struct pblk *pblk = tdisk->private_data;
 717
 718         kobject_uevent(&pblk->kobj, KOBJ_REMOVE);
 719         kobject_del(&pblk->kobj);
 720         kobject_put(&pblk->kobj);
 721 }