projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
lightnvm: propagate right error code to target
[linux-2.6-block.git] / drivers / lightnvm / pblk-recovery.c
CommitLineData
a4bd217b
JG		 1/*
2 * Copyright (C) 2016 CNEX Labs
3 * Initial: Javier Gonzalez <javier@cnexlabs.com>
4 *
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License version
7 * 2 as published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it will be useful, but
10 * WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * General Public License for more details.
13 *
14 * pblk-recovery.c - pblk's recovery path
15 */
16
17#include "pblk.h"
18
19void pblk_submit_rec(struct work_struct *work)
20{
21 struct pblk_rec_ctx *recovery =
22 container_of(work, struct pblk_rec_ctx, ws_rec);
23 struct pblk *pblk = recovery->pblk;
24 struct nvm_tgt_dev *dev = pblk->dev;
25 struct nvm_rq *rqd = recovery->rqd;
26 struct pblk_c_ctx *c_ctx = nvm_rq_to_pdu(rqd);
27 int max_secs = nvm_max_phys_sects(dev);
28 struct bio *bio;
29 unsigned int nr_rec_secs;
30 unsigned int pgs_read;
31 int ret;
32
33 nr_rec_secs = bitmap_weight((unsigned long int *)&rqd->ppa_status,
34 max_secs);
35
36 bio = bio_alloc(GFP_KERNEL, nr_rec_secs);
37 if (!bio) {
38 pr_err("pblk: not able to create recovery bio\n");
39 return;
40 }
41
42 bio->bi_iter.bi_sector = 0;
43 bio_set_op_attrs(bio, REQ_OP_WRITE, 0);
44 rqd->bio = bio;
45 rqd->nr_ppas = nr_rec_secs;
46
47 pgs_read = pblk_rb_read_to_bio_list(&pblk->rwb, bio, &recovery->failed,
48 nr_rec_secs);
49 if (pgs_read != nr_rec_secs) {
50 pr_err("pblk: could not read recovery entries\n");
51 goto err;
52 }
53
54 if (pblk_setup_w_rec_rq(pblk, rqd, c_ctx)) {
55 pr_err("pblk: could not setup recovery request\n");
56 goto err;
57 }
58
59#ifdef CONFIG_NVM_DEBUG
60 atomic_long_add(nr_rec_secs, &pblk->recov_writes);
61#endif
62
63 ret = pblk_submit_io(pblk, rqd);
64 if (ret) {
65 pr_err("pblk: I/O submission failed: %d\n", ret);
66 goto err;
67 }
68
69 mempool_free(recovery, pblk->rec_pool);
70 return;
71
72err:
73 bio_put(bio);
74 pblk_free_rqd(pblk, rqd, WRITE);
75}
76
77int pblk_recov_setup_rq(struct pblk *pblk, struct pblk_c_ctx *c_ctx,
78 struct pblk_rec_ctx *recovery, u64 *comp_bits,
79 unsigned int comp)
80{
81 struct nvm_tgt_dev *dev = pblk->dev;
82 int max_secs = nvm_max_phys_sects(dev);
83 struct nvm_rq *rec_rqd;
84 struct pblk_c_ctx *rec_ctx;
85 int nr_entries = c_ctx->nr_valid + c_ctx->nr_padded;
86
87 rec_rqd = pblk_alloc_rqd(pblk, WRITE);
88 if (IS_ERR(rec_rqd)) {
89 pr_err("pblk: could not create recovery req.\n");
90 return -ENOMEM;
91 }
92
93 rec_ctx = nvm_rq_to_pdu(rec_rqd);
94
95 /* Copy completion bitmap, but exclude the first X completed entries */
96 bitmap_shift_right((unsigned long int *)&rec_rqd->ppa_status,
97 (unsigned long int *)comp_bits,
98 comp, max_secs);
99
100 /* Save the context for the entries that need to be re-written and
101 * update current context with the completed entries.
102 */
103 rec_ctx->sentry = pblk_rb_wrap_pos(&pblk->rwb, c_ctx->sentry + comp);
104 if (comp >= c_ctx->nr_valid) {
105 rec_ctx->nr_valid = 0;
106 rec_ctx->nr_padded = nr_entries - comp;
107
108 c_ctx->nr_padded = comp - c_ctx->nr_valid;
109 } else {
110 rec_ctx->nr_valid = c_ctx->nr_valid - comp;
111 rec_ctx->nr_padded = c_ctx->nr_padded;
112
113 c_ctx->nr_valid = comp;
114 c_ctx->nr_padded = 0;
115 }
116
117 recovery->rqd = rec_rqd;
118 recovery->pblk = pblk;
119
120 return 0;
121}
122
123__le64 *pblk_recov_get_lba_list(struct pblk *pblk, struct line_emeta *emeta)
124{
125 u32 crc;
126
127 crc = pblk_calc_emeta_crc(pblk, emeta);
128 if (le32_to_cpu(emeta->crc) != crc)
129 return NULL;
130
131 if (le32_to_cpu(emeta->header.identifier) != PBLK_MAGIC)
132 return NULL;
133
134 return pblk_line_emeta_to_lbas(emeta);
135}
136
137static int pblk_recov_l2p_from_emeta(struct pblk *pblk, struct pblk_line *line)
138{
139 struct nvm_tgt_dev *dev = pblk->dev;
140 struct nvm_geo *geo = &dev->geo;
141 struct pblk_line_meta *lm = &pblk->lm;
142 struct line_emeta *emeta = line->emeta;
143 __le64 *lba_list;
144 int data_start;
145 int nr_data_lbas, nr_valid_lbas, nr_lbas = 0;
146 int i;
147
148 lba_list = pblk_recov_get_lba_list(pblk, emeta);
149 if (!lba_list)
150 return 1;
151
152 data_start = pblk_line_smeta_start(pblk, line) + lm->smeta_sec;
153 nr_data_lbas = lm->sec_per_line - lm->emeta_sec;
154 nr_valid_lbas = le64_to_cpu(emeta->nr_valid_lbas);
155
156 for (i = data_start; i < nr_data_lbas && nr_lbas < nr_valid_lbas; i++) {
157 struct ppa_addr ppa;
158 int pos;
159
160 ppa = addr_to_pblk_ppa(pblk, i, line->id);
161 pos = pblk_ppa_to_pos(geo, ppa);
162
163 /* Do not update bad blocks */
164 if (test_bit(pos, line->blk_bitmap))
165 continue;
166
167 if (le64_to_cpu(lba_list[i]) == ADDR_EMPTY) {
168 spin_lock(&line->lock);
169 if (test_and_set_bit(i, line->invalid_bitmap))
2a79efd8 170 WARN_ONCE(1, "pblk: rec. double invalidate:\n");
a4bd217b
JG		 171 else
172 line->vsc--;
173 spin_unlock(&line->lock);
174
175 continue;
176 }
177
178 pblk_update_map(pblk, le64_to_cpu(lba_list[i]), ppa);
179 nr_lbas++;
180 }
181
182 if (nr_valid_lbas != nr_lbas)
183 pr_err("pblk: line %d - inconsistent lba list(%llu/%d)\n",
184 line->id, line->emeta->nr_valid_lbas, nr_lbas);
185
186 line->left_msecs = 0;
187
188 return 0;
189}
190
191static int pblk_calc_sec_in_line(struct pblk *pblk, struct pblk_line *line)
192{
193 struct nvm_tgt_dev *dev = pblk->dev;
194 struct nvm_geo *geo = &dev->geo;
195 struct pblk_line_meta *lm = &pblk->lm;
196 int nr_bb = bitmap_weight(line->blk_bitmap, lm->blk_per_line);
197
198 return lm->sec_per_line - lm->smeta_sec - lm->emeta_sec -
199 nr_bb * geo->sec_per_blk;
200}
201
202struct pblk_recov_alloc {
203 struct ppa_addr *ppa_list;
204 struct pblk_sec_meta *meta_list;
205 struct nvm_rq *rqd;
206 void *data;
207 dma_addr_t dma_ppa_list;
208 dma_addr_t dma_meta_list;
209};
210
211static int pblk_recov_read_oob(struct pblk *pblk, struct pblk_line *line,
212 struct pblk_recov_alloc p, u64 r_ptr)
213{
214 struct nvm_tgt_dev *dev = pblk->dev;
215 struct nvm_geo *geo = &dev->geo;
216 struct ppa_addr *ppa_list;
217 struct pblk_sec_meta *meta_list;
218 struct nvm_rq *rqd;
219 struct bio *bio;
220 void *data;
221 dma_addr_t dma_ppa_list, dma_meta_list;
222 u64 r_ptr_int;
223 int left_ppas;
224 int rq_ppas, rq_len;
225 int i, j;
226 int ret = 0;
227 DECLARE_COMPLETION_ONSTACK(wait);
228
229 ppa_list = p.ppa_list;
230 meta_list = p.meta_list;
231 rqd = p.rqd;
232 data = p.data;
233 dma_ppa_list = p.dma_ppa_list;
234 dma_meta_list = p.dma_meta_list;
235
236 left_ppas = line->cur_sec - r_ptr;
237 if (!left_ppas)
238 return 0;
239
240 r_ptr_int = r_ptr;
241
242next_read_rq:
243 memset(rqd, 0, pblk_r_rq_size);
244
245 rq_ppas = pblk_calc_secs(pblk, left_ppas, 0);
246 if (!rq_ppas)
247 rq_ppas = pblk->min_write_pgs;
248 rq_len = rq_ppas * geo->sec_size;
249
250 bio = bio_map_kern(dev->q, data, rq_len, GFP_KERNEL);
251 if (IS_ERR(bio))
252 return PTR_ERR(bio);
253
254 bio->bi_iter.bi_sector = 0; /* internal bio */
255 bio_set_op_attrs(bio, REQ_OP_READ, 0);
256
257 rqd->bio = bio;
258 rqd->opcode = NVM_OP_PREAD;
259 rqd->flags = pblk_set_read_mode(pblk);
260 rqd->meta_list = meta_list;
261 rqd->nr_ppas = rq_ppas;
262 rqd->ppa_list = ppa_list;
263 rqd->dma_ppa_list = dma_ppa_list;
264 rqd->dma_meta_list = dma_meta_list;
265 rqd->end_io = pblk_end_io_sync;
266 rqd->private = &wait;
267
268 for (i = 0; i < rqd->nr_ppas; ) {
269 struct ppa_addr ppa;
270 int pos;
271
272 ppa = addr_to_gen_ppa(pblk, r_ptr_int, line->id);
273 pos = pblk_dev_ppa_to_pos(geo, ppa);
274
275 while (test_bit(pos, line->blk_bitmap)) {
276 r_ptr_int += pblk->min_write_pgs;
277 ppa = addr_to_gen_ppa(pblk, r_ptr_int, line->id);
278 pos = pblk_dev_ppa_to_pos(geo, ppa);
279 }
280
281 for (j = 0; j < pblk->min_write_pgs; j++, i++, r_ptr_int++)
282 rqd->ppa_list[i] =
283 addr_to_gen_ppa(pblk, r_ptr_int, line->id);
284 }
285
286 /* If read fails, more padding is needed */
287 ret = pblk_submit_io(pblk, rqd);
288 if (ret) {
289 pr_err("pblk: I/O submission failed: %d\n", ret);
290 return ret;
291 }
292
293 if (!wait_for_completion_io_timeout(&wait,
294 msecs_to_jiffies(PBLK_COMMAND_TIMEOUT_MS))) {
295 pr_err("pblk: L2P recovery read timed out\n");
296 return -EINTR;
297 }
298
299 reinit_completion(&wait);
300
301 /* At this point, the read should not fail. If it does, it is a problem
302 * we cannot recover from here. Need FTL log.
303 */
304 if (rqd->error) {
305 pr_err("pblk: L2P recovery failed (%d)\n", rqd->error);
306 return -EINTR;
307 }
308
309 for (i = 0; i < rqd->nr_ppas; i++) {
310 u64 lba = le64_to_cpu(meta_list[i].lba);
311
312 if (lba == ADDR_EMPTY || lba > pblk->rl.nr_secs)
313 continue;
314
315 pblk_update_map(pblk, lba, rqd->ppa_list[i]);
316 }
317
318 left_ppas -= rq_ppas;
319 if (left_ppas > 0)
320 goto next_read_rq;
321
322 return 0;
323}
324
325static int pblk_recov_pad_oob(struct pblk *pblk, struct pblk_line *line,
326 struct pblk_recov_alloc p, int left_ppas)
327{
328 struct nvm_tgt_dev *dev = pblk->dev;
329 struct nvm_geo *geo = &dev->geo;
330 struct ppa_addr *ppa_list;
331 struct pblk_sec_meta *meta_list;
332 struct nvm_rq *rqd;
333 struct bio *bio;
334 void *data;
335 dma_addr_t dma_ppa_list, dma_meta_list;
336 __le64 *lba_list = pblk_line_emeta_to_lbas(line->emeta);
337 u64 w_ptr = line->cur_sec;
338 int left_line_ppas = line->left_msecs;
339 int rq_ppas, rq_len;
340 int i, j;
341 int ret = 0;
342 DECLARE_COMPLETION_ONSTACK(wait);
343
344 ppa_list = p.ppa_list;
345 meta_list = p.meta_list;
346 rqd = p.rqd;
347 data = p.data;
348 dma_ppa_list = p.dma_ppa_list;
349 dma_meta_list = p.dma_meta_list;
350
351next_pad_rq:
352 rq_ppas = pblk_calc_secs(pblk, left_ppas, 0);
353 if (!rq_ppas)
354 rq_ppas = pblk->min_write_pgs;
355 rq_len = rq_ppas * geo->sec_size;
356
357 bio = bio_map_kern(dev->q, data, rq_len, GFP_KERNEL);
358 if (IS_ERR(bio))
359 return PTR_ERR(bio);
360
361 bio->bi_iter.bi_sector = 0; /* internal bio */
362 bio_set_op_attrs(bio, REQ_OP_WRITE, 0);
363
364 memset(rqd, 0, pblk_r_rq_size);
365
366 rqd->bio = bio;
367 rqd->opcode = NVM_OP_PWRITE;
368 rqd->flags = pblk_set_progr_mode(pblk, WRITE);
369 rqd->meta_list = meta_list;
370 rqd->nr_ppas = rq_ppas;
371 rqd->ppa_list = ppa_list;
372 rqd->dma_ppa_list = dma_ppa_list;
373 rqd->dma_meta_list = dma_meta_list;
374 rqd->end_io = pblk_end_io_sync;
375 rqd->private = &wait;
376
377 for (i = 0; i < rqd->nr_ppas; ) {
378 struct ppa_addr ppa;
379 int pos;
380
381 w_ptr = pblk_alloc_page(pblk, line, pblk->min_write_pgs);
382 ppa = addr_to_pblk_ppa(pblk, w_ptr, line->id);
383 pos = pblk_ppa_to_pos(geo, ppa);
384
385 while (test_bit(pos, line->blk_bitmap)) {
386 w_ptr += pblk->min_write_pgs;
387 ppa = addr_to_pblk_ppa(pblk, w_ptr, line->id);
388 pos = pblk_ppa_to_pos(geo, ppa);
389 }
390
391 for (j = 0; j < pblk->min_write_pgs; j++, i++, w_ptr++) {
392 struct ppa_addr dev_ppa;
393
394 dev_ppa = addr_to_gen_ppa(pblk, w_ptr, line->id);
395
396 pblk_map_invalidate(pblk, dev_ppa);
397 meta_list[i].lba = cpu_to_le64(ADDR_EMPTY);
398 lba_list[w_ptr] = cpu_to_le64(ADDR_EMPTY);
399 rqd->ppa_list[i] = dev_ppa;
400 }
401 }
402
403 ret = pblk_submit_io(pblk, rqd);
404 if (ret) {
405 pr_err("pblk: I/O submission failed: %d\n", ret);
406 return ret;
407 }
408
409 if (!wait_for_completion_io_timeout(&wait,
410 msecs_to_jiffies(PBLK_COMMAND_TIMEOUT_MS))) {
411 pr_err("pblk: L2P recovery write timed out\n");
412 }
413 reinit_completion(&wait);
414
415 left_line_ppas -= rq_ppas;
416 left_ppas -= rq_ppas;
417 if (left_ppas > 0 && left_line_ppas)
418 goto next_pad_rq;
419
420 return 0;
421}
422
423/* When this function is called, it means that not all upper pages have been
424 * written in a page that contains valid data. In order to recover this data, we
425 * first find the write pointer on the device, then we pad all necessary
426 * sectors, and finally attempt to read the valid data
427 */
428static int pblk_recov_scan_all_oob(struct pblk *pblk, struct pblk_line *line,
429 struct pblk_recov_alloc p)
430{
431 struct nvm_tgt_dev *dev = pblk->dev;
432 struct nvm_geo *geo = &dev->geo;
433 struct ppa_addr *ppa_list;
434 struct pblk_sec_meta *meta_list;
435 struct nvm_rq *rqd;
436 struct bio *bio;
437 void *data;
438 dma_addr_t dma_ppa_list, dma_meta_list;
439 u64 w_ptr = 0, r_ptr;
440 int rq_ppas, rq_len;
441 int i, j;
442 int ret = 0;
443 int rec_round;
444 int left_ppas = pblk_calc_sec_in_line(pblk, line) - line->cur_sec;
445 DECLARE_COMPLETION_ONSTACK(wait);
446
447 ppa_list = p.ppa_list;
448 meta_list = p.meta_list;
449 rqd = p.rqd;
450 data = p.data;
451 dma_ppa_list = p.dma_ppa_list;
452 dma_meta_list = p.dma_meta_list;
453
454 /* we could recover up until the line write pointer */
455 r_ptr = line->cur_sec;
456 rec_round = 0;
457
458next_rq:
459 memset(rqd, 0, pblk_r_rq_size);
460
461 rq_ppas = pblk_calc_secs(pblk, left_ppas, 0);
462 if (!rq_ppas)
463 rq_ppas = pblk->min_write_pgs;
464 rq_len = rq_ppas * geo->sec_size;
465
466 bio = bio_map_kern(dev->q, data, rq_len, GFP_KERNEL);
467 if (IS_ERR(bio))
468 return PTR_ERR(bio);
469
470 bio->bi_iter.bi_sector = 0; /* internal bio */
471 bio_set_op_attrs(bio, REQ_OP_READ, 0);
472
473 rqd->bio = bio;
474 rqd->opcode = NVM_OP_PREAD;
475 rqd->flags = pblk_set_read_mode(pblk);
476 rqd->meta_list = meta_list;
477 rqd->nr_ppas = rq_ppas;
478 rqd->ppa_list = ppa_list;
479 rqd->dma_ppa_list = dma_ppa_list;
480 rqd->dma_meta_list = dma_meta_list;
481 rqd->end_io = pblk_end_io_sync;
482 rqd->private = &wait;
483
484 for (i = 0; i < rqd->nr_ppas; ) {
485 struct ppa_addr ppa;
486 int pos;
487
488 w_ptr = pblk_alloc_page(pblk, line, pblk->min_write_pgs);
489 ppa = addr_to_gen_ppa(pblk, w_ptr, line->id);
490 pos = pblk_dev_ppa_to_pos(geo, ppa);
491
492 while (test_bit(pos, line->blk_bitmap)) {
493 w_ptr += pblk->min_write_pgs;
494 ppa = addr_to_gen_ppa(pblk, w_ptr, line->id);
495 pos = pblk_dev_ppa_to_pos(geo, ppa);
496 }
497
498 for (j = 0; j < pblk->min_write_pgs; j++, i++, w_ptr++)
499 rqd->ppa_list[i] =
500 addr_to_gen_ppa(pblk, w_ptr, line->id);
501 }
502
503 ret = pblk_submit_io(pblk, rqd);
504 if (ret) {
505 pr_err("pblk: I/O submission failed: %d\n", ret);
506 return ret;
507 }
508
509 if (!wait_for_completion_io_timeout(&wait,
510 msecs_to_jiffies(PBLK_COMMAND_TIMEOUT_MS))) {
511 pr_err("pblk: L2P recovery read timed out\n");
512 }
513 reinit_completion(&wait);
514
515 /* This should not happen since the read failed during normal recovery,
516 * but the media works funny sometimes...
517 */
518 if (!rec_round++ && !rqd->error) {
519 rec_round = 0;
520 for (i = 0; i < rqd->nr_ppas; i++, r_ptr++) {
521 u64 lba = le64_to_cpu(meta_list[i].lba);
522
523 if (lba == ADDR_EMPTY || lba > pblk->rl.nr_secs)
524 continue;
525
526 pblk_update_map(pblk, lba, rqd->ppa_list[i]);
527 }
528 }
529
530 /* Reached the end of the written line */
531 if (rqd->error == NVM_RSP_ERR_EMPTYPAGE) {
532 int pad_secs, nr_error_bits, bit;
533 int ret;
534
535 bit = find_first_bit((void *)&rqd->ppa_status, rqd->nr_ppas);
536 nr_error_bits = rqd->nr_ppas - bit;
537
538 /* Roll back failed sectors */
539 line->cur_sec -= nr_error_bits;
540 line->left_msecs += nr_error_bits;
541 bitmap_clear(line->map_bitmap, line->cur_sec, nr_error_bits);
542
543 pad_secs = pblk_pad_distance(pblk);
544 if (pad_secs > line->left_msecs)
545 pad_secs = line->left_msecs;
546
547 ret = pblk_recov_pad_oob(pblk, line, p, pad_secs);
548 if (ret)
549 pr_err("pblk: OOB padding failed (err:%d)\n", ret);
550
551 ret = pblk_recov_read_oob(pblk, line, p, r_ptr);
552 if (ret)
553 pr_err("pblk: OOB read failed (err:%d)\n", ret);
554
555 line->left_ssecs = line->left_msecs;
556 left_ppas = 0;
557 }
558
559 left_ppas -= rq_ppas;
560 if (left_ppas > 0)
561 goto next_rq;
562
563 return ret;
564}
565
566static int pblk_recov_scan_oob(struct pblk *pblk, struct pblk_line *line,
567 struct pblk_recov_alloc p, int *done)
568{
569 struct nvm_tgt_dev *dev = pblk->dev;
570 struct nvm_geo *geo = &dev->geo;
571 struct ppa_addr *ppa_list;
572 struct pblk_sec_meta *meta_list;
573 struct nvm_rq *rqd;
574 struct bio *bio;
575 void *data;
576 dma_addr_t dma_ppa_list, dma_meta_list;
577 u64 paddr;
578 int rq_ppas, rq_len;
579 int i, j;
580 int ret = 0;
581 int left_ppas = pblk_calc_sec_in_line(pblk, line);
582 DECLARE_COMPLETION_ONSTACK(wait);
583
584 ppa_list = p.ppa_list;
585 meta_list = p.meta_list;
586 rqd = p.rqd;
587 data = p.data;
588 dma_ppa_list = p.dma_ppa_list;
589 dma_meta_list = p.dma_meta_list;
590
591 *done = 1;
592
593next_rq:
594 memset(rqd, 0, pblk_r_rq_size);
595
596 rq_ppas = pblk_calc_secs(pblk, left_ppas, 0);
597 if (!rq_ppas)
598 rq_ppas = pblk->min_write_pgs;
599 rq_len = rq_ppas * geo->sec_size;
600
601 bio = bio_map_kern(dev->q, data, rq_len, GFP_KERNEL);
602 if (IS_ERR(bio))
603 return PTR_ERR(bio);
604
605 bio->bi_iter.bi_sector = 0; /* internal bio */
606 bio_set_op_attrs(bio, REQ_OP_READ, 0);
607
608 rqd->bio = bio;
609 rqd->opcode = NVM_OP_PREAD;
610 rqd->flags = pblk_set_read_mode(pblk);
611 rqd->meta_list = meta_list;
612 rqd->nr_ppas = rq_ppas;
613 rqd->ppa_list = ppa_list;
614 rqd->dma_ppa_list = dma_ppa_list;
615 rqd->dma_meta_list = dma_meta_list;
616 rqd->end_io = pblk_end_io_sync;
617 rqd->private = &wait;
618
619 for (i = 0; i < rqd->nr_ppas; ) {
620 struct ppa_addr ppa;
621 int pos;
622
623 paddr = pblk_alloc_page(pblk, line, pblk->min_write_pgs);
624 ppa = addr_to_gen_ppa(pblk, paddr, line->id);
625 pos = pblk_dev_ppa_to_pos(geo, ppa);
626
627 while (test_bit(pos, line->blk_bitmap)) {
628 paddr += pblk->min_write_pgs;
629 ppa = addr_to_gen_ppa(pblk, paddr, line->id);
630 pos = pblk_dev_ppa_to_pos(geo, ppa);
631 }
632
633 for (j = 0; j < pblk->min_write_pgs; j++, i++, paddr++)
634 rqd->ppa_list[i] =
635 addr_to_gen_ppa(pblk, paddr, line->id);
636 }
637
638 ret = pblk_submit_io(pblk, rqd);
639 if (ret) {
640 pr_err("pblk: I/O submission failed: %d\n", ret);
641 bio_put(bio);
642 return ret;
643 }
644
645 if (!wait_for_completion_io_timeout(&wait,
646 msecs_to_jiffies(PBLK_COMMAND_TIMEOUT_MS))) {
647 pr_err("pblk: L2P recovery read timed out\n");
648 }
649 reinit_completion(&wait);
650
651 /* Reached the end of the written line */
652 if (rqd->error) {
653 int nr_error_bits, bit;
654
655 bit = find_first_bit((void *)&rqd->ppa_status, rqd->nr_ppas);
656 nr_error_bits = rqd->nr_ppas - bit;
657
658 /* Roll back failed sectors */
659 line->cur_sec -= nr_error_bits;
660 line->left_msecs += nr_error_bits;
661 line->left_ssecs = line->left_msecs;
662 bitmap_clear(line->map_bitmap, line->cur_sec, nr_error_bits);
663
664 left_ppas = 0;
665 rqd->nr_ppas = bit;
666
667 if (rqd->error != NVM_RSP_ERR_EMPTYPAGE)
668 *done = 0;
669 }
670
671 for (i = 0; i < rqd->nr_ppas; i++) {
672 u64 lba = le64_to_cpu(meta_list[i].lba);
673
674 if (lba == ADDR_EMPTY || lba > pblk->rl.nr_secs)
675 continue;
676
677 pblk_update_map(pblk, lba, rqd->ppa_list[i]);
678 }
679
680 left_ppas -= rq_ppas;
681 if (left_ppas > 0)
682 goto next_rq;
683
684 return ret;
685}
686
687/* Scan line for lbas on out of bound area */
688static int pblk_recov_l2p_from_oob(struct pblk *pblk, struct pblk_line *line)
689{
690 struct nvm_tgt_dev *dev = pblk->dev;
691 struct nvm_geo *geo = &dev->geo;
692 struct nvm_rq *rqd;
693 struct ppa_addr *ppa_list;
694 struct pblk_sec_meta *meta_list;
695 struct pblk_recov_alloc p;
696 void *data;
697 dma_addr_t dma_ppa_list, dma_meta_list;
698 int done, ret = 0;
699
700 rqd = pblk_alloc_rqd(pblk, READ);
701 if (IS_ERR(rqd))
702 return PTR_ERR(rqd);
703
704 meta_list = nvm_dev_dma_alloc(dev->parent, GFP_KERNEL, &dma_meta_list);
705 if (!meta_list) {
706 ret = -ENOMEM;
707 goto free_rqd;
708 }
709
710 ppa_list = (void *)(meta_list) + pblk_dma_meta_size;
711 dma_ppa_list = dma_meta_list + pblk_dma_meta_size;
712
713 data = kcalloc(pblk->max_write_pgs, geo->sec_size, GFP_KERNEL);
714 if (!data) {
715 ret = -ENOMEM;
716 goto free_meta_list;
717 }
718
719 p.ppa_list = ppa_list;
720 p.meta_list = meta_list;
721 p.rqd = rqd;
722 p.data = data;
723 p.dma_ppa_list = dma_ppa_list;
724 p.dma_meta_list = dma_meta_list;
725
726 ret = pblk_recov_scan_oob(pblk, line, p, &done);
727 if (ret) {
728 pr_err("pblk: could not recover L2P from OOB\n");
729 goto out;
730 }
731
732 if (!done) {
733 ret = pblk_recov_scan_all_oob(pblk, line, p);
734 if (ret) {
735 pr_err("pblk: could not recover L2P from OOB\n");
736 goto out;
737 }
738 }
739
740 if (pblk_line_is_full(line))
741 pblk_line_recov_close(pblk, line);
742
743out:
744 kfree(data);
745free_meta_list:
746 nvm_dev_dma_free(dev->parent, meta_list, dma_meta_list);
747free_rqd:
748 pblk_free_rqd(pblk, rqd, READ);
749
750 return ret;
751}
752
753/* Insert lines ordered by sequence number (seq_num) on list */
754static void pblk_recov_line_add_ordered(struct list_head *head,
755 struct pblk_line *line)
756{
757 struct pblk_line *t = NULL;
758
759 list_for_each_entry(t, head, list)
760 if (t->seq_nr > line->seq_nr)
761 break;
762
763 __list_add(&line->list, t->list.prev, &t->list);
764}
765
766struct pblk_line *pblk_recov_l2p(struct pblk *pblk)
767{
768 struct nvm_tgt_dev *dev = pblk->dev;
769 struct nvm_geo *geo = &dev->geo;
770 struct pblk_line_meta *lm = &pblk->lm;
771 struct pblk_line_mgmt *l_mg = &pblk->l_mg;
772 struct pblk_line *line, *tline, *data_line = NULL;
773 struct line_smeta *smeta;
774 struct line_emeta *emeta;
775 int found_lines = 0, recovered_lines = 0, open_lines = 0;
776 int is_next = 0;
777 int meta_line;
778 int i, valid_uuid = 0;
779 LIST_HEAD(recov_list);
780
781 /* TODO: Implement FTL snapshot */
782
783 /* Scan recovery - takes place when FTL snapshot fails */
784 spin_lock(&l_mg->free_lock);
785 meta_line = find_first_zero_bit(&l_mg->meta_bitmap, PBLK_DATA_LINES);
786 set_bit(meta_line, &l_mg->meta_bitmap);
787 smeta = l_mg->sline_meta[meta_line].meta;
788 emeta = l_mg->eline_meta[meta_line].meta;
789 spin_unlock(&l_mg->free_lock);
790
791 /* Order data lines using their sequence number */
792 for (i = 0; i < l_mg->nr_lines; i++) {
793 u32 crc;
794
795 line = &pblk->lines[i];
796
797 memset(smeta, 0, lm->smeta_len);
798 line->smeta = smeta;
799 line->lun_bitmap = ((void *)(smeta)) +
800 sizeof(struct line_smeta);
801
802 /* Lines that cannot be read are assumed as not written here */
803 if (pblk_line_read_smeta(pblk, line))
804 continue;
805
806 crc = pblk_calc_smeta_crc(pblk, smeta);
807 if (le32_to_cpu(smeta->crc) != crc)
808 continue;
809
810 if (le32_to_cpu(smeta->header.identifier) != PBLK_MAGIC)
811 continue;
812
813 if (le16_to_cpu(smeta->header.version) != 1) {
814 pr_err("pblk: found incompatible line version %u\n",
815 smeta->header.version);
816 return ERR_PTR(-EINVAL);
817 }
818
819 /* The first valid instance uuid is used for initialization */
820 if (!valid_uuid) {
821 memcpy(pblk->instance_uuid, smeta->header.uuid, 16);
822 valid_uuid = 1;
823 }
824
825 if (memcmp(pblk->instance_uuid, smeta->header.uuid, 16)) {
826 pr_debug("pblk: ignore line %u due to uuid mismatch\n",
827 i);
828 continue;
829 }
830
831 /* Update line metadata */
832 spin_lock(&line->lock);
833 line->id = le32_to_cpu(line->smeta->header.id);
834 line->type = le16_to_cpu(line->smeta->header.type);
835 line->seq_nr = le64_to_cpu(line->smeta->seq_nr);
836 spin_unlock(&line->lock);
837
838 /* Update general metadata */
839 spin_lock(&l_mg->free_lock);
840 if (line->seq_nr >= l_mg->d_seq_nr)
841 l_mg->d_seq_nr = line->seq_nr + 1;
842 l_mg->nr_free_lines--;
843 spin_unlock(&l_mg->free_lock);
844
845 if (pblk_line_recov_alloc(pblk, line))
846 goto out;
847
848 pblk_recov_line_add_ordered(&recov_list, line);
849 found_lines++;
850 pr_debug("pblk: recovering data line %d, seq:%llu\n",
851 line->id, smeta->seq_nr);
852 }
853
854 if (!found_lines) {
855 pblk_setup_uuid(pblk);
856
857 spin_lock(&l_mg->free_lock);
858 WARN_ON_ONCE(!test_and_clear_bit(meta_line,
859 &l_mg->meta_bitmap));
860 spin_unlock(&l_mg->free_lock);
861
862 goto out;
863 }
864
865 /* Verify closed blocks and recover this portion of L2P table*/
866 list_for_each_entry_safe(line, tline, &recov_list, list) {
867 int off, nr_bb;
868
869 recovered_lines++;
870 /* Calculate where emeta starts based on the line bb */
871 off = lm->sec_per_line - lm->emeta_sec;
872 nr_bb = bitmap_weight(line->blk_bitmap, lm->blk_per_line);
873 off -= nr_bb * geo->sec_per_pl;
874
875 memset(emeta, 0, lm->emeta_len);
876 line->emeta = emeta;
877 line->emeta_ssec = off;
878
879 if (pblk_line_read_emeta(pblk, line)) {
880 pblk_recov_l2p_from_oob(pblk, line);
881 goto next;
882 }
883
884 if (pblk_recov_l2p_from_emeta(pblk, line))
885 pblk_recov_l2p_from_oob(pblk, line);
886
887next:
888 if (pblk_line_is_full(line)) {
889 struct list_head *move_list;
890
891 spin_lock(&line->lock);
892 line->state = PBLK_LINESTATE_CLOSED;
893 move_list = pblk_line_gc_list(pblk, line);
894 spin_unlock(&line->lock);
895
896 spin_lock(&l_mg->gc_lock);
897 list_move_tail(&line->list, move_list);
898 spin_unlock(&l_mg->gc_lock);
899
900 mempool_free(line->map_bitmap, pblk->line_meta_pool);
901 line->map_bitmap = NULL;
902 line->smeta = NULL;
903 line->emeta = NULL;
904 } else {
905 if (open_lines > 1)
906 pr_err("pblk: failed to recover L2P\n");
907
908 open_lines++;
909 line->meta_line = meta_line;
910 data_line = line;
911 }
912 }
913
914 spin_lock(&l_mg->free_lock);
915 if (!open_lines) {
916 WARN_ON_ONCE(!test_and_clear_bit(meta_line,
917 &l_mg->meta_bitmap));
918 pblk_line_replace_data(pblk);
919 } else {
920 /* Allocate next line for preparation */
921 l_mg->data_next = pblk_line_get(pblk);
922 if (l_mg->data_next) {
923 l_mg->data_next->seq_nr = l_mg->d_seq_nr++;
924 l_mg->data_next->type = PBLK_LINETYPE_DATA;
925 is_next = 1;
926 }
927 }
928 spin_unlock(&l_mg->free_lock);
929
930 if (is_next) {
931 pblk_line_erase(pblk, l_mg->data_next);
932 pblk_rl_free_lines_dec(&pblk->rl, l_mg->data_next);
933 }
934
935out:
936 if (found_lines != recovered_lines)
937 pr_err("pblk: failed to recover all found lines %d/%d\n",
938 found_lines, recovered_lines);
939
940 return data_line;
941}
942
943/*
944 * Pad until smeta can be read on current data line
945 */
946void pblk_recov_pad(struct pblk *pblk)
947{
948 struct nvm_tgt_dev *dev = pblk->dev;
949 struct nvm_geo *geo = &dev->geo;
950 struct pblk_line *line;
951 struct pblk_line_mgmt *l_mg = &pblk->l_mg;
952 struct nvm_rq *rqd;
953 struct pblk_recov_alloc p;
954 struct ppa_addr *ppa_list;
955 struct pblk_sec_meta *meta_list;
956 void *data;
957 dma_addr_t dma_ppa_list, dma_meta_list;
958
959 spin_lock(&l_mg->free_lock);
960 line = l_mg->data_line;
961 spin_unlock(&l_mg->free_lock);
962
963 rqd = pblk_alloc_rqd(pblk, READ);
964 if (IS_ERR(rqd))
965 return;
966
967 meta_list = nvm_dev_dma_alloc(dev->parent, GFP_KERNEL, &dma_meta_list);
968 if (!meta_list)
969 goto free_rqd;
970
971 ppa_list = (void *)(meta_list) + pblk_dma_meta_size;
972 dma_ppa_list = dma_meta_list + pblk_dma_meta_size;
973
974 data = kcalloc(pblk->max_write_pgs, geo->sec_size, GFP_KERNEL);
975 if (!data)
976 goto free_meta_list;
977
978 p.ppa_list = ppa_list;
979 p.meta_list = meta_list;
980 p.rqd = rqd;
981 p.data = data;
982 p.dma_ppa_list = dma_ppa_list;
983 p.dma_meta_list = dma_meta_list;
984
985 if (pblk_recov_pad_oob(pblk, line, p, line->left_msecs)) {
986 pr_err("pblk: Tear down padding failed\n");
987 goto free_data;
988 }
989
990 pblk_line_close(pblk, line);
991
992free_data:
993 kfree(data);
994free_meta_list:
995 nvm_dev_dma_free(dev->parent, meta_list, dma_meta_list);
996free_rqd:
997 pblk_free_rqd(pblk, rqd, READ);
998}
Linux 6.x block layer and io_uring tree(s)