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