Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright (C) 2022 Intel Corporation.
3 : : * All rights reserved.
4 : : */
5 : :
6 : : #include "ftl_l2p.h"
7 : : #include "ftl_core.h"
8 : : #include "ftl_band.h"
9 : : #include "ftl_utils.h"
10 : : #include "ftl_l2p_flat.h"
11 : : #include "utils/ftl_addr_utils.h"
12 : :
13 : : static struct ftl_md *
14 : 0 : get_l2p_md(struct spdk_ftl_dev *dev)
15 : : {
16 : 0 : return dev->layout.md[FTL_LAYOUT_REGION_TYPE_L2P];
17 : : }
18 : :
19 : : struct ftl_l2p_flat {
20 : : void *l2p;
21 : : bool is_halted;
22 : : };
23 : :
24 : : void
25 : 0 : ftl_l2p_flat_pin(struct spdk_ftl_dev *dev, struct ftl_l2p_pin_ctx *pin_ctx)
26 : : {
27 [ # # ]: 0 : assert(dev->num_lbas >= pin_ctx->lba + pin_ctx->count);
28 : :
29 : 0 : ftl_l2p_pin_complete(dev, 0, pin_ctx);
30 : 0 : }
31 : :
32 : : void
33 : 0 : ftl_l2p_flat_unpin(struct spdk_ftl_dev *dev, uint64_t lba, uint64_t count)
34 : : {
35 [ # # ]: 0 : assert(dev->num_lbas >= lba + count);
36 : 0 : }
37 : :
38 : : void
39 : 0 : ftl_l2p_flat_set(struct spdk_ftl_dev *dev, uint64_t lba, ftl_addr addr)
40 : : {
41 : 0 : struct ftl_l2p_flat *l2p_flat = dev->l2p;
42 : :
43 [ # # ]: 0 : assert(dev->num_lbas > lba);
44 : :
45 : 0 : ftl_addr_store(dev, l2p_flat->l2p, lba, addr);
46 : 0 : }
47 : :
48 : : ftl_addr
49 : 0 : ftl_l2p_flat_get(struct spdk_ftl_dev *dev, uint64_t lba)
50 : : {
51 : 0 : struct ftl_l2p_flat *l2p_flat = dev->l2p;
52 : :
53 [ # # ]: 0 : assert(dev->num_lbas > lba);
54 : :
55 : 0 : return ftl_addr_load(dev, l2p_flat->l2p, lba);
56 : : }
57 : :
58 : : static void
59 : 0 : md_cb(struct spdk_ftl_dev *dev, struct ftl_md *md, int status)
60 : : {
61 : 0 : ftl_l2p_cb cb = md->owner.private;
62 : 0 : void *cb_ctx = md->owner.cb_ctx;
63 : :
64 : 0 : cb(dev, status, cb_ctx);
65 : 0 : }
66 : :
67 : : void
68 : 0 : ftl_l2p_flat_clear(struct spdk_ftl_dev *dev, ftl_l2p_cb cb, void *cb_ctx)
69 : : {
70 : 0 : struct ftl_l2p_flat *l2p_flat = dev->l2p;
71 : : struct ftl_md *md;
72 : :
73 [ # # ]: 0 : memset(l2p_flat->l2p, (int)FTL_ADDR_INVALID,
74 : : ftl_md_get_buffer_size(get_l2p_md(dev)));
75 : :
76 : 0 : md = get_l2p_md(dev);
77 : 0 : md->cb = md_cb;
78 : 0 : md->owner.cb_ctx = cb_ctx;
79 : 0 : md->owner.private = cb;
80 : 0 : ftl_md_persist(md);
81 : 0 : }
82 : :
83 : : void
84 : 0 : ftl_l2p_flat_restore(struct spdk_ftl_dev *dev, ftl_l2p_cb cb, void *cb_ctx)
85 : : {
86 : : struct ftl_md *md;
87 : :
88 : 0 : md = get_l2p_md(dev);
89 : 0 : md->cb = md_cb;
90 : 0 : md->owner.cb_ctx = cb_ctx;
91 : 0 : md->owner.private = cb;
92 : 0 : ftl_md_restore(md);
93 : 0 : }
94 : :
95 : : void
96 : 0 : ftl_l2p_flat_persist(struct spdk_ftl_dev *dev, ftl_l2p_cb cb, void *cb_ctx)
97 : : {
98 : : struct ftl_md *md;
99 : :
100 : 0 : md = get_l2p_md(dev);
101 : 0 : md->cb = md_cb;
102 : 0 : md->owner.cb_ctx = cb_ctx;
103 : 0 : md->owner.private = cb;
104 : 0 : ftl_md_persist(md);
105 : 0 : }
106 : :
107 : : static int
108 : 0 : ftl_l2p_flat_init_dram(struct spdk_ftl_dev *dev, struct ftl_l2p_flat *l2p_flat,
109 : : size_t l2p_size)
110 : : {
111 : 0 : struct ftl_md *md = get_l2p_md(dev);
112 : :
113 [ # # ]: 0 : assert(ftl_md_get_buffer_size(md) >= l2p_size);
114 : :
115 : 0 : l2p_flat->l2p = ftl_md_get_buffer(md);
116 [ # # ]: 0 : if (!l2p_flat->l2p) {
117 [ # # ]: 0 : FTL_ERRLOG(dev, "Failed to allocate l2p table\n");
118 : 0 : return -1;
119 : : }
120 : :
121 : 0 : return 0;
122 : : }
123 : :
124 : : int
125 : 0 : ftl_l2p_flat_init(struct spdk_ftl_dev *dev)
126 : : {
127 : 0 : size_t l2p_size = dev->num_lbas * dev->layout.l2p.addr_size;
128 : : struct ftl_l2p_flat *l2p_flat;
129 : : int ret;
130 : :
131 [ # # ]: 0 : if (dev->num_lbas == 0) {
132 [ # # ]: 0 : FTL_ERRLOG(dev, "Invalid l2p table size\n");
133 : 0 : return -1;
134 : : }
135 : :
136 [ # # ]: 0 : if (dev->l2p) {
137 [ # # ]: 0 : FTL_ERRLOG(dev, "L2p table already allocated\n");
138 : 0 : return -1;
139 : : }
140 : :
141 : 0 : l2p_flat = calloc(1, sizeof(*l2p_flat));
142 [ # # ]: 0 : if (!l2p_flat) {
143 [ # # ]: 0 : FTL_ERRLOG(dev, "Failed to allocate l2p_flat\n");
144 : 0 : return -1;
145 : : }
146 : :
147 : 0 : ret = ftl_l2p_flat_init_dram(dev, l2p_flat, l2p_size);
148 : :
149 [ # # ]: 0 : if (ret) {
150 : 0 : free(l2p_flat);
151 : 0 : return ret;
152 : : }
153 : :
154 : 0 : dev->l2p = l2p_flat;
155 : 0 : return 0;
156 : : }
157 : :
158 : : void
159 : 0 : ftl_l2p_flat_deinit(struct spdk_ftl_dev *dev)
160 : : {
161 : 0 : struct ftl_l2p_flat *l2p_flat = dev->l2p;
162 : :
163 [ # # ]: 0 : if (!l2p_flat) {
164 : 0 : return;
165 : : }
166 : :
167 : 0 : free(l2p_flat);
168 : :
169 : 0 : dev->l2p = NULL;
170 : : }
171 : :
172 : : void
173 : 0 : ftl_l2p_flat_unmap(struct spdk_ftl_dev *dev, ftl_l2p_cb cb, void *cb_ctx)
174 : : {
175 : 0 : cb(dev, 0, cb_ctx);
176 : 0 : }
177 : :
178 : : void
179 : 0 : ftl_l2p_flat_process(struct spdk_ftl_dev *dev)
180 : : {
181 : 0 : }
182 : :
183 : : bool
184 : 0 : ftl_l2p_flat_is_halted(struct spdk_ftl_dev *dev)
185 : : {
186 : 0 : return true;
187 : : }
188 : :
189 : : void
190 : 0 : ftl_l2p_flat_halt(struct spdk_ftl_dev *dev)
191 : : {
192 : 0 : }
193 : :
194 : : void
195 : 0 : ftl_l2p_flat_resume(struct spdk_ftl_dev *dev)
196 : : {
197 : 0 : }
|