Javier González | a4bd217 | 2017-04-15 20:55:50 +0200 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2016 CNEX Labs |
| 3 | * Initial release: Javier Gonzalez <javier@cnexlabs.com> |
| 4 | * Matias Bjorling <matias@cnexlabs.com> |
| 5 | * |
| 6 | * This program is free software; you can redistribute it and/or |
| 7 | * modify it under the terms of the GNU General Public License version |
| 8 | * 2 as published by the Free Software Foundation. |
| 9 | * |
| 10 | * This program is distributed in the hope that it will be useful, but |
| 11 | * WITHOUT ANY WARRANTY; without even the implied warranty of |
| 12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| 13 | * General Public License for more details. |
| 14 | * |
| 15 | * Implementation of a physical block-device target for Open-channel SSDs. |
| 16 | * |
| 17 | * pblk-sysfs.c - pblk's sysfs |
| 18 | * |
| 19 | */ |
| 20 | |
| 21 | #include "pblk.h" |
| 22 | |
| 23 | static ssize_t pblk_sysfs_luns_show(struct pblk *pblk, char *page) |
| 24 | { |
| 25 | struct nvm_tgt_dev *dev = pblk->dev; |
| 26 | struct nvm_geo *geo = &dev->geo; |
| 27 | struct pblk_lun *rlun; |
| 28 | ssize_t sz = 0; |
| 29 | int i; |
| 30 | |
| 31 | for (i = 0; i < geo->nr_luns; i++) { |
| 32 | int active = 1; |
| 33 | |
| 34 | rlun = &pblk->luns[i]; |
| 35 | if (!down_trylock(&rlun->wr_sem)) { |
| 36 | active = 0; |
| 37 | up(&rlun->wr_sem); |
| 38 | } |
| 39 | sz += snprintf(page + sz, PAGE_SIZE - sz, |
| 40 | "pblk: pos:%d, ch:%d, lun:%d - %d\n", |
| 41 | i, |
| 42 | rlun->bppa.g.ch, |
| 43 | rlun->bppa.g.lun, |
| 44 | active); |
| 45 | } |
| 46 | |
| 47 | return sz; |
| 48 | } |
| 49 | |
| 50 | static ssize_t pblk_sysfs_rate_limiter(struct pblk *pblk, char *page) |
| 51 | { |
| 52 | struct nvm_tgt_dev *dev = pblk->dev; |
| 53 | struct nvm_geo *geo = &dev->geo; |
| 54 | int free_blocks, total_blocks; |
| 55 | int rb_user_max, rb_user_cnt; |
| 56 | int rb_gc_max, rb_gc_rsv, rb_gc_cnt, rb_budget, rb_state; |
| 57 | |
| 58 | free_blocks = atomic_read(&pblk->rl.free_blocks); |
| 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_rsv = pblk->rl.rb_gc_rsv; |
| 63 | rb_gc_cnt = atomic_read(&pblk->rl.rb_gc_cnt); |
| 64 | rb_budget = pblk->rl.rb_budget; |
| 65 | rb_state = pblk->rl.rb_state; |
| 66 | |
| 67 | total_blocks = geo->blks_per_lun * geo->nr_luns; |
| 68 | |
| 69 | return snprintf(page, PAGE_SIZE, |
| 70 | "u:%u/%u,gc:%u/%u/%u(%u/%u)(stop:<%u,full:>%u,free:%d/%d)-%d\n", |
| 71 | rb_user_cnt, |
| 72 | rb_user_max, |
| 73 | rb_gc_cnt, |
| 74 | rb_gc_max, |
| 75 | rb_gc_rsv, |
| 76 | rb_state, |
| 77 | rb_budget, |
| 78 | pblk->rl.low, |
| 79 | pblk->rl.high, |
| 80 | free_blocks, |
| 81 | total_blocks, |
| 82 | READ_ONCE(pblk->rl.rb_user_active)); |
| 83 | } |
| 84 | |
| 85 | static ssize_t pblk_sysfs_gc_state_show(struct pblk *pblk, char *page) |
| 86 | { |
| 87 | int gc_enabled, gc_active; |
| 88 | |
| 89 | pblk_gc_sysfs_state_show(pblk, &gc_enabled, &gc_active); |
| 90 | return snprintf(page, PAGE_SIZE, "gc_enabled=%d, gc_active=%d\n", |
| 91 | gc_enabled, gc_active); |
| 92 | } |
| 93 | |
| 94 | static ssize_t pblk_sysfs_stats(struct pblk *pblk, char *page) |
| 95 | { |
| 96 | ssize_t sz; |
| 97 | |
| 98 | sz = snprintf(page, PAGE_SIZE, |
| 99 | "read_failed=%lu, read_high_ecc=%lu, read_empty=%lu, read_failed_gc=%lu, write_failed=%lu, erase_failed=%lu\n", |
| 100 | atomic_long_read(&pblk->read_failed), |
| 101 | atomic_long_read(&pblk->read_high_ecc), |
| 102 | atomic_long_read(&pblk->read_empty), |
| 103 | atomic_long_read(&pblk->read_failed_gc), |
| 104 | atomic_long_read(&pblk->write_failed), |
| 105 | atomic_long_read(&pblk->erase_failed)); |
| 106 | |
| 107 | return sz; |
| 108 | } |
| 109 | |
| 110 | static ssize_t pblk_sysfs_write_buffer(struct pblk *pblk, char *page) |
| 111 | { |
| 112 | return pblk_rb_sysfs(&pblk->rwb, page); |
| 113 | } |
| 114 | |
| 115 | static ssize_t pblk_sysfs_ppaf(struct pblk *pblk, char *page) |
| 116 | { |
| 117 | struct nvm_tgt_dev *dev = pblk->dev; |
| 118 | struct nvm_geo *geo = &dev->geo; |
| 119 | ssize_t sz = 0; |
| 120 | |
| 121 | sz = snprintf(page, PAGE_SIZE - sz, |
| 122 | "g:(b:%d)blk:%d/%d,pg:%d/%d,lun:%d/%d,ch:%d/%d,pl:%d/%d,sec:%d/%d\n", |
| 123 | pblk->ppaf_bitsize, |
| 124 | pblk->ppaf.blk_offset, geo->ppaf.blk_len, |
| 125 | pblk->ppaf.pg_offset, geo->ppaf.pg_len, |
| 126 | pblk->ppaf.lun_offset, geo->ppaf.lun_len, |
| 127 | pblk->ppaf.ch_offset, geo->ppaf.ch_len, |
| 128 | pblk->ppaf.pln_offset, geo->ppaf.pln_len, |
| 129 | pblk->ppaf.sec_offset, geo->ppaf.sect_len); |
| 130 | |
| 131 | sz += snprintf(page + sz, PAGE_SIZE - sz, |
| 132 | "d:blk:%d/%d,pg:%d/%d,lun:%d/%d,ch:%d/%d,pl:%d/%d,sec:%d/%d\n", |
| 133 | geo->ppaf.blk_offset, geo->ppaf.blk_len, |
| 134 | geo->ppaf.pg_offset, geo->ppaf.pg_len, |
| 135 | geo->ppaf.lun_offset, geo->ppaf.lun_len, |
| 136 | geo->ppaf.ch_offset, geo->ppaf.ch_len, |
| 137 | geo->ppaf.pln_offset, geo->ppaf.pln_len, |
| 138 | geo->ppaf.sect_offset, geo->ppaf.sect_len); |
| 139 | |
| 140 | return sz; |
| 141 | } |
| 142 | |
| 143 | static ssize_t pblk_sysfs_lines(struct pblk *pblk, char *page) |
| 144 | { |
| 145 | struct nvm_tgt_dev *dev = pblk->dev; |
| 146 | struct nvm_geo *geo = &dev->geo; |
| 147 | struct pblk_line_meta *lm = &pblk->lm; |
| 148 | struct pblk_line_mgmt *l_mg = &pblk->l_mg; |
| 149 | struct pblk_line *line; |
| 150 | ssize_t sz = 0; |
| 151 | int nr_free_lines; |
| 152 | int cur_data, cur_log; |
| 153 | int free_line_cnt = 0, closed_line_cnt = 0; |
| 154 | int d_line_cnt = 0, l_line_cnt = 0; |
| 155 | int gc_full = 0, gc_high = 0, gc_mid = 0, gc_low = 0, gc_empty = 0; |
| 156 | int free = 0, bad = 0, cor = 0; |
| 157 | int msecs = 0, ssecs = 0, cur_sec = 0, vsc = 0, sec_in_line = 0; |
| 158 | int map_weight = 0, meta_weight = 0; |
| 159 | |
| 160 | spin_lock(&l_mg->free_lock); |
| 161 | cur_data = (l_mg->data_line) ? l_mg->data_line->id : -1; |
| 162 | cur_log = (l_mg->log_line) ? l_mg->log_line->id : -1; |
| 163 | nr_free_lines = l_mg->nr_free_lines; |
| 164 | |
| 165 | list_for_each_entry(line, &l_mg->free_list, list) |
| 166 | free_line_cnt++; |
| 167 | spin_unlock(&l_mg->free_lock); |
| 168 | |
| 169 | spin_lock(&l_mg->gc_lock); |
| 170 | list_for_each_entry(line, &l_mg->gc_full_list, list) { |
| 171 | if (line->type == PBLK_LINETYPE_DATA) |
| 172 | d_line_cnt++; |
| 173 | else if (line->type == PBLK_LINETYPE_LOG) |
| 174 | l_line_cnt++; |
| 175 | closed_line_cnt++; |
| 176 | gc_full++; |
| 177 | } |
| 178 | |
| 179 | list_for_each_entry(line, &l_mg->gc_high_list, list) { |
| 180 | if (line->type == PBLK_LINETYPE_DATA) |
| 181 | d_line_cnt++; |
| 182 | else if (line->type == PBLK_LINETYPE_LOG) |
| 183 | l_line_cnt++; |
| 184 | closed_line_cnt++; |
| 185 | gc_high++; |
| 186 | } |
| 187 | |
| 188 | list_for_each_entry(line, &l_mg->gc_mid_list, list) { |
| 189 | if (line->type == PBLK_LINETYPE_DATA) |
| 190 | d_line_cnt++; |
| 191 | else if (line->type == PBLK_LINETYPE_LOG) |
| 192 | l_line_cnt++; |
| 193 | closed_line_cnt++; |
| 194 | gc_mid++; |
| 195 | } |
| 196 | |
| 197 | list_for_each_entry(line, &l_mg->gc_low_list, list) { |
| 198 | if (line->type == PBLK_LINETYPE_DATA) |
| 199 | d_line_cnt++; |
| 200 | else if (line->type == PBLK_LINETYPE_LOG) |
| 201 | l_line_cnt++; |
| 202 | closed_line_cnt++; |
| 203 | gc_low++; |
| 204 | } |
| 205 | |
| 206 | list_for_each_entry(line, &l_mg->gc_empty_list, list) { |
| 207 | if (line->type == PBLK_LINETYPE_DATA) |
| 208 | d_line_cnt++; |
| 209 | else if (line->type == PBLK_LINETYPE_LOG) |
| 210 | l_line_cnt++; |
| 211 | closed_line_cnt++; |
| 212 | gc_empty++; |
| 213 | } |
| 214 | |
| 215 | list_for_each_entry(line, &l_mg->free_list, list) |
| 216 | free++; |
| 217 | list_for_each_entry(line, &l_mg->bad_list, list) |
| 218 | bad++; |
| 219 | list_for_each_entry(line, &l_mg->corrupt_list, list) |
| 220 | cor++; |
| 221 | spin_unlock(&l_mg->gc_lock); |
| 222 | |
| 223 | spin_lock(&l_mg->free_lock); |
| 224 | if (l_mg->data_line) { |
| 225 | cur_sec = l_mg->data_line->cur_sec; |
| 226 | msecs = l_mg->data_line->left_msecs; |
| 227 | ssecs = l_mg->data_line->left_ssecs; |
| 228 | vsc = l_mg->data_line->vsc; |
| 229 | sec_in_line = l_mg->data_line->sec_in_line; |
| 230 | meta_weight = bitmap_weight(&l_mg->meta_bitmap, |
| 231 | PBLK_DATA_LINES); |
| 232 | map_weight = bitmap_weight(l_mg->data_line->map_bitmap, |
| 233 | lm->sec_per_line); |
| 234 | } |
| 235 | spin_unlock(&l_mg->free_lock); |
| 236 | |
| 237 | if (nr_free_lines != free_line_cnt) |
| 238 | pr_err("pblk: corrupted free line list\n"); |
| 239 | |
| 240 | sz = snprintf(page, PAGE_SIZE - sz, |
| 241 | "line: nluns:%d, nblks:%d, nsecs:%d\n", |
| 242 | geo->nr_luns, lm->blk_per_line, lm->sec_per_line); |
| 243 | |
| 244 | sz += snprintf(page + sz, PAGE_SIZE - sz, |
| 245 | "lines:d:%d,l:%d-f:%d(%d),b:%d,co:%d,c:%d(d:%d,l:%d)t:%d\n", |
| 246 | cur_data, cur_log, |
| 247 | free, nr_free_lines, bad, cor, |
| 248 | closed_line_cnt, |
| 249 | d_line_cnt, l_line_cnt, |
| 250 | l_mg->nr_lines); |
| 251 | |
| 252 | sz += snprintf(page + sz, PAGE_SIZE - sz, |
| 253 | "GC: full:%d, high:%d, mid:%d, low:%d, empty:%d, queue:%d\n", |
| 254 | gc_full, gc_high, gc_mid, gc_low, gc_empty, |
| 255 | atomic_read(&pblk->gc.inflight_gc)); |
| 256 | |
| 257 | sz += snprintf(page + sz, PAGE_SIZE - sz, |
| 258 | "data (%d) cur:%d, left:%d/%d, vsc:%d, s:%d, map:%d/%d (%d)\n", |
| 259 | cur_data, cur_sec, msecs, ssecs, vsc, sec_in_line, |
| 260 | map_weight, lm->sec_per_line, meta_weight); |
| 261 | |
| 262 | return sz; |
| 263 | } |
| 264 | |
| 265 | static ssize_t pblk_sysfs_lines_info(struct pblk *pblk, char *page) |
| 266 | { |
| 267 | struct nvm_tgt_dev *dev = pblk->dev; |
| 268 | struct nvm_geo *geo = &dev->geo; |
| 269 | struct pblk_line_meta *lm = &pblk->lm; |
| 270 | ssize_t sz = 0; |
| 271 | |
| 272 | sz = snprintf(page, PAGE_SIZE - sz, |
| 273 | "smeta - len:%d, secs:%d\n", |
| 274 | lm->smeta_len, lm->smeta_sec); |
| 275 | sz += snprintf(page + sz, PAGE_SIZE - sz, |
| 276 | "emeta - len:%d, sec:%d, bb_start:%d\n", |
| 277 | lm->emeta_len, lm->emeta_sec, |
| 278 | lm->emeta_bb); |
| 279 | sz += snprintf(page + sz, PAGE_SIZE - sz, |
| 280 | "bitmap lengths: sec:%d, blk:%d, lun:%d\n", |
| 281 | lm->sec_bitmap_len, |
| 282 | lm->blk_bitmap_len, |
| 283 | lm->lun_bitmap_len); |
| 284 | sz += snprintf(page + sz, PAGE_SIZE - sz, |
| 285 | "blk_line:%d, sec_line:%d, sec_blk:%d\n", |
| 286 | lm->blk_per_line, |
| 287 | lm->sec_per_line, |
| 288 | geo->sec_per_blk); |
| 289 | |
| 290 | return sz; |
| 291 | } |
| 292 | |
Javier González | c2e9f5d | 2017-06-26 11:57:14 +0200 | [diff] [blame] | 293 | static ssize_t pblk_sysfs_get_sec_per_write(struct pblk *pblk, char *page) |
| 294 | { |
| 295 | return snprintf(page, PAGE_SIZE, "%d\n", pblk->sec_per_write); |
| 296 | } |
| 297 | |
Javier González | a4bd217 | 2017-04-15 20:55:50 +0200 | [diff] [blame] | 298 | #ifdef CONFIG_NVM_DEBUG |
| 299 | static ssize_t pblk_sysfs_stats_debug(struct pblk *pblk, char *page) |
| 300 | { |
| 301 | return snprintf(page, PAGE_SIZE, |
Javier González | db7ada3 | 2017-06-26 11:57:13 +0200 | [diff] [blame] | 302 | "%lu\t%lu\t%lu\t%lu\t%lu\t%lu\t%lu\t%lu\t%lu\t%lu\t%lu\t%lu\t%lu\t%lu\n", |
Javier González | a4bd217 | 2017-04-15 20:55:50 +0200 | [diff] [blame] | 303 | atomic_long_read(&pblk->inflight_writes), |
| 304 | atomic_long_read(&pblk->inflight_reads), |
| 305 | atomic_long_read(&pblk->req_writes), |
| 306 | atomic_long_read(&pblk->nr_flush), |
| 307 | atomic_long_read(&pblk->padded_writes), |
| 308 | atomic_long_read(&pblk->padded_wb), |
| 309 | atomic_long_read(&pblk->sub_writes), |
| 310 | atomic_long_read(&pblk->sync_writes), |
| 311 | atomic_long_read(&pblk->compl_writes), |
| 312 | atomic_long_read(&pblk->recov_writes), |
| 313 | atomic_long_read(&pblk->recov_gc_writes), |
| 314 | atomic_long_read(&pblk->recov_gc_reads), |
Javier González | db7ada3 | 2017-06-26 11:57:13 +0200 | [diff] [blame] | 315 | atomic_long_read(&pblk->cache_reads), |
Javier González | a4bd217 | 2017-04-15 20:55:50 +0200 | [diff] [blame] | 316 | atomic_long_read(&pblk->sync_reads)); |
| 317 | } |
| 318 | #endif |
| 319 | |
| 320 | static ssize_t pblk_sysfs_rate_store(struct pblk *pblk, const char *page, |
| 321 | size_t len) |
| 322 | { |
| 323 | struct pblk_gc *gc = &pblk->gc; |
| 324 | size_t c_len; |
| 325 | int value; |
| 326 | |
| 327 | c_len = strcspn(page, "\n"); |
| 328 | if (c_len >= len) |
| 329 | return -EINVAL; |
| 330 | |
| 331 | if (kstrtouint(page, 0, &value)) |
| 332 | return -EINVAL; |
| 333 | |
| 334 | spin_lock(&gc->lock); |
| 335 | pblk_rl_set_gc_rsc(&pblk->rl, value); |
| 336 | spin_unlock(&gc->lock); |
| 337 | |
| 338 | return len; |
| 339 | } |
| 340 | |
| 341 | static ssize_t pblk_sysfs_gc_force(struct pblk *pblk, const char *page, |
| 342 | size_t len) |
| 343 | { |
| 344 | size_t c_len; |
| 345 | int force; |
| 346 | |
| 347 | c_len = strcspn(page, "\n"); |
| 348 | if (c_len >= len) |
| 349 | return -EINVAL; |
| 350 | |
| 351 | if (kstrtouint(page, 0, &force)) |
| 352 | return -EINVAL; |
| 353 | |
| 354 | if (force < 0 || force > 1) |
| 355 | return -EINVAL; |
| 356 | |
| 357 | pblk_gc_sysfs_force(pblk, force); |
| 358 | |
| 359 | return len; |
| 360 | } |
| 361 | |
Javier González | c2e9f5d | 2017-06-26 11:57:14 +0200 | [diff] [blame] | 362 | static ssize_t pblk_sysfs_set_sec_per_write(struct pblk *pblk, |
| 363 | const char *page, size_t len) |
| 364 | { |
| 365 | size_t c_len; |
| 366 | int sec_per_write; |
| 367 | |
| 368 | c_len = strcspn(page, "\n"); |
| 369 | if (c_len >= len) |
| 370 | return -EINVAL; |
| 371 | |
| 372 | if (kstrtouint(page, 0, &sec_per_write)) |
| 373 | return -EINVAL; |
| 374 | |
| 375 | if (sec_per_write < pblk->min_write_pgs |
| 376 | || sec_per_write > pblk->max_write_pgs |
| 377 | || sec_per_write % pblk->min_write_pgs != 0) |
| 378 | return -EINVAL; |
| 379 | |
| 380 | pblk_set_sec_per_write(pblk, sec_per_write); |
| 381 | |
| 382 | return len; |
| 383 | } |
| 384 | |
Javier González | a4bd217 | 2017-04-15 20:55:50 +0200 | [diff] [blame] | 385 | static struct attribute sys_write_luns = { |
| 386 | .name = "write_luns", |
| 387 | .mode = 0444, |
| 388 | }; |
| 389 | |
| 390 | static struct attribute sys_rate_limiter_attr = { |
| 391 | .name = "rate_limiter", |
| 392 | .mode = 0444, |
| 393 | }; |
| 394 | |
| 395 | static struct attribute sys_gc_state = { |
| 396 | .name = "gc_state", |
| 397 | .mode = 0444, |
| 398 | }; |
| 399 | |
| 400 | static struct attribute sys_errors_attr = { |
| 401 | .name = "errors", |
| 402 | .mode = 0444, |
| 403 | }; |
| 404 | |
| 405 | static struct attribute sys_rb_attr = { |
| 406 | .name = "write_buffer", |
| 407 | .mode = 0444, |
| 408 | }; |
| 409 | |
| 410 | static struct attribute sys_stats_ppaf_attr = { |
| 411 | .name = "ppa_format", |
| 412 | .mode = 0444, |
| 413 | }; |
| 414 | |
| 415 | static struct attribute sys_lines_attr = { |
| 416 | .name = "lines", |
| 417 | .mode = 0444, |
| 418 | }; |
| 419 | |
| 420 | static struct attribute sys_lines_info_attr = { |
| 421 | .name = "lines_info", |
| 422 | .mode = 0444, |
| 423 | }; |
| 424 | |
| 425 | static struct attribute sys_gc_force = { |
| 426 | .name = "gc_force", |
| 427 | .mode = 0200, |
| 428 | }; |
| 429 | |
Javier González | c2e9f5d | 2017-06-26 11:57:14 +0200 | [diff] [blame] | 430 | static struct attribute sys_max_sec_per_write = { |
| 431 | .name = "max_sec_per_write", |
| 432 | .mode = 0644, |
| 433 | }; |
| 434 | |
Javier González | a4bd217 | 2017-04-15 20:55:50 +0200 | [diff] [blame] | 435 | static struct attribute sys_gc_rl_max = { |
| 436 | .name = "gc_rl_max", |
| 437 | .mode = 0200, |
| 438 | }; |
| 439 | |
| 440 | #ifdef CONFIG_NVM_DEBUG |
| 441 | static struct attribute sys_stats_debug_attr = { |
| 442 | .name = "stats", |
| 443 | .mode = 0444, |
| 444 | }; |
| 445 | #endif |
| 446 | |
| 447 | static struct attribute *pblk_attrs[] = { |
| 448 | &sys_write_luns, |
| 449 | &sys_rate_limiter_attr, |
| 450 | &sys_errors_attr, |
| 451 | &sys_gc_state, |
| 452 | &sys_gc_force, |
Javier González | c2e9f5d | 2017-06-26 11:57:14 +0200 | [diff] [blame] | 453 | &sys_max_sec_per_write, |
Javier González | a4bd217 | 2017-04-15 20:55:50 +0200 | [diff] [blame] | 454 | &sys_gc_rl_max, |
| 455 | &sys_rb_attr, |
| 456 | &sys_stats_ppaf_attr, |
| 457 | &sys_lines_attr, |
| 458 | &sys_lines_info_attr, |
| 459 | #ifdef CONFIG_NVM_DEBUG |
| 460 | &sys_stats_debug_attr, |
| 461 | #endif |
| 462 | NULL, |
| 463 | }; |
| 464 | |
| 465 | static ssize_t pblk_sysfs_show(struct kobject *kobj, struct attribute *attr, |
| 466 | char *buf) |
| 467 | { |
| 468 | struct pblk *pblk = container_of(kobj, struct pblk, kobj); |
| 469 | |
| 470 | if (strcmp(attr->name, "rate_limiter") == 0) |
| 471 | return pblk_sysfs_rate_limiter(pblk, buf); |
| 472 | else if (strcmp(attr->name, "write_luns") == 0) |
| 473 | return pblk_sysfs_luns_show(pblk, buf); |
| 474 | else if (strcmp(attr->name, "gc_state") == 0) |
| 475 | return pblk_sysfs_gc_state_show(pblk, buf); |
| 476 | else if (strcmp(attr->name, "errors") == 0) |
| 477 | return pblk_sysfs_stats(pblk, buf); |
| 478 | else if (strcmp(attr->name, "write_buffer") == 0) |
| 479 | return pblk_sysfs_write_buffer(pblk, buf); |
| 480 | else if (strcmp(attr->name, "ppa_format") == 0) |
| 481 | return pblk_sysfs_ppaf(pblk, buf); |
| 482 | else if (strcmp(attr->name, "lines") == 0) |
| 483 | return pblk_sysfs_lines(pblk, buf); |
| 484 | else if (strcmp(attr->name, "lines_info") == 0) |
| 485 | return pblk_sysfs_lines_info(pblk, buf); |
Javier González | c2e9f5d | 2017-06-26 11:57:14 +0200 | [diff] [blame] | 486 | else if (strcmp(attr->name, "max_sec_per_write") == 0) |
| 487 | return pblk_sysfs_get_sec_per_write(pblk, buf); |
Javier González | a4bd217 | 2017-04-15 20:55:50 +0200 | [diff] [blame] | 488 | #ifdef CONFIG_NVM_DEBUG |
| 489 | else if (strcmp(attr->name, "stats") == 0) |
| 490 | return pblk_sysfs_stats_debug(pblk, buf); |
| 491 | #endif |
| 492 | return 0; |
| 493 | } |
| 494 | |
| 495 | static ssize_t pblk_sysfs_store(struct kobject *kobj, struct attribute *attr, |
| 496 | const char *buf, size_t len) |
| 497 | { |
| 498 | struct pblk *pblk = container_of(kobj, struct pblk, kobj); |
| 499 | |
| 500 | if (strcmp(attr->name, "gc_rl_max") == 0) |
| 501 | return pblk_sysfs_rate_store(pblk, buf, len); |
| 502 | else if (strcmp(attr->name, "gc_force") == 0) |
| 503 | return pblk_sysfs_gc_force(pblk, buf, len); |
Javier González | c2e9f5d | 2017-06-26 11:57:14 +0200 | [diff] [blame] | 504 | else if (strcmp(attr->name, "max_sec_per_write") == 0) |
| 505 | return pblk_sysfs_set_sec_per_write(pblk, buf, len); |
Javier González | a4bd217 | 2017-04-15 20:55:50 +0200 | [diff] [blame] | 506 | |
| 507 | return 0; |
| 508 | } |
| 509 | |
| 510 | static const struct sysfs_ops pblk_sysfs_ops = { |
| 511 | .show = pblk_sysfs_show, |
| 512 | .store = pblk_sysfs_store, |
| 513 | }; |
| 514 | |
| 515 | static struct kobj_type pblk_ktype = { |
| 516 | .sysfs_ops = &pblk_sysfs_ops, |
| 517 | .default_attrs = pblk_attrs, |
| 518 | }; |
| 519 | |
| 520 | int pblk_sysfs_init(struct gendisk *tdisk) |
| 521 | { |
| 522 | struct pblk *pblk = tdisk->private_data; |
| 523 | struct device *parent_dev = disk_to_dev(pblk->disk); |
| 524 | int ret; |
| 525 | |
| 526 | ret = kobject_init_and_add(&pblk->kobj, &pblk_ktype, |
| 527 | kobject_get(&parent_dev->kobj), |
| 528 | "%s", "pblk"); |
| 529 | if (ret) { |
| 530 | pr_err("pblk: could not register %s/pblk\n", |
| 531 | tdisk->disk_name); |
| 532 | return ret; |
| 533 | } |
| 534 | |
| 535 | kobject_uevent(&pblk->kobj, KOBJ_ADD); |
| 536 | return 0; |
| 537 | } |
| 538 | |
| 539 | void pblk_sysfs_exit(struct gendisk *tdisk) |
| 540 | { |
| 541 | struct pblk *pblk = tdisk->private_data; |
| 542 | |
| 543 | kobject_uevent(&pblk->kobj, KOBJ_REMOVE); |
| 544 | kobject_del(&pblk->kobj); |
| 545 | kobject_put(&pblk->kobj); |
| 546 | } |