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 | ||
d205bde7 | 61 | int null_init_zoned_dev(struct nullb_device *dev, struct request_queue *q) |
ca4b2a01 | 62 | { |
0ebcdd70 | 63 | sector_t dev_capacity_sects, zone_capacity_sects; |
2b8b7ed7 | 64 | struct nullb_zone *zone; |
ca4b2a01 MB |
65 | sector_t sector = 0; |
66 | unsigned int i; | |
67 | ||
68 | if (!is_power_of_2(dev->zone_size)) { | |
9c7eddf1 | 69 | pr_err("zone_size must be power-of-two\n"); |
ca4b2a01 MB |
70 | return -EINVAL; |
71 | } | |
e2748325 CK |
72 | if (dev->zone_size > dev->size) { |
73 | pr_err("Zone size larger than device capacity\n"); | |
74 | return -EINVAL; | |
75 | } | |
ca4b2a01 | 76 | |
089565fb AR |
77 | if (!dev->zone_capacity) |
78 | dev->zone_capacity = dev->zone_size; | |
79 | ||
80 | if (dev->zone_capacity > dev->zone_size) { | |
db060f54 DLM |
81 | pr_err("zone capacity (%lu MB) larger than zone size (%lu MB)\n", |
82 | dev->zone_capacity, dev->zone_size); | |
089565fb AR |
83 | return -EINVAL; |
84 | } | |
85 | ||
cd92cdb9 DLM |
86 | zone_capacity_sects = mb_to_sects(dev->zone_capacity); |
87 | dev_capacity_sects = mb_to_sects(dev->size); | |
88 | dev->zone_size_sects = mb_to_sects(dev->zone_size); | |
89 | dev->nr_zones = round_up(dev_capacity_sects, dev->zone_size_sects) | |
90 | >> ilog2(dev->zone_size_sects); | |
0ebcdd70 | 91 | |
2b8b7ed7 DLM |
92 | dev->zones = kvmalloc_array(dev->nr_zones, sizeof(struct nullb_zone), |
93 | GFP_KERNEL | __GFP_ZERO); | |
ca4b2a01 MB |
94 | if (!dev->zones) |
95 | return -ENOMEM; | |
96 | ||
2b8b7ed7 | 97 | spin_lock_init(&dev->zone_res_lock); |
aa1c09cb | 98 | |
ea2c18e1 MS |
99 | if (dev->zone_nr_conv >= dev->nr_zones) { |
100 | dev->zone_nr_conv = dev->nr_zones - 1; | |
9c7eddf1 | 101 | pr_info("changed the number of conventional zones to %u", |
ea2c18e1 MS |
102 | dev->zone_nr_conv); |
103 | } | |
104 | ||
dc4d137e NC |
105 | /* Max active zones has to be < nbr of seq zones in order to be enforceable */ |
106 | if (dev->zone_max_active >= dev->nr_zones - dev->zone_nr_conv) { | |
107 | dev->zone_max_active = 0; | |
108 | pr_info("zone_max_active limit disabled, limit >= zone count\n"); | |
109 | } | |
110 | ||
111 | /* Max open zones has to be <= max active zones */ | |
112 | if (dev->zone_max_active && dev->zone_max_open > dev->zone_max_active) { | |
113 | dev->zone_max_open = dev->zone_max_active; | |
114 | pr_info("changed the maximum number of open zones to %u\n", | |
115 | dev->nr_zones); | |
116 | } else if (dev->zone_max_open >= dev->nr_zones - dev->zone_nr_conv) { | |
117 | dev->zone_max_open = 0; | |
118 | pr_info("zone_max_open limit disabled, limit >= zone count\n"); | |
119 | } | |
2b8b7ed7 | 120 | dev->need_zone_res_mgmt = dev->zone_max_active || dev->zone_max_open; |
2e8c6e0e | 121 | dev->imp_close_zone_no = dev->zone_nr_conv; |
dc4d137e | 122 | |
ea2c18e1 | 123 | for (i = 0; i < dev->zone_nr_conv; i++) { |
2b8b7ed7 | 124 | zone = &dev->zones[i]; |
ea2c18e1 | 125 | |
2b8b7ed7 | 126 | null_init_zone_lock(dev, zone); |
ea2c18e1 MS |
127 | zone->start = sector; |
128 | zone->len = dev->zone_size_sects; | |
82394db7 | 129 | zone->capacity = zone->len; |
ea2c18e1 MS |
130 | zone->wp = zone->start + zone->len; |
131 | zone->type = BLK_ZONE_TYPE_CONVENTIONAL; | |
132 | zone->cond = BLK_ZONE_COND_NOT_WP; | |
133 | ||
134 | sector += dev->zone_size_sects; | |
135 | } | |
136 | ||
137 | for (i = dev->zone_nr_conv; i < dev->nr_zones; i++) { | |
2b8b7ed7 | 138 | zone = &dev->zones[i]; |
ca4b2a01 | 139 | |
2b8b7ed7 | 140 | null_init_zone_lock(dev, zone); |
ca4b2a01 | 141 | zone->start = zone->wp = sector; |
0ebcdd70 DLM |
142 | if (zone->start + dev->zone_size_sects > dev_capacity_sects) |
143 | zone->len = dev_capacity_sects - zone->start; | |
144 | else | |
145 | zone->len = dev->zone_size_sects; | |
146 | zone->capacity = | |
147 | min_t(sector_t, zone->len, zone_capacity_sects); | |
ca4b2a01 MB |
148 | zone->type = BLK_ZONE_TYPE_SEQWRITE_REQ; |
149 | zone->cond = BLK_ZONE_COND_EMPTY; | |
150 | ||
151 | sector += dev->zone_size_sects; | |
152 | } | |
153 | ||
d205bde7 DLM |
154 | return 0; |
155 | } | |
156 | ||
157 | int null_register_zoned_dev(struct nullb *nullb) | |
158 | { | |
e0489ed5 | 159 | struct nullb_device *dev = nullb->dev; |
d205bde7 DLM |
160 | struct request_queue *q = nullb->q; |
161 | ||
6b2bd274 | 162 | disk_set_zoned(nullb->disk, BLK_ZONED_HM); |
5752dc78 DLM |
163 | blk_queue_flag_set(QUEUE_FLAG_ZONE_RESETALL, q); |
164 | blk_queue_required_elevator_features(q, ELEVATOR_F_ZBD_SEQ_WRITE); | |
165 | ||
e0489ed5 DLM |
166 | if (queue_is_mq(q)) { |
167 | int ret = blk_revalidate_disk_zones(nullb->disk, NULL); | |
168 | ||
169 | if (ret) | |
170 | return ret; | |
171 | } else { | |
172 | blk_queue_chunk_sectors(q, dev->zone_size_sects); | |
d86e716a | 173 | nullb->disk->nr_zones = bdev_nr_zones(nullb->disk->part0); |
e0489ed5 | 174 | } |
d205bde7 | 175 | |
e0489ed5 | 176 | blk_queue_max_zone_append_sectors(q, dev->zone_size_sects); |
982977df CH |
177 | disk_set_max_open_zones(nullb->disk, dev->zone_max_open); |
178 | disk_set_max_active_zones(nullb->disk, dev->zone_max_active); | |
d205bde7 | 179 | |
ca4b2a01 MB |
180 | return 0; |
181 | } | |
182 | ||
d205bde7 | 183 | void null_free_zoned_dev(struct nullb_device *dev) |
ca4b2a01 MB |
184 | { |
185 | kvfree(dev->zones); | |
72ce11dd | 186 | dev->zones = NULL; |
ca4b2a01 MB |
187 | } |
188 | ||
7fc8fb51 | 189 | int null_report_zones(struct gendisk *disk, sector_t sector, |
d4100351 | 190 | unsigned int nr_zones, report_zones_cb cb, void *data) |
ca4b2a01 | 191 | { |
e76239a3 CH |
192 | struct nullb *nullb = disk->private_data; |
193 | struct nullb_device *dev = nullb->dev; | |
2b8b7ed7 DLM |
194 | unsigned int first_zone, i; |
195 | struct nullb_zone *zone; | |
196 | struct blk_zone blkz; | |
d4100351 | 197 | int error; |
ca4b2a01 | 198 | |
d4100351 CH |
199 | first_zone = null_zone_no(dev, sector); |
200 | if (first_zone >= dev->nr_zones) | |
201 | return 0; | |
ca4b2a01 | 202 | |
d4100351 | 203 | nr_zones = min(nr_zones, dev->nr_zones - first_zone); |
766c3297 CK |
204 | trace_nullb_report_zones(nullb, nr_zones); |
205 | ||
2b8b7ed7 DLM |
206 | memset(&blkz, 0, sizeof(struct blk_zone)); |
207 | zone = &dev->zones[first_zone]; | |
208 | for (i = 0; i < nr_zones; i++, zone++) { | |
d4100351 CH |
209 | /* |
210 | * Stacked DM target drivers will remap the zone information by | |
211 | * modifying the zone information passed to the report callback. | |
212 | * So use a local copy to avoid corruption of the device zone | |
213 | * array. | |
214 | */ | |
2b8b7ed7 DLM |
215 | null_lock_zone(dev, zone); |
216 | blkz.start = zone->start; | |
217 | blkz.len = zone->len; | |
218 | blkz.wp = zone->wp; | |
219 | blkz.type = zone->type; | |
220 | blkz.cond = zone->cond; | |
221 | blkz.capacity = zone->capacity; | |
222 | null_unlock_zone(dev, zone); | |
223 | ||
224 | error = cb(&blkz, i, data); | |
d4100351 CH |
225 | if (error) |
226 | return error; | |
227 | } | |
ca4b2a01 | 228 | |
d4100351 | 229 | return nr_zones; |
ca4b2a01 MB |
230 | } |
231 | ||
aa1c09cb DLM |
232 | /* |
233 | * This is called in the case of memory backing from null_process_cmd() | |
234 | * with the target zone already locked. | |
235 | */ | |
dd85b492 AJ |
236 | size_t null_zone_valid_read_len(struct nullb *nullb, |
237 | sector_t sector, unsigned int len) | |
238 | { | |
239 | struct nullb_device *dev = nullb->dev; | |
2b8b7ed7 | 240 | struct nullb_zone *zone = &dev->zones[null_zone_no(dev, sector)]; |
dd85b492 AJ |
241 | unsigned int nr_sectors = len >> SECTOR_SHIFT; |
242 | ||
243 | /* Read must be below the write pointer position */ | |
244 | if (zone->type == BLK_ZONE_TYPE_CONVENTIONAL || | |
245 | sector + nr_sectors <= zone->wp) | |
246 | return len; | |
247 | ||
248 | if (sector > zone->wp) | |
249 | return 0; | |
250 | ||
251 | return (zone->wp - sector) << SECTOR_SHIFT; | |
252 | } | |
253 | ||
2b8b7ed7 DLM |
254 | static blk_status_t __null_close_zone(struct nullb_device *dev, |
255 | struct nullb_zone *zone) | |
dc4d137e | 256 | { |
dc4d137e NC |
257 | switch (zone->cond) { |
258 | case BLK_ZONE_COND_CLOSED: | |
259 | /* close operation on closed is not an error */ | |
260 | return BLK_STS_OK; | |
261 | case BLK_ZONE_COND_IMP_OPEN: | |
262 | dev->nr_zones_imp_open--; | |
263 | break; | |
264 | case BLK_ZONE_COND_EXP_OPEN: | |
265 | dev->nr_zones_exp_open--; | |
266 | break; | |
267 | case BLK_ZONE_COND_EMPTY: | |
268 | case BLK_ZONE_COND_FULL: | |
269 | default: | |
270 | return BLK_STS_IOERR; | |
271 | } | |
272 | ||
273 | if (zone->wp == zone->start) { | |
274 | zone->cond = BLK_ZONE_COND_EMPTY; | |
275 | } else { | |
276 | zone->cond = BLK_ZONE_COND_CLOSED; | |
277 | dev->nr_zones_closed++; | |
278 | } | |
279 | ||
280 | return BLK_STS_OK; | |
281 | } | |
282 | ||
2e8c6e0e | 283 | static void null_close_imp_open_zone(struct nullb_device *dev) |
dc4d137e | 284 | { |
2e8c6e0e DLM |
285 | struct nullb_zone *zone; |
286 | unsigned int zno, i; | |
287 | ||
288 | zno = dev->imp_close_zone_no; | |
289 | if (zno >= dev->nr_zones) | |
290 | zno = dev->zone_nr_conv; | |
dc4d137e NC |
291 | |
292 | for (i = dev->zone_nr_conv; i < dev->nr_zones; i++) { | |
2e8c6e0e DLM |
293 | zone = &dev->zones[zno]; |
294 | zno++; | |
295 | if (zno >= dev->nr_zones) | |
296 | zno = dev->zone_nr_conv; | |
297 | ||
298 | if (zone->cond == BLK_ZONE_COND_IMP_OPEN) { | |
299 | __null_close_zone(dev, zone); | |
300 | dev->imp_close_zone_no = zno; | |
dc4d137e NC |
301 | return; |
302 | } | |
303 | } | |
304 | } | |
305 | ||
fd78874b | 306 | static blk_status_t null_check_active(struct nullb_device *dev) |
dc4d137e NC |
307 | { |
308 | if (!dev->zone_max_active) | |
fd78874b KB |
309 | return BLK_STS_OK; |
310 | ||
311 | if (dev->nr_zones_exp_open + dev->nr_zones_imp_open + | |
312 | dev->nr_zones_closed < dev->zone_max_active) | |
313 | return BLK_STS_OK; | |
dc4d137e | 314 | |
fd78874b | 315 | return BLK_STS_ZONE_ACTIVE_RESOURCE; |
dc4d137e NC |
316 | } |
317 | ||
fd78874b | 318 | static blk_status_t null_check_open(struct nullb_device *dev) |
dc4d137e NC |
319 | { |
320 | if (!dev->zone_max_open) | |
fd78874b | 321 | return BLK_STS_OK; |
dc4d137e NC |
322 | |
323 | if (dev->nr_zones_exp_open + dev->nr_zones_imp_open < dev->zone_max_open) | |
fd78874b | 324 | return BLK_STS_OK; |
dc4d137e | 325 | |
fd78874b KB |
326 | if (dev->nr_zones_imp_open) { |
327 | if (null_check_active(dev) == BLK_STS_OK) { | |
2e8c6e0e | 328 | null_close_imp_open_zone(dev); |
fd78874b KB |
329 | return BLK_STS_OK; |
330 | } | |
dc4d137e NC |
331 | } |
332 | ||
fd78874b | 333 | return BLK_STS_ZONE_OPEN_RESOURCE; |
dc4d137e NC |
334 | } |
335 | ||
336 | /* | |
337 | * This function matches the manage open zone resources function in the ZBC standard, | |
338 | * with the addition of max active zones support (added in the ZNS standard). | |
339 | * | |
340 | * The function determines if a zone can transition to implicit open or explicit open, | |
341 | * while maintaining the max open zone (and max active zone) limit(s). It may close an | |
342 | * implicit open zone in order to make additional zone resources available. | |
343 | * | |
344 | * ZBC states that an implicit open zone shall be closed only if there is not | |
345 | * room within the open limit. However, with the addition of an active limit, | |
346 | * it is not certain that closing an implicit open zone will allow a new zone | |
347 | * to be opened, since we might already be at the active limit capacity. | |
348 | */ | |
2b8b7ed7 DLM |
349 | static blk_status_t null_check_zone_resources(struct nullb_device *dev, |
350 | struct nullb_zone *zone) | |
dc4d137e | 351 | { |
fd78874b KB |
352 | blk_status_t ret; |
353 | ||
dc4d137e NC |
354 | switch (zone->cond) { |
355 | case BLK_ZONE_COND_EMPTY: | |
fd78874b KB |
356 | ret = null_check_active(dev); |
357 | if (ret != BLK_STS_OK) | |
358 | return ret; | |
dc4d137e NC |
359 | fallthrough; |
360 | case BLK_ZONE_COND_CLOSED: | |
fd78874b | 361 | return null_check_open(dev); |
dc4d137e NC |
362 | default: |
363 | /* Should never be called for other states */ | |
364 | WARN_ON(1); | |
fd78874b | 365 | return BLK_STS_IOERR; |
dc4d137e NC |
366 | } |
367 | } | |
368 | ||
fceb5d1b | 369 | static blk_status_t null_zone_write(struct nullb_cmd *cmd, sector_t sector, |
e0489ed5 | 370 | unsigned int nr_sectors, bool append) |
ca4b2a01 MB |
371 | { |
372 | struct nullb_device *dev = cmd->nq->dev; | |
ca4b2a01 | 373 | unsigned int zno = null_zone_no(dev, sector); |
2b8b7ed7 | 374 | struct nullb_zone *zone = &dev->zones[zno]; |
9dd44c7e DLM |
375 | blk_status_t ret; |
376 | ||
377 | trace_nullb_zone_op(cmd, zno, zone->cond); | |
378 | ||
2e896d89 DLM |
379 | if (zone->type == BLK_ZONE_TYPE_CONVENTIONAL) { |
380 | if (append) | |
381 | return BLK_STS_IOERR; | |
9dd44c7e | 382 | return null_process_cmd(cmd, REQ_OP_WRITE, sector, nr_sectors); |
2e896d89 | 383 | } |
ca4b2a01 | 384 | |
2b8b7ed7 | 385 | null_lock_zone(dev, zone); |
aa1c09cb | 386 | |
2b8b7ed7 | 387 | if (zone->cond == BLK_ZONE_COND_FULL) { |
ca4b2a01 | 388 | /* Cannot write to a full zone */ |
aa1c09cb DLM |
389 | ret = BLK_STS_IOERR; |
390 | goto unlock; | |
dc4d137e NC |
391 | } |
392 | ||
393 | /* | |
394 | * Regular writes must be at the write pointer position. | |
395 | * Zone append writes are automatically issued at the write | |
396 | * pointer and the position returned using the request or BIO | |
397 | * sector. | |
398 | */ | |
399 | if (append) { | |
400 | sector = zone->wp; | |
aacae8c4 | 401 | if (dev->queue_mode == NULL_Q_MQ) |
dc4d137e | 402 | cmd->rq->__sector = sector; |
aacae8c4 DLM |
403 | else |
404 | cmd->bio->bi_iter.bi_sector = sector; | |
dc4d137e | 405 | } else if (sector != zone->wp) { |
aa1c09cb DLM |
406 | ret = BLK_STS_IOERR; |
407 | goto unlock; | |
dc4d137e NC |
408 | } |
409 | ||
aa1c09cb DLM |
410 | if (zone->wp + nr_sectors > zone->start + zone->capacity) { |
411 | ret = BLK_STS_IOERR; | |
412 | goto unlock; | |
413 | } | |
dc4d137e | 414 | |
2b8b7ed7 DLM |
415 | if (zone->cond == BLK_ZONE_COND_CLOSED || |
416 | zone->cond == BLK_ZONE_COND_EMPTY) { | |
417 | null_lock_zone_res(dev); | |
418 | ||
419 | ret = null_check_zone_resources(dev, zone); | |
420 | if (ret != BLK_STS_OK) { | |
421 | null_unlock_zone_res(dev); | |
422 | goto unlock; | |
423 | } | |
424 | if (zone->cond == BLK_ZONE_COND_CLOSED) { | |
425 | dev->nr_zones_closed--; | |
426 | dev->nr_zones_imp_open++; | |
427 | } else if (zone->cond == BLK_ZONE_COND_EMPTY) { | |
428 | dev->nr_zones_imp_open++; | |
429 | } | |
430 | ||
431 | if (zone->cond != BLK_ZONE_COND_EXP_OPEN) | |
432 | zone->cond = BLK_ZONE_COND_IMP_OPEN; | |
433 | ||
434 | null_unlock_zone_res(dev); | |
dc4d137e | 435 | } |
dc4d137e NC |
436 | |
437 | ret = null_process_cmd(cmd, REQ_OP_WRITE, sector, nr_sectors); | |
438 | if (ret != BLK_STS_OK) | |
aa1c09cb | 439 | goto unlock; |
dc4d137e NC |
440 | |
441 | zone->wp += nr_sectors; | |
442 | if (zone->wp == zone->start + zone->capacity) { | |
2b8b7ed7 | 443 | null_lock_zone_res(dev); |
dc4d137e NC |
444 | if (zone->cond == BLK_ZONE_COND_EXP_OPEN) |
445 | dev->nr_zones_exp_open--; | |
446 | else if (zone->cond == BLK_ZONE_COND_IMP_OPEN) | |
447 | dev->nr_zones_imp_open--; | |
448 | zone->cond = BLK_ZONE_COND_FULL; | |
2b8b7ed7 | 449 | null_unlock_zone_res(dev); |
dc4d137e | 450 | } |
2b8b7ed7 | 451 | |
aa1c09cb DLM |
452 | ret = BLK_STS_OK; |
453 | ||
454 | unlock: | |
2b8b7ed7 | 455 | null_unlock_zone(dev, zone); |
aa1c09cb DLM |
456 | |
457 | return ret; | |
dc4d137e NC |
458 | } |
459 | ||
2b8b7ed7 DLM |
460 | static blk_status_t null_open_zone(struct nullb_device *dev, |
461 | struct nullb_zone *zone) | |
dc4d137e | 462 | { |
2b8b7ed7 | 463 | blk_status_t ret = BLK_STS_OK; |
fd78874b | 464 | |
dc4d137e NC |
465 | if (zone->type == BLK_ZONE_TYPE_CONVENTIONAL) |
466 | return BLK_STS_IOERR; | |
467 | ||
2b8b7ed7 DLM |
468 | null_lock_zone_res(dev); |
469 | ||
dc4d137e NC |
470 | switch (zone->cond) { |
471 | case BLK_ZONE_COND_EXP_OPEN: | |
472 | /* open operation on exp open is not an error */ | |
2b8b7ed7 | 473 | goto unlock; |
dc4d137e | 474 | case BLK_ZONE_COND_EMPTY: |
fd78874b KB |
475 | ret = null_check_zone_resources(dev, zone); |
476 | if (ret != BLK_STS_OK) | |
2b8b7ed7 | 477 | goto unlock; |
dc4d137e NC |
478 | break; |
479 | case BLK_ZONE_COND_IMP_OPEN: | |
480 | dev->nr_zones_imp_open--; | |
481 | break; | |
16c731fe | 482 | case BLK_ZONE_COND_CLOSED: |
fd78874b KB |
483 | ret = null_check_zone_resources(dev, zone); |
484 | if (ret != BLK_STS_OK) | |
2b8b7ed7 | 485 | goto unlock; |
dc4d137e NC |
486 | dev->nr_zones_closed--; |
487 | break; | |
488 | case BLK_ZONE_COND_FULL: | |
489 | default: | |
2b8b7ed7 DLM |
490 | ret = BLK_STS_IOERR; |
491 | goto unlock; | |
dc4d137e NC |
492 | } |
493 | ||
494 | zone->cond = BLK_ZONE_COND_EXP_OPEN; | |
495 | dev->nr_zones_exp_open++; | |
ca4b2a01 | 496 | |
2b8b7ed7 DLM |
497 | unlock: |
498 | null_unlock_zone_res(dev); | |
499 | ||
500 | return ret; | |
dc4d137e NC |
501 | } |
502 | ||
2b8b7ed7 DLM |
503 | static blk_status_t null_close_zone(struct nullb_device *dev, |
504 | struct nullb_zone *zone) | |
dc4d137e | 505 | { |
fd78874b KB |
506 | blk_status_t ret; |
507 | ||
dc4d137e NC |
508 | if (zone->type == BLK_ZONE_TYPE_CONVENTIONAL) |
509 | return BLK_STS_IOERR; | |
510 | ||
2b8b7ed7 DLM |
511 | null_lock_zone_res(dev); |
512 | ret = __null_close_zone(dev, zone); | |
513 | null_unlock_zone_res(dev); | |
514 | ||
515 | return ret; | |
516 | } | |
517 | ||
518 | static blk_status_t null_finish_zone(struct nullb_device *dev, | |
519 | struct nullb_zone *zone) | |
520 | { | |
521 | blk_status_t ret = BLK_STS_OK; | |
522 | ||
523 | if (zone->type == BLK_ZONE_TYPE_CONVENTIONAL) | |
524 | return BLK_STS_IOERR; | |
525 | ||
526 | null_lock_zone_res(dev); | |
527 | ||
dc4d137e NC |
528 | switch (zone->cond) { |
529 | case BLK_ZONE_COND_FULL: | |
530 | /* finish operation on full is not an error */ | |
2b8b7ed7 | 531 | goto unlock; |
dc4d137e | 532 | case BLK_ZONE_COND_EMPTY: |
fd78874b KB |
533 | ret = null_check_zone_resources(dev, zone); |
534 | if (ret != BLK_STS_OK) | |
2b8b7ed7 | 535 | goto unlock; |
dc4d137e NC |
536 | break; |
537 | case BLK_ZONE_COND_IMP_OPEN: | |
538 | dev->nr_zones_imp_open--; | |
539 | break; | |
540 | case BLK_ZONE_COND_EXP_OPEN: | |
541 | dev->nr_zones_exp_open--; | |
542 | break; | |
543 | case BLK_ZONE_COND_CLOSED: | |
fd78874b KB |
544 | ret = null_check_zone_resources(dev, zone); |
545 | if (ret != BLK_STS_OK) | |
2b8b7ed7 | 546 | goto unlock; |
dc4d137e NC |
547 | dev->nr_zones_closed--; |
548 | break; | |
549 | default: | |
2b8b7ed7 DLM |
550 | ret = BLK_STS_IOERR; |
551 | goto unlock; | |
dc4d137e | 552 | } |
089565fb | 553 | |
dc4d137e NC |
554 | zone->cond = BLK_ZONE_COND_FULL; |
555 | zone->wp = zone->start + zone->len; | |
ca4b2a01 | 556 | |
2b8b7ed7 DLM |
557 | unlock: |
558 | null_unlock_zone_res(dev); | |
559 | ||
560 | return ret; | |
dc4d137e NC |
561 | } |
562 | ||
2b8b7ed7 DLM |
563 | static blk_status_t null_reset_zone(struct nullb_device *dev, |
564 | struct nullb_zone *zone) | |
dc4d137e NC |
565 | { |
566 | if (zone->type == BLK_ZONE_TYPE_CONVENTIONAL) | |
567 | return BLK_STS_IOERR; | |
9dd44c7e | 568 | |
2b8b7ed7 DLM |
569 | null_lock_zone_res(dev); |
570 | ||
dc4d137e NC |
571 | switch (zone->cond) { |
572 | case BLK_ZONE_COND_EMPTY: | |
573 | /* reset operation on empty is not an error */ | |
2b8b7ed7 | 574 | null_unlock_zone_res(dev); |
9dd44c7e | 575 | return BLK_STS_OK; |
dc4d137e NC |
576 | case BLK_ZONE_COND_IMP_OPEN: |
577 | dev->nr_zones_imp_open--; | |
578 | break; | |
579 | case BLK_ZONE_COND_EXP_OPEN: | |
580 | dev->nr_zones_exp_open--; | |
581 | break; | |
582 | case BLK_ZONE_COND_CLOSED: | |
583 | dev->nr_zones_closed--; | |
584 | break; | |
585 | case BLK_ZONE_COND_FULL: | |
586 | break; | |
ca4b2a01 | 587 | default: |
2b8b7ed7 | 588 | null_unlock_zone_res(dev); |
fceb5d1b | 589 | return BLK_STS_IOERR; |
ca4b2a01 | 590 | } |
dc4d137e NC |
591 | |
592 | zone->cond = BLK_ZONE_COND_EMPTY; | |
593 | zone->wp = zone->start; | |
594 | ||
2b8b7ed7 DLM |
595 | null_unlock_zone_res(dev); |
596 | ||
0ec4d913 DLM |
597 | if (dev->memory_backed) |
598 | return null_handle_discard(dev, zone->start, zone->len); | |
599 | ||
dc4d137e | 600 | return BLK_STS_OK; |
ca4b2a01 MB |
601 | } |
602 | ||
ff07a02e | 603 | static blk_status_t null_zone_mgmt(struct nullb_cmd *cmd, enum req_op op, |
da644b2c | 604 | sector_t sector) |
ca4b2a01 MB |
605 | { |
606 | struct nullb_device *dev = cmd->nq->dev; | |
aa1c09cb | 607 | unsigned int zone_no; |
2b8b7ed7 | 608 | struct nullb_zone *zone; |
aa1c09cb | 609 | blk_status_t ret; |
a61dbfb1 CK |
610 | size_t i; |
611 | ||
aa1c09cb | 612 | if (op == REQ_OP_ZONE_RESET_ALL) { |
f9c91042 DLM |
613 | for (i = dev->zone_nr_conv; i < dev->nr_zones; i++) { |
614 | zone = &dev->zones[i]; | |
2b8b7ed7 | 615 | null_lock_zone(dev, zone); |
f9c91042 DLM |
616 | if (zone->cond != BLK_ZONE_COND_EMPTY) { |
617 | null_reset_zone(dev, zone); | |
618 | trace_nullb_zone_op(cmd, i, zone->cond); | |
619 | } | |
2b8b7ed7 | 620 | null_unlock_zone(dev, zone); |
f9c91042 DLM |
621 | } |
622 | return BLK_STS_OK; | |
aa1c09cb DLM |
623 | } |
624 | ||
625 | zone_no = null_zone_no(dev, sector); | |
626 | zone = &dev->zones[zone_no]; | |
627 | ||
2b8b7ed7 | 628 | null_lock_zone(dev, zone); |
aa1c09cb DLM |
629 | |
630 | switch (op) { | |
a61dbfb1 | 631 | case REQ_OP_ZONE_RESET: |
dc4d137e | 632 | ret = null_reset_zone(dev, zone); |
a61dbfb1 | 633 | break; |
da644b2c | 634 | case REQ_OP_ZONE_OPEN: |
dc4d137e | 635 | ret = null_open_zone(dev, zone); |
da644b2c AJ |
636 | break; |
637 | case REQ_OP_ZONE_CLOSE: | |
dc4d137e | 638 | ret = null_close_zone(dev, zone); |
da644b2c AJ |
639 | break; |
640 | case REQ_OP_ZONE_FINISH: | |
dc4d137e | 641 | ret = null_finish_zone(dev, zone); |
da644b2c | 642 | break; |
a61dbfb1 | 643 | default: |
aa1c09cb DLM |
644 | ret = BLK_STS_NOTSUPP; |
645 | break; | |
ea2c18e1 | 646 | } |
766c3297 | 647 | |
dc4d137e NC |
648 | if (ret == BLK_STS_OK) |
649 | trace_nullb_zone_op(cmd, zone_no, zone->cond); | |
650 | ||
2b8b7ed7 | 651 | null_unlock_zone(dev, zone); |
aa1c09cb | 652 | |
dc4d137e | 653 | return ret; |
fceb5d1b CK |
654 | } |
655 | ||
ff07a02e | 656 | blk_status_t null_process_zoned_cmd(struct nullb_cmd *cmd, enum req_op op, |
9dd44c7e | 657 | sector_t sector, sector_t nr_sectors) |
fceb5d1b | 658 | { |
2b8b7ed7 DLM |
659 | struct nullb_device *dev; |
660 | struct nullb_zone *zone; | |
aa1c09cb | 661 | blk_status_t sts; |
35bc10b2 | 662 | |
fceb5d1b CK |
663 | switch (op) { |
664 | case REQ_OP_WRITE: | |
2b8b7ed7 | 665 | return null_zone_write(cmd, sector, nr_sectors, false); |
e0489ed5 | 666 | case REQ_OP_ZONE_APPEND: |
2b8b7ed7 | 667 | return null_zone_write(cmd, sector, nr_sectors, true); |
fceb5d1b CK |
668 | case REQ_OP_ZONE_RESET: |
669 | case REQ_OP_ZONE_RESET_ALL: | |
da644b2c AJ |
670 | case REQ_OP_ZONE_OPEN: |
671 | case REQ_OP_ZONE_CLOSE: | |
672 | case REQ_OP_ZONE_FINISH: | |
2b8b7ed7 | 673 | return null_zone_mgmt(cmd, op, sector); |
fceb5d1b | 674 | default: |
2b8b7ed7 DLM |
675 | dev = cmd->nq->dev; |
676 | zone = &dev->zones[null_zone_no(dev, sector)]; | |
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 | } |