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 
pblk_sysfs_luns_show(struct pblk * pblk,char * page)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->all_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.a.ch,
43 					rlun->bppa.a.lun,
44 					active);
45 	}
46 
47 	return sz;
48 }
49 
pblk_sysfs_rate_limiter(struct pblk * pblk,char * page)50 static ssize_t pblk_sysfs_rate_limiter(struct pblk *pblk, char *page)
51 {
52 	int free_blocks, free_user_blocks, total_blocks;
53 	int rb_user_max, rb_user_cnt;
54 	int rb_gc_max, rb_gc_cnt, rb_budget, rb_state;
55 
56 	free_blocks = pblk_rl_nr_free_blks(&pblk->rl);
57 	free_user_blocks = pblk_rl_nr_user_free_blks(&pblk->rl);
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;
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 
65 	total_blocks = pblk->rl.total_blocks;
66 
67 	return snprintf(page, PAGE_SIZE,
68 		"u:%u/%u,gc:%u/%u(%u)(stop:<%u,full:>%u,free:%d/%d/%d)-%d\n",
69 				rb_user_cnt,
70 				rb_user_max,
71 				rb_gc_cnt,
72 				rb_gc_max,
73 				rb_state,
74 				rb_budget,
75 				pblk->rl.high,
76 				free_blocks,
77 				free_user_blocks,
78 				total_blocks,
79 				READ_ONCE(pblk->rl.rb_user_active));
80 }
81 
pblk_sysfs_gc_state_show(struct pblk * pblk,char * page)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 
pblk_sysfs_stats(struct pblk * pblk,char * page)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 
pblk_sysfs_write_buffer(struct pblk * pblk,char * page)107 static ssize_t pblk_sysfs_write_buffer(struct pblk *pblk, char *page)
108 {
109 	return pblk_rb_sysfs(&pblk->rwb, page);
110 }
111 
pblk_sysfs_ppaf(struct pblk * pblk,char * page)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 
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;
121 
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",
124 			pblk->addrf_len,
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,
130 			ppaf->sec_offset, ppaf->sec_len);
131 
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 	}
159 
160 	return sz;
161 }
162 
pblk_sysfs_lines(struct pblk * pblk,char * page)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;
173 	int free_line_cnt = 0, closed_line_cnt = 0, emeta_line_cnt = 0;
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;
176 	int gc_werr = 0;
177 
178 	int bad = 0, cor = 0;
179 	int msecs = 0, cur_sec = 0, vsc = 0, sec_in_line = 0;
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 
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 
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 
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 
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;
261 		vsc = le32_to_cpu(*l_mg->data_line->vsc);
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)
271 		pblk_err(pblk, "corrupted free line list:%d/%d\n",
272 						nr_free_lines, free_line_cnt);
273 
274 	sz = snprintf(page, PAGE_SIZE - sz,
275 		"line: nluns:%d, nblks:%d, nsecs:%d\n",
276 		geo->all_luns, lm->blk_per_line, lm->sec_per_line);
277 
278 	sz += snprintf(page + sz, PAGE_SIZE - sz,
279 		"lines:d:%d,l:%d-f:%d,m:%d/%d,c:%d,b:%d,co:%d(d:%d,l:%d)t:%d\n",
280 					cur_data, cur_log,
281 					nr_free_lines,
282 					emeta_line_cnt, meta_weight,
283 					closed_line_cnt,
284 					bad, cor,
285 					d_line_cnt, l_line_cnt,
286 					l_mg->nr_lines);
287 
288 	sz += snprintf(page + sz, PAGE_SIZE - sz,
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,
291 			atomic_read(&pblk->gc.read_inflight_gc));
292 
293 	sz += snprintf(page + sz, PAGE_SIZE - sz,
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,
296 			map_weight, lm->sec_per_line,
297 			atomic_read(&pblk->inflight_io));
298 
299 	return sz;
300 }
301 
pblk_sysfs_lines_info(struct pblk * pblk,char * page)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",
314 					lm->emeta_len[0], lm->emeta_sec[0],
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,
325 					geo->clba);
326 
327 	return sz;
328 }
329 
pblk_sysfs_get_sec_per_write(struct pblk * pblk,char * page)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 
pblk_get_write_amp(u64 user,u64 gc,u64 pad,char * page)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 
pblk_sysfs_get_write_amp_mileage(struct pblk * pblk,char * page)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 
pblk_sysfs_get_write_amp_trip(struct pblk * pblk,char * page)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 
bucket_percentage(unsigned long long bucket,unsigned long long total)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 
pblk_sysfs_get_padding_dist(struct pblk * pblk,char * page)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 
424 #ifdef CONFIG_NVM_PBLK_DEBUG
pblk_sysfs_stats_debug(struct pblk * pblk,char * page)425 static ssize_t pblk_sysfs_stats_debug(struct pblk *pblk, char *page)
426 {
427 	return snprintf(page, PAGE_SIZE,
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",
429 			atomic_long_read(&pblk->inflight_writes),
430 			atomic_long_read(&pblk->inflight_reads),
431 			atomic_long_read(&pblk->req_writes),
432 			(u64)atomic64_read(&pblk->nr_flush),
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),
437 			atomic_long_read(&pblk->recov_writes),
438 			atomic_long_read(&pblk->recov_gc_writes),
439 			atomic_long_read(&pblk->recov_gc_reads),
440 			atomic_long_read(&pblk->cache_reads),
441 			atomic_long_read(&pblk->sync_reads));
442 }
443 #endif
444 
pblk_sysfs_gc_force(struct pblk * pblk,const char * page,size_t len)445 static ssize_t pblk_sysfs_gc_force(struct pblk *pblk, const char *page,
446 				   size_t len)
447 {
448 	size_t c_len;
449 	int force;
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 
458 	pblk_gc_sysfs_force(pblk, force);
459 
460 	return len;
461 }
462 
pblk_sysfs_set_sec_per_write(struct pblk * pblk,const char * page,size_t len)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 
pblk_sysfs_set_write_amp_trip(struct pblk * pblk,const char * page,size_t len)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 
pblk_sysfs_set_padding_dist(struct pblk * pblk,const char * page,size_t len)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 
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 
581 static struct attribute sys_max_sec_per_write = {
582 	.name = "max_sec_per_write",
583 	.mode = 0644,
584 };
585 
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 
596 static struct attribute sys_padding_dist = {
597 	.name = "padding_dist",
598 	.mode = 0644,
599 };
600 
601 #ifdef CONFIG_NVM_PBLK_DEBUG
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,
614 	&sys_max_sec_per_write,
615 	&sys_rb_attr,
616 	&sys_stats_ppaf_attr,
617 	&sys_lines_attr,
618 	&sys_lines_info_attr,
619 	&sys_write_amp_mileage,
620 	&sys_write_amp_trip,
621 	&sys_padding_dist,
622 #ifdef CONFIG_NVM_PBLK_DEBUG
623 	&sys_stats_debug_attr,
624 #endif
625 	NULL,
626 };
627 
pblk_sysfs_show(struct kobject * kobj,struct attribute * attr,char * buf)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);
649 	else if (strcmp(attr->name, "max_sec_per_write") == 0)
650 		return pblk_sysfs_get_sec_per_write(pblk, buf);
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);
655 	else if (strcmp(attr->name, "padding_dist") == 0)
656 		return pblk_sysfs_get_padding_dist(pblk, buf);
657 #ifdef CONFIG_NVM_PBLK_DEBUG
658 	else if (strcmp(attr->name, "stats") == 0)
659 		return pblk_sysfs_stats_debug(pblk, buf);
660 #endif
661 	return 0;
662 }
663 
pblk_sysfs_store(struct kobject * kobj,struct attribute * attr,const char * buf,size_t len)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 
669 	if (strcmp(attr->name, "gc_force") == 0)
670 		return pblk_sysfs_gc_force(pblk, buf, len);
671 	else if (strcmp(attr->name, "max_sec_per_write") == 0)
672 		return pblk_sysfs_set_sec_per_write(pblk, buf, len);
673 	else if (strcmp(attr->name, "write_amp_trip") == 0)
674 		return pblk_sysfs_set_write_amp_trip(pblk, buf, len);
675 	else if (strcmp(attr->name, "padding_dist") == 0)
676 		return pblk_sysfs_set_padding_dist(pblk, buf, len);
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 
pblk_sysfs_init(struct gendisk * tdisk)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) {
700 		pblk_err(pblk, "could not register\n");
701 		return ret;
702 	}
703 
704 	kobject_uevent(&pblk->kobj, KOBJ_ADD);
705 	return 0;
706 }
707 
pblk_sysfs_exit(struct gendisk * tdisk)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 }
716