Commit | Line | Data |
---|---|---|
ca4b2a01 MB |
1 | // SPDX-License-Identifier: GPL-2.0 |
2 | #include <linux/vmalloc.h> | |
aa1c09cb | 3 | #include <linux/bitmap.h> |
ca4b2a01 MB |
4 | #include "null_blk.h" |
5 | ||
766c3297 | 6 | #define CREATE_TRACE_POINTS |
eebf34a8 | 7 | #include "trace.h" |
766c3297 | 8 | |
db060f54 DLM |
9 | #undef pr_fmt |
10 | #define pr_fmt(fmt) "null_blk: " fmt | |
11 | ||
cd92cdb9 DLM |
12 | static inline sector_t mb_to_sects(unsigned long mb) |
13 | { | |
14 | return ((sector_t)mb * SZ_1M) >> SECTOR_SHIFT; | |
15 | } | |
ca4b2a01 MB |
16 | |
17 | static inline unsigned int null_zone_no(struct nullb_device *dev, sector_t sect) | |
18 | { | |
19 | return sect >> ilog2(dev->zone_size_sects); | |
20 | } | |
21 | ||
2b8b7ed7 DLM |
22 | static inline void null_lock_zone_res(struct nullb_device *dev) |
23 | { | |
24 | if (dev->need_zone_res_mgmt) | |
25 | spin_lock_irq(&dev->zone_res_lock); | |
26 | } | |
27 | ||
28 | static inline void null_unlock_zone_res(struct nullb_device *dev) | |
29 | { | |
30 | if (dev->need_zone_res_mgmt) | |
31 | spin_unlock_irq(&dev->zone_res_lock); | |
32 | } | |
33 | ||
34 | static inline void null_init_zone_lock(struct nullb_device *dev, | |
35 | struct nullb_zone *zone) | |
36 | { | |
37 | if (!dev->memory_backed) | |
38 | spin_lock_init(&zone->spinlock); | |
39 | else | |
40 | mutex_init(&zone->mutex); | |
41 | } | |
42 | ||
43 | static inline void null_lock_zone(struct nullb_device *dev, | |
44 | struct nullb_zone *zone) | |
45 | { | |
46 | if (!dev->memory_backed) | |
47 | spin_lock_irq(&zone->spinlock); | |
48 | else | |
49 | mutex_lock(&zone->mutex); | |
50 | } | |
51 | ||
52 | static inline void null_unlock_zone(struct nullb_device *dev, | |
53 | struct nullb_zone *zone) | |
54 | { | |
55 | if (!dev->memory_backed) | |
56 | spin_unlock_irq(&zone->spinlock); | |
57 | else | |
58 | mutex_unlock(&zone->mutex); | |
59 | } | |
60 | ||
e440626b CH |
61 | int null_init_zoned_dev(struct nullb_device *dev, |
62 | struct queue_limits *lim) | |
ca4b2a01 | 63 | { |
0ebcdd70 | 64 | sector_t dev_capacity_sects, zone_capacity_sects; |
2b8b7ed7 | 65 | struct nullb_zone *zone; |
ca4b2a01 MB |
66 | sector_t sector = 0; |
67 | unsigned int i; | |
68 | ||
69 | if (!is_power_of_2(dev->zone_size)) { | |
9c7eddf1 | 70 | pr_err("zone_size must be power-of-two\n"); |
ca4b2a01 MB |
71 | return -EINVAL; |
72 | } | |
e2748325 CK |
73 | if (dev->zone_size > dev->size) { |
74 | pr_err("Zone size larger than device capacity\n"); | |
75 | return -EINVAL; | |
76 | } | |
ca4b2a01 | 77 | |
089565fb AR |
78 | if (!dev->zone_capacity) |
79 | dev->zone_capacity = dev->zone_size; | |
80 | ||
81 | if (dev->zone_capacity > dev->zone_size) { | |
db060f54 DLM |
82 | pr_err("zone capacity (%lu MB) larger than zone size (%lu MB)\n", |
83 | dev->zone_capacity, dev->zone_size); | |
089565fb AR |
84 | return -EINVAL; |
85 | } | |
86 | ||
cd92cdb9 DLM |
87 | zone_capacity_sects = mb_to_sects(dev->zone_capacity); |
88 | dev_capacity_sects = mb_to_sects(dev->size); | |
89 | dev->zone_size_sects = mb_to_sects(dev->zone_size); | |
90 | dev->nr_zones = round_up(dev_capacity_sects, dev->zone_size_sects) | |
91 | >> ilog2(dev->zone_size_sects); | |
0ebcdd70 | 92 | |
2b8b7ed7 DLM |
93 | dev->zones = kvmalloc_array(dev->nr_zones, sizeof(struct nullb_zone), |
94 | GFP_KERNEL | __GFP_ZERO); | |
ca4b2a01 MB |
95 | if (!dev->zones) |
96 | return -ENOMEM; | |
97 | ||
2b8b7ed7 | 98 | spin_lock_init(&dev->zone_res_lock); |
aa1c09cb | 99 | |
ea2c18e1 MS |
100 | if (dev->zone_nr_conv >= dev->nr_zones) { |
101 | dev->zone_nr_conv = dev->nr_zones - 1; | |
9c7eddf1 | 102 | pr_info("changed the number of conventional zones to %u", |
ea2c18e1 MS |
103 | dev->zone_nr_conv); |
104 | } | |
105 | ||
dc4d137e NC |
106 | /* Max active zones has to be < nbr of seq zones in order to be enforceable */ |
107 | if (dev->zone_max_active >= dev->nr_zones - dev->zone_nr_conv) { | |
108 | dev->zone_max_active = 0; | |
109 | pr_info("zone_max_active limit disabled, limit >= zone count\n"); | |
110 | } | |
111 | ||
112 | /* Max open zones has to be <= max active zones */ | |
113 | if (dev->zone_max_active && dev->zone_max_open > dev->zone_max_active) { | |
114 | dev->zone_max_open = dev->zone_max_active; | |
115 | pr_info("changed the maximum number of open zones to %u\n", | |
116 | dev->nr_zones); | |
117 | } else if (dev->zone_max_open >= dev->nr_zones - dev->zone_nr_conv) { | |
118 | dev->zone_max_open = 0; | |
119 | pr_info("zone_max_open limit disabled, limit >= zone count\n"); | |
120 | } | |
2b8b7ed7 | 121 | dev->need_zone_res_mgmt = dev->zone_max_active || dev->zone_max_open; |
2e8c6e0e | 122 | dev->imp_close_zone_no = dev->zone_nr_conv; |
dc4d137e | 123 | |
ea2c18e1 | 124 | for (i = 0; i < dev->zone_nr_conv; i++) { |
2b8b7ed7 | 125 | zone = &dev->zones[i]; |
ea2c18e1 | 126 | |
2b8b7ed7 | 127 | null_init_zone_lock(dev, zone); |
ea2c18e1 MS |
128 | zone->start = sector; |
129 | zone->len = dev->zone_size_sects; | |
82394db7 | 130 | zone->capacity = zone->len; |
ea2c18e1 MS |
131 | zone->wp = zone->start + zone->len; |
132 | zone->type = BLK_ZONE_TYPE_CONVENTIONAL; | |
133 | zone->cond = BLK_ZONE_COND_NOT_WP; | |
134 | ||
135 | sector += dev->zone_size_sects; | |
136 | } | |
137 | ||
138 | for (i = dev->zone_nr_conv; i < dev->nr_zones; i++) { | |
2b8b7ed7 | 139 | zone = &dev->zones[i]; |
ca4b2a01 | 140 | |
2b8b7ed7 | 141 | null_init_zone_lock(dev, zone); |
ca4b2a01 | 142 | zone->start = zone->wp = sector; |
0ebcdd70 DLM |
143 | if (zone->start + dev->zone_size_sects > dev_capacity_sects) |
144 | zone->len = dev_capacity_sects - zone->start; | |
145 | else | |
146 | zone->len = dev->zone_size_sects; | |
147 | zone->capacity = | |
148 | min_t(sector_t, zone->len, zone_capacity_sects); | |
ca4b2a01 MB |
149 | zone->type = BLK_ZONE_TYPE_SEQWRITE_REQ; |
150 | zone->cond = BLK_ZONE_COND_EMPTY; | |
151 | ||
152 | sector += dev->zone_size_sects; | |
153 | } | |
154 | ||
e440626b CH |
155 | lim->zoned = true; |
156 | lim->chunk_sectors = dev->zone_size_sects; | |
157 | lim->max_zone_append_sectors = dev->zone_size_sects; | |
158 | lim->max_open_zones = dev->zone_max_open; | |
159 | lim->max_active_zones = dev->zone_max_active; | |
d205bde7 DLM |
160 | return 0; |
161 | } | |
162 | ||
163 | int null_register_zoned_dev(struct nullb *nullb) | |
164 | { | |
165 | struct request_queue *q = nullb->q; | |
166 | ||
5752dc78 DLM |
167 | blk_queue_flag_set(QUEUE_FLAG_ZONE_RESETALL, q); |
168 | blk_queue_required_elevator_features(q, ELEVATOR_F_ZBD_SEQ_WRITE); | |
a442b899 | 169 | nullb->disk->nr_zones = bdev_nr_zones(nullb->disk->part0); |
8b631f9c | 170 | return blk_revalidate_disk_zones(nullb->disk, NULL); |
ca4b2a01 MB |
171 | } |
172 | ||
d205bde7 | 173 | void null_free_zoned_dev(struct nullb_device *dev) |
ca4b2a01 MB |
174 | { |
175 | kvfree(dev->zones); | |
72ce11dd | 176 | dev->zones = NULL; |
ca4b2a01 MB |
177 | } |
178 | ||
7fc8fb51 | 179 | int null_report_zones(struct gendisk *disk, sector_t sector, |
d4100351 | 180 | unsigned int nr_zones, report_zones_cb cb, void *data) |
ca4b2a01 | 181 | { |
e76239a3 CH |
182 | struct nullb *nullb = disk->private_data; |
183 | struct nullb_device *dev = nullb->dev; | |
2b8b7ed7 DLM |
184 | unsigned int first_zone, i; |
185 | struct nullb_zone *zone; | |
186 | struct blk_zone blkz; | |
d4100351 | 187 | int error; |
ca4b2a01 | 188 | |
d4100351 CH |
189 | first_zone = null_zone_no(dev, sector); |
190 | if (first_zone >= dev->nr_zones) | |
191 | return 0; | |
ca4b2a01 | 192 | |
d4100351 | 193 | nr_zones = min(nr_zones, dev->nr_zones - first_zone); |
766c3297 CK |
194 | trace_nullb_report_zones(nullb, nr_zones); |
195 | ||
2b8b7ed7 DLM |
196 | memset(&blkz, 0, sizeof(struct blk_zone)); |
197 | zone = &dev->zones[first_zone]; | |
198 | for (i = 0; i < nr_zones; i++, zone++) { | |
d4100351 CH |
199 | /* |
200 | * Stacked DM target drivers will remap the zone information by | |
201 | * modifying the zone information passed to the report callback. | |
202 | * So use a local copy to avoid corruption of the device zone | |
203 | * array. | |
204 | */ | |
2b8b7ed7 DLM |
205 | null_lock_zone(dev, zone); |
206 | blkz.start = zone->start; | |
207 | blkz.len = zone->len; | |
208 | blkz.wp = zone->wp; | |
209 | blkz.type = zone->type; | |
210 | blkz.cond = zone->cond; | |
211 | blkz.capacity = zone->capacity; | |
212 | null_unlock_zone(dev, zone); | |
213 | ||
214 | error = cb(&blkz, i, data); | |
d4100351 CH |
215 | if (error) |
216 | return error; | |
217 | } | |
ca4b2a01 | 218 | |
d4100351 | 219 | return nr_zones; |
ca4b2a01 MB |
220 | } |
221 | ||
aa1c09cb DLM |
222 | /* |
223 | * This is called in the case of memory backing from null_process_cmd() | |
224 | * with the target zone already locked. | |
225 | */ | |
dd85b492 AJ |
226 | size_t null_zone_valid_read_len(struct nullb *nullb, |
227 | sector_t sector, unsigned int len) | |
228 | { | |
229 | struct nullb_device *dev = nullb->dev; | |
2b8b7ed7 | 230 | struct nullb_zone *zone = &dev->zones[null_zone_no(dev, sector)]; |
dd85b492 AJ |
231 | unsigned int nr_sectors = len >> SECTOR_SHIFT; |
232 | ||
233 | /* Read must be below the write pointer position */ | |
234 | if (zone->type == BLK_ZONE_TYPE_CONVENTIONAL || | |
235 | sector + nr_sectors <= zone->wp) | |
236 | return len; | |
237 | ||
238 | if (sector > zone->wp) | |
239 | return 0; | |
240 | ||
241 | return (zone->wp - sector) << SECTOR_SHIFT; | |
242 | } | |
243 | ||
2b8b7ed7 DLM |
244 | static blk_status_t __null_close_zone(struct nullb_device *dev, |
245 | struct nullb_zone *zone) | |
dc4d137e | 246 | { |
dc4d137e NC |
247 | switch (zone->cond) { |
248 | case BLK_ZONE_COND_CLOSED: | |
249 | /* close operation on closed is not an error */ | |
250 | return BLK_STS_OK; | |
251 | case BLK_ZONE_COND_IMP_OPEN: | |
252 | dev->nr_zones_imp_open--; | |
253 | break; | |
254 | case BLK_ZONE_COND_EXP_OPEN: | |
255 | dev->nr_zones_exp_open--; | |
256 | break; | |
257 | case BLK_ZONE_COND_EMPTY: | |
258 | case BLK_ZONE_COND_FULL: | |
259 | default: | |
260 | return BLK_STS_IOERR; | |
261 | } | |
262 | ||
263 | if (zone->wp == zone->start) { | |
264 | zone->cond = BLK_ZONE_COND_EMPTY; | |
265 | } else { | |
266 | zone->cond = BLK_ZONE_COND_CLOSED; | |
267 | dev->nr_zones_closed++; | |
268 | } | |
269 | ||
270 | return BLK_STS_OK; | |
271 | } | |
272 | ||
2e8c6e0e | 273 | static void null_close_imp_open_zone(struct nullb_device *dev) |
dc4d137e | 274 | { |
2e8c6e0e DLM |
275 | struct nullb_zone *zone; |
276 | unsigned int zno, i; | |
277 | ||
278 | zno = dev->imp_close_zone_no; | |
279 | if (zno >= dev->nr_zones) | |
280 | zno = dev->zone_nr_conv; | |
dc4d137e NC |
281 | |
282 | for (i = dev->zone_nr_conv; i < dev->nr_zones; i++) { | |
2e8c6e0e DLM |
283 | zone = &dev->zones[zno]; |
284 | zno++; | |
285 | if (zno >= dev->nr_zones) | |
286 | zno = dev->zone_nr_conv; | |
287 | ||
288 | if (zone->cond == BLK_ZONE_COND_IMP_OPEN) { | |
289 | __null_close_zone(dev, zone); | |
290 | dev->imp_close_zone_no = zno; | |
dc4d137e NC |
291 | return; |
292 | } | |
293 | } | |
294 | } | |
295 | ||
fd78874b | 296 | static blk_status_t null_check_active(struct nullb_device *dev) |
dc4d137e NC |
297 | { |
298 | if (!dev->zone_max_active) | |
fd78874b KB |
299 | return BLK_STS_OK; |
300 | ||
301 | if (dev->nr_zones_exp_open + dev->nr_zones_imp_open + | |
302 | dev->nr_zones_closed < dev->zone_max_active) | |
303 | return BLK_STS_OK; | |
dc4d137e | 304 | |
fd78874b | 305 | return BLK_STS_ZONE_ACTIVE_RESOURCE; |
dc4d137e NC |
306 | } |
307 | ||
fd78874b | 308 | static blk_status_t null_check_open(struct nullb_device *dev) |
dc4d137e NC |
309 | { |
310 | if (!dev->zone_max_open) | |
fd78874b | 311 | return BLK_STS_OK; |
dc4d137e NC |
312 | |
313 | if (dev->nr_zones_exp_open + dev->nr_zones_imp_open < dev->zone_max_open) | |
fd78874b | 314 | return BLK_STS_OK; |
dc4d137e | 315 | |
fd78874b KB |
316 | if (dev->nr_zones_imp_open) { |
317 | if (null_check_active(dev) == BLK_STS_OK) { | |
2e8c6e0e | 318 | null_close_imp_open_zone(dev); |
fd78874b KB |
319 | return BLK_STS_OK; |
320 | } | |
dc4d137e NC |
321 | } |
322 | ||
fd78874b | 323 | return BLK_STS_ZONE_OPEN_RESOURCE; |
dc4d137e NC |
324 | } |
325 | ||
326 | /* | |
327 | * This function matches the manage open zone resources function in the ZBC standard, | |
328 | * with the addition of max active zones support (added in the ZNS standard). | |
329 | * | |
330 | * The function determines if a zone can transition to implicit open or explicit open, | |
331 | * while maintaining the max open zone (and max active zone) limit(s). It may close an | |
332 | * implicit open zone in order to make additional zone resources available. | |
333 | * | |
334 | * ZBC states that an implicit open zone shall be closed only if there is not | |
335 | * room within the open limit. However, with the addition of an active limit, | |
336 | * it is not certain that closing an implicit open zone will allow a new zone | |
337 | * to be opened, since we might already be at the active limit capacity. | |
338 | */ | |
2b8b7ed7 DLM |
339 | static blk_status_t null_check_zone_resources(struct nullb_device *dev, |
340 | struct nullb_zone *zone) | |
dc4d137e | 341 | { |
fd78874b KB |
342 | blk_status_t ret; |
343 | ||
dc4d137e NC |
344 | switch (zone->cond) { |
345 | case BLK_ZONE_COND_EMPTY: | |
fd78874b KB |
346 | ret = null_check_active(dev); |
347 | if (ret != BLK_STS_OK) | |
348 | return ret; | |
dc4d137e NC |
349 | fallthrough; |
350 | case BLK_ZONE_COND_CLOSED: | |
fd78874b | 351 | return null_check_open(dev); |
dc4d137e NC |
352 | default: |
353 | /* Should never be called for other states */ | |
354 | WARN_ON(1); | |
fd78874b | 355 | return BLK_STS_IOERR; |
dc4d137e NC |
356 | } |
357 | } | |
358 | ||
fceb5d1b | 359 | static blk_status_t null_zone_write(struct nullb_cmd *cmd, sector_t sector, |
e0489ed5 | 360 | unsigned int nr_sectors, bool append) |
ca4b2a01 MB |
361 | { |
362 | struct nullb_device *dev = cmd->nq->dev; | |
ca4b2a01 | 363 | unsigned int zno = null_zone_no(dev, sector); |
2b8b7ed7 | 364 | struct nullb_zone *zone = &dev->zones[zno]; |
9dd44c7e DLM |
365 | blk_status_t ret; |
366 | ||
367 | trace_nullb_zone_op(cmd, zno, zone->cond); | |
368 | ||
2e896d89 DLM |
369 | if (zone->type == BLK_ZONE_TYPE_CONVENTIONAL) { |
370 | if (append) | |
371 | return BLK_STS_IOERR; | |
9dd44c7e | 372 | return null_process_cmd(cmd, REQ_OP_WRITE, sector, nr_sectors); |
2e896d89 | 373 | } |
ca4b2a01 | 374 | |
2b8b7ed7 | 375 | null_lock_zone(dev, zone); |
aa1c09cb | 376 | |
d3a57388 SK |
377 | if (zone->cond == BLK_ZONE_COND_FULL || |
378 | zone->cond == BLK_ZONE_COND_READONLY || | |
379 | zone->cond == BLK_ZONE_COND_OFFLINE) { | |
380 | /* Cannot write to the zone */ | |
aa1c09cb DLM |
381 | ret = BLK_STS_IOERR; |
382 | goto unlock; | |
dc4d137e NC |
383 | } |
384 | ||
385 | /* | |
386 | * Regular writes must be at the write pointer position. | |
387 | * Zone append writes are automatically issued at the write | |
388 | * pointer and the position returned using the request or BIO | |
389 | * sector. | |
390 | */ | |
391 | if (append) { | |
392 | sector = zone->wp; | |
8b631f9c | 393 | blk_mq_rq_from_pdu(cmd)->__sector = sector; |
dc4d137e | 394 | } else if (sector != zone->wp) { |
aa1c09cb DLM |
395 | ret = BLK_STS_IOERR; |
396 | goto unlock; | |
dc4d137e NC |
397 | } |
398 | ||
aa1c09cb DLM |
399 | if (zone->wp + nr_sectors > zone->start + zone->capacity) { |
400 | ret = BLK_STS_IOERR; | |
401 | goto unlock; | |
402 | } | |
dc4d137e | 403 | |
2b8b7ed7 DLM |
404 | if (zone->cond == BLK_ZONE_COND_CLOSED || |
405 | zone->cond == BLK_ZONE_COND_EMPTY) { | |
406 | null_lock_zone_res(dev); | |
407 | ||
408 | ret = null_check_zone_resources(dev, zone); | |
409 | if (ret != BLK_STS_OK) { | |
410 | null_unlock_zone_res(dev); | |
411 | goto unlock; | |
412 | } | |
413 | if (zone->cond == BLK_ZONE_COND_CLOSED) { | |
414 | dev->nr_zones_closed--; | |
415 | dev->nr_zones_imp_open++; | |
416 | } else if (zone->cond == BLK_ZONE_COND_EMPTY) { | |
417 | dev->nr_zones_imp_open++; | |
418 | } | |
419 | ||
420 | if (zone->cond != BLK_ZONE_COND_EXP_OPEN) | |
421 | zone->cond = BLK_ZONE_COND_IMP_OPEN; | |
422 | ||
423 | null_unlock_zone_res(dev); | |
dc4d137e | 424 | } |
dc4d137e NC |
425 | |
426 | ret = null_process_cmd(cmd, REQ_OP_WRITE, sector, nr_sectors); | |
427 | if (ret != BLK_STS_OK) | |
aa1c09cb | 428 | goto unlock; |
dc4d137e NC |
429 | |
430 | zone->wp += nr_sectors; | |
431 | if (zone->wp == zone->start + zone->capacity) { | |
2b8b7ed7 | 432 | null_lock_zone_res(dev); |
dc4d137e NC |
433 | if (zone->cond == BLK_ZONE_COND_EXP_OPEN) |
434 | dev->nr_zones_exp_open--; | |
435 | else if (zone->cond == BLK_ZONE_COND_IMP_OPEN) | |
436 | dev->nr_zones_imp_open--; | |
437 | zone->cond = BLK_ZONE_COND_FULL; | |
2b8b7ed7 | 438 | null_unlock_zone_res(dev); |
dc4d137e | 439 | } |
2b8b7ed7 | 440 | |
aa1c09cb DLM |
441 | ret = BLK_STS_OK; |
442 | ||
443 | unlock: | |
2b8b7ed7 | 444 | null_unlock_zone(dev, zone); |
aa1c09cb DLM |
445 | |
446 | return ret; | |
dc4d137e NC |
447 | } |
448 | ||
2b8b7ed7 DLM |
449 | static blk_status_t null_open_zone(struct nullb_device *dev, |
450 | struct nullb_zone *zone) | |
dc4d137e | 451 | { |
2b8b7ed7 | 452 | blk_status_t ret = BLK_STS_OK; |
fd78874b | 453 | |
dc4d137e NC |
454 | if (zone->type == BLK_ZONE_TYPE_CONVENTIONAL) |
455 | return BLK_STS_IOERR; | |
456 | ||
2b8b7ed7 DLM |
457 | null_lock_zone_res(dev); |
458 | ||
dc4d137e NC |
459 | switch (zone->cond) { |
460 | case BLK_ZONE_COND_EXP_OPEN: | |
461 | /* open operation on exp open is not an error */ | |
2b8b7ed7 | 462 | goto unlock; |
dc4d137e | 463 | case BLK_ZONE_COND_EMPTY: |
fd78874b KB |
464 | ret = null_check_zone_resources(dev, zone); |
465 | if (ret != BLK_STS_OK) | |
2b8b7ed7 | 466 | goto unlock; |
dc4d137e NC |
467 | break; |
468 | case BLK_ZONE_COND_IMP_OPEN: | |
469 | dev->nr_zones_imp_open--; | |
470 | break; | |
16c731fe | 471 | case BLK_ZONE_COND_CLOSED: |
fd78874b KB |
472 | ret = null_check_zone_resources(dev, zone); |
473 | if (ret != BLK_STS_OK) | |
2b8b7ed7 | 474 | goto unlock; |
dc4d137e NC |
475 | dev->nr_zones_closed--; |
476 | break; | |
477 | case BLK_ZONE_COND_FULL: | |
478 | default: | |
2b8b7ed7 DLM |
479 | ret = BLK_STS_IOERR; |
480 | goto unlock; | |
dc4d137e NC |
481 | } |
482 | ||
483 | zone->cond = BLK_ZONE_COND_EXP_OPEN; | |
484 | dev->nr_zones_exp_open++; | |
ca4b2a01 | 485 | |
2b8b7ed7 DLM |
486 | unlock: |
487 | null_unlock_zone_res(dev); | |
488 | ||
489 | return ret; | |
dc4d137e NC |
490 | } |
491 | ||
2b8b7ed7 DLM |
492 | static blk_status_t null_close_zone(struct nullb_device *dev, |
493 | struct nullb_zone *zone) | |
dc4d137e | 494 | { |
fd78874b KB |
495 | blk_status_t ret; |
496 | ||
dc4d137e NC |
497 | if (zone->type == BLK_ZONE_TYPE_CONVENTIONAL) |
498 | return BLK_STS_IOERR; | |
499 | ||
2b8b7ed7 DLM |
500 | null_lock_zone_res(dev); |
501 | ret = __null_close_zone(dev, zone); | |
502 | null_unlock_zone_res(dev); | |
503 | ||
504 | return ret; | |
505 | } | |
506 | ||
507 | static blk_status_t null_finish_zone(struct nullb_device *dev, | |
508 | struct nullb_zone *zone) | |
509 | { | |
510 | blk_status_t ret = BLK_STS_OK; | |
511 | ||
512 | if (zone->type == BLK_ZONE_TYPE_CONVENTIONAL) | |
513 | return BLK_STS_IOERR; | |
514 | ||
515 | null_lock_zone_res(dev); | |
516 | ||
dc4d137e NC |
517 | switch (zone->cond) { |
518 | case BLK_ZONE_COND_FULL: | |
519 | /* finish operation on full is not an error */ | |
2b8b7ed7 | 520 | goto unlock; |
dc4d137e | 521 | case BLK_ZONE_COND_EMPTY: |
fd78874b KB |
522 | ret = null_check_zone_resources(dev, zone); |
523 | if (ret != BLK_STS_OK) | |
2b8b7ed7 | 524 | goto unlock; |
dc4d137e NC |
525 | break; |
526 | case BLK_ZONE_COND_IMP_OPEN: | |
527 | dev->nr_zones_imp_open--; | |
528 | break; | |
529 | case BLK_ZONE_COND_EXP_OPEN: | |
530 | dev->nr_zones_exp_open--; | |
531 | break; | |
532 | case BLK_ZONE_COND_CLOSED: | |
fd78874b KB |
533 | ret = null_check_zone_resources(dev, zone); |
534 | if (ret != BLK_STS_OK) | |
2b8b7ed7 | 535 | goto unlock; |
dc4d137e NC |
536 | dev->nr_zones_closed--; |
537 | break; | |
538 | default: | |
2b8b7ed7 DLM |
539 | ret = BLK_STS_IOERR; |
540 | goto unlock; | |
dc4d137e | 541 | } |
089565fb | 542 | |
dc4d137e NC |
543 | zone->cond = BLK_ZONE_COND_FULL; |
544 | zone->wp = zone->start + zone->len; | |
ca4b2a01 | 545 | |
2b8b7ed7 DLM |
546 | unlock: |
547 | null_unlock_zone_res(dev); | |
548 | ||
549 | return ret; | |
dc4d137e NC |
550 | } |
551 | ||
2b8b7ed7 DLM |
552 | static blk_status_t null_reset_zone(struct nullb_device *dev, |
553 | struct nullb_zone *zone) | |
dc4d137e NC |
554 | { |
555 | if (zone->type == BLK_ZONE_TYPE_CONVENTIONAL) | |
556 | return BLK_STS_IOERR; | |
9dd44c7e | 557 | |
2b8b7ed7 DLM |
558 | null_lock_zone_res(dev); |
559 | ||
dc4d137e NC |
560 | switch (zone->cond) { |
561 | case BLK_ZONE_COND_EMPTY: | |
562 | /* reset operation on empty is not an error */ | |
2b8b7ed7 | 563 | null_unlock_zone_res(dev); |
9dd44c7e | 564 | return BLK_STS_OK; |
dc4d137e NC |
565 | case BLK_ZONE_COND_IMP_OPEN: |
566 | dev->nr_zones_imp_open--; | |
567 | break; | |
568 | case BLK_ZONE_COND_EXP_OPEN: | |
569 | dev->nr_zones_exp_open--; | |
570 | break; | |
571 | case BLK_ZONE_COND_CLOSED: | |
572 | dev->nr_zones_closed--; | |
573 | break; | |
574 | case BLK_ZONE_COND_FULL: | |
575 | break; | |
ca4b2a01 | 576 | default: |
2b8b7ed7 | 577 | null_unlock_zone_res(dev); |
fceb5d1b | 578 | return BLK_STS_IOERR; |
ca4b2a01 | 579 | } |
dc4d137e NC |
580 | |
581 | zone->cond = BLK_ZONE_COND_EMPTY; | |
582 | zone->wp = zone->start; | |
583 | ||
2b8b7ed7 DLM |
584 | null_unlock_zone_res(dev); |
585 | ||
0ec4d913 DLM |
586 | if (dev->memory_backed) |
587 | return null_handle_discard(dev, zone->start, zone->len); | |
588 | ||
dc4d137e | 589 | return BLK_STS_OK; |
ca4b2a01 MB |
590 | } |
591 | ||
ff07a02e | 592 | static blk_status_t null_zone_mgmt(struct nullb_cmd *cmd, enum req_op op, |
da644b2c | 593 | sector_t sector) |
ca4b2a01 MB |
594 | { |
595 | struct nullb_device *dev = cmd->nq->dev; | |
aa1c09cb | 596 | unsigned int zone_no; |
2b8b7ed7 | 597 | struct nullb_zone *zone; |
aa1c09cb | 598 | blk_status_t ret; |
a61dbfb1 CK |
599 | size_t i; |
600 | ||
aa1c09cb | 601 | if (op == REQ_OP_ZONE_RESET_ALL) { |
f9c91042 DLM |
602 | for (i = dev->zone_nr_conv; i < dev->nr_zones; i++) { |
603 | zone = &dev->zones[i]; | |
2b8b7ed7 | 604 | null_lock_zone(dev, zone); |
d3a57388 SK |
605 | if (zone->cond != BLK_ZONE_COND_EMPTY && |
606 | zone->cond != BLK_ZONE_COND_READONLY && | |
607 | zone->cond != BLK_ZONE_COND_OFFLINE) { | |
f9c91042 DLM |
608 | null_reset_zone(dev, zone); |
609 | trace_nullb_zone_op(cmd, i, zone->cond); | |
610 | } | |
2b8b7ed7 | 611 | null_unlock_zone(dev, zone); |
f9c91042 DLM |
612 | } |
613 | return BLK_STS_OK; | |
aa1c09cb DLM |
614 | } |
615 | ||
616 | zone_no = null_zone_no(dev, sector); | |
617 | zone = &dev->zones[zone_no]; | |
618 | ||
2b8b7ed7 | 619 | null_lock_zone(dev, zone); |
aa1c09cb | 620 | |
d3a57388 SK |
621 | if (zone->cond == BLK_ZONE_COND_READONLY || |
622 | zone->cond == BLK_ZONE_COND_OFFLINE) { | |
623 | ret = BLK_STS_IOERR; | |
624 | goto unlock; | |
625 | } | |
626 | ||
aa1c09cb | 627 | switch (op) { |
a61dbfb1 | 628 | case REQ_OP_ZONE_RESET: |
dc4d137e | 629 | ret = null_reset_zone(dev, zone); |
a61dbfb1 | 630 | break; |
da644b2c | 631 | case REQ_OP_ZONE_OPEN: |
dc4d137e | 632 | ret = null_open_zone(dev, zone); |
da644b2c AJ |
633 | break; |
634 | case REQ_OP_ZONE_CLOSE: | |
dc4d137e | 635 | ret = null_close_zone(dev, zone); |
da644b2c AJ |
636 | break; |
637 | case REQ_OP_ZONE_FINISH: | |
dc4d137e | 638 | ret = null_finish_zone(dev, zone); |
da644b2c | 639 | break; |
a61dbfb1 | 640 | default: |
aa1c09cb DLM |
641 | ret = BLK_STS_NOTSUPP; |
642 | break; | |
ea2c18e1 | 643 | } |
766c3297 | 644 | |
dc4d137e NC |
645 | if (ret == BLK_STS_OK) |
646 | trace_nullb_zone_op(cmd, zone_no, zone->cond); | |
647 | ||
d3a57388 | 648 | unlock: |
2b8b7ed7 | 649 | null_unlock_zone(dev, zone); |
aa1c09cb | 650 | |
dc4d137e | 651 | return ret; |
fceb5d1b CK |
652 | } |
653 | ||
ff07a02e | 654 | blk_status_t null_process_zoned_cmd(struct nullb_cmd *cmd, enum req_op op, |
9dd44c7e | 655 | sector_t sector, sector_t nr_sectors) |
fceb5d1b | 656 | { |
2b8b7ed7 DLM |
657 | struct nullb_device *dev; |
658 | struct nullb_zone *zone; | |
aa1c09cb | 659 | blk_status_t sts; |
35bc10b2 | 660 | |
fceb5d1b CK |
661 | switch (op) { |
662 | case REQ_OP_WRITE: | |
2b8b7ed7 | 663 | return null_zone_write(cmd, sector, nr_sectors, false); |
e0489ed5 | 664 | case REQ_OP_ZONE_APPEND: |
2b8b7ed7 | 665 | return null_zone_write(cmd, sector, nr_sectors, true); |
fceb5d1b CK |
666 | case REQ_OP_ZONE_RESET: |
667 | case REQ_OP_ZONE_RESET_ALL: | |
da644b2c AJ |
668 | case REQ_OP_ZONE_OPEN: |
669 | case REQ_OP_ZONE_CLOSE: | |
670 | case REQ_OP_ZONE_FINISH: | |
2b8b7ed7 | 671 | return null_zone_mgmt(cmd, op, sector); |
fceb5d1b | 672 | default: |
2b8b7ed7 DLM |
673 | dev = cmd->nq->dev; |
674 | zone = &dev->zones[null_zone_no(dev, sector)]; | |
d3a57388 SK |
675 | if (zone->cond == BLK_ZONE_COND_OFFLINE) |
676 | return BLK_STS_IOERR; | |
2b8b7ed7 DLM |
677 | |
678 | null_lock_zone(dev, zone); | |
35bc10b2 | 679 | sts = null_process_cmd(cmd, op, sector, nr_sectors); |
2b8b7ed7 DLM |
680 | null_unlock_zone(dev, zone); |
681 | return sts; | |
fceb5d1b | 682 | } |
ca4b2a01 | 683 | } |
d3a57388 SK |
684 | |
685 | /* | |
686 | * Set a zone in the read-only or offline condition. | |
687 | */ | |
688 | static void null_set_zone_cond(struct nullb_device *dev, | |
689 | struct nullb_zone *zone, enum blk_zone_cond cond) | |
690 | { | |
691 | if (WARN_ON_ONCE(cond != BLK_ZONE_COND_READONLY && | |
692 | cond != BLK_ZONE_COND_OFFLINE)) | |
693 | return; | |
694 | ||
695 | null_lock_zone(dev, zone); | |
696 | ||
697 | /* | |
698 | * If the read-only condition is requested again to zones already in | |
699 | * read-only condition, restore back normal empty condition. Do the same | |
700 | * if the offline condition is requested for offline zones. Otherwise, | |
701 | * set the specified zone condition to the zones. Finish the zones | |
702 | * beforehand to free up zone resources. | |
703 | */ | |
704 | if (zone->cond == cond) { | |
705 | zone->cond = BLK_ZONE_COND_EMPTY; | |
706 | zone->wp = zone->start; | |
707 | if (dev->memory_backed) | |
708 | null_handle_discard(dev, zone->start, zone->len); | |
709 | } else { | |
710 | if (zone->cond != BLK_ZONE_COND_READONLY && | |
711 | zone->cond != BLK_ZONE_COND_OFFLINE) | |
712 | null_finish_zone(dev, zone); | |
713 | zone->cond = cond; | |
714 | zone->wp = (sector_t)-1; | |
715 | } | |
716 | ||
717 | null_unlock_zone(dev, zone); | |
718 | } | |
719 | ||
720 | /* | |
721 | * Identify a zone from the sector written to configfs file. Then set zone | |
722 | * condition to the zone. | |
723 | */ | |
724 | ssize_t zone_cond_store(struct nullb_device *dev, const char *page, | |
725 | size_t count, enum blk_zone_cond cond) | |
726 | { | |
727 | unsigned long long sector; | |
728 | unsigned int zone_no; | |
729 | int ret; | |
730 | ||
731 | if (!dev->zoned) { | |
732 | pr_err("null_blk device is not zoned\n"); | |
733 | return -EINVAL; | |
734 | } | |
735 | ||
736 | if (!dev->zones) { | |
737 | pr_err("null_blk device is not yet powered\n"); | |
738 | return -EINVAL; | |
739 | } | |
740 | ||
741 | ret = kstrtoull(page, 0, §or); | |
742 | if (ret < 0) | |
743 | return ret; | |
744 | ||
745 | zone_no = null_zone_no(dev, sector); | |
746 | if (zone_no >= dev->nr_zones) { | |
747 | pr_err("Sector out of range\n"); | |
748 | return -EINVAL; | |
749 | } | |
750 | ||
751 | if (dev->zones[zone_no].type == BLK_ZONE_TYPE_CONVENTIONAL) { | |
752 | pr_err("Can not change condition of conventional zones\n"); | |
753 | return -EINVAL; | |
754 | } | |
755 | ||
756 | null_set_zone_cond(dev, &dev->zones[zone_no], cond); | |
757 | ||
758 | return count; | |
759 | } |