1 // SPDX-License-Identifier: GPL-2.0-only
3 * SCSI Zoned Block commands
5 * Copyright (C) 2014-2015 SUSE Linux GmbH
6 * Written by: Hannes Reinecke <hare@suse.de>
7 * Modified by: Damien Le Moal <damien.lemoal@hgst.com>
8 * Modified by: Shaun Tancheff <shaun.tancheff@seagate.com>
11 #include <linux/blkdev.h>
12 #include <linux/vmalloc.h>
13 #include <linux/sched/mm.h>
14 #include <linux/mutex.h>
16 #include <asm/unaligned.h>
18 #include <scsi/scsi.h>
19 #include <scsi/scsi_cmnd.h>
23 static unsigned int sd_zbc_get_zone_wp_offset(struct blk_zone
*zone
)
25 if (zone
->type
== ZBC_ZONE_TYPE_CONV
)
29 case BLK_ZONE_COND_IMP_OPEN
:
30 case BLK_ZONE_COND_EXP_OPEN
:
31 case BLK_ZONE_COND_CLOSED
:
32 return zone
->wp
- zone
->start
;
33 case BLK_ZONE_COND_FULL
:
35 case BLK_ZONE_COND_EMPTY
:
36 case BLK_ZONE_COND_OFFLINE
:
37 case BLK_ZONE_COND_READONLY
:
40 * Offline and read-only zones do not have a valid
41 * write pointer. Use 0 as for an empty zone.
47 static int sd_zbc_parse_report(struct scsi_disk
*sdkp
, u8
*buf
,
48 unsigned int idx
, report_zones_cb cb
, void *data
)
50 struct scsi_device
*sdp
= sdkp
->device
;
51 struct blk_zone zone
= { 0 };
54 zone
.type
= buf
[0] & 0x0f;
55 zone
.cond
= (buf
[1] >> 4) & 0xf;
61 zone
.len
= logical_to_sectors(sdp
, get_unaligned_be64(&buf
[8]));
62 zone
.start
= logical_to_sectors(sdp
, get_unaligned_be64(&buf
[16]));
63 zone
.wp
= logical_to_sectors(sdp
, get_unaligned_be64(&buf
[24]));
64 if (zone
.type
!= ZBC_ZONE_TYPE_CONV
&&
65 zone
.cond
== ZBC_ZONE_COND_FULL
)
66 zone
.wp
= zone
.start
+ zone
.len
;
68 ret
= cb(&zone
, idx
, data
);
72 if (sdkp
->rev_wp_offset
)
73 sdkp
->rev_wp_offset
[idx
] = sd_zbc_get_zone_wp_offset(&zone
);
79 * sd_zbc_do_report_zones - Issue a REPORT ZONES scsi command.
80 * @sdkp: The target disk
81 * @buf: vmalloc-ed buffer to use for the reply
82 * @buflen: the buffer size
83 * @lba: Start LBA of the report
84 * @partial: Do partial report
86 * For internal use during device validation.
87 * Using partial=true can significantly speed up execution of a report zones
88 * command because the disk does not have to count all possible report matching
89 * zones and will only report the count of zones fitting in the command reply
92 static int sd_zbc_do_report_zones(struct scsi_disk
*sdkp
, unsigned char *buf
,
93 unsigned int buflen
, sector_t lba
,
96 struct scsi_device
*sdp
= sdkp
->device
;
97 const int timeout
= sdp
->request_queue
->rq_timeout
;
98 struct scsi_sense_hdr sshdr
;
99 unsigned char cmd
[16];
100 unsigned int rep_len
;
105 cmd
[1] = ZI_REPORT_ZONES
;
106 put_unaligned_be64(lba
, &cmd
[2]);
107 put_unaligned_be32(buflen
, &cmd
[10]);
109 cmd
[14] = ZBC_REPORT_ZONE_PARTIAL
;
111 result
= scsi_execute_req(sdp
, cmd
, DMA_FROM_DEVICE
,
113 timeout
, SD_MAX_RETRIES
, NULL
);
115 sd_printk(KERN_ERR
, sdkp
,
116 "REPORT ZONES start lba %llu failed\n", lba
);
117 sd_print_result(sdkp
, "REPORT ZONES", result
);
118 if (driver_byte(result
) == DRIVER_SENSE
&&
119 scsi_sense_valid(&sshdr
))
120 sd_print_sense_hdr(sdkp
, &sshdr
);
124 rep_len
= get_unaligned_be32(&buf
[0]);
126 sd_printk(KERN_ERR
, sdkp
,
127 "REPORT ZONES report invalid length %u\n",
136 * Allocate a buffer for report zones reply.
137 * @sdkp: The target disk
138 * @nr_zones: Maximum number of zones to report
139 * @buflen: Size of the buffer allocated
141 * Try to allocate a reply buffer for the number of requested zones.
142 * The size of the buffer allocated may be smaller than requested to
143 * satify the device constraint (max_hw_sectors, max_segments, etc).
145 * Return the address of the allocated buffer and update @buflen with
146 * the size of the allocated buffer.
148 static void *sd_zbc_alloc_report_buffer(struct scsi_disk
*sdkp
,
149 unsigned int nr_zones
, size_t *buflen
)
151 struct request_queue
*q
= sdkp
->disk
->queue
;
156 * Report zone buffer size should be at most 64B times the number of
157 * zones requested plus the 64B reply header, but should be at least
158 * SECTOR_SIZE for ATA devices.
159 * Make sure that this size does not exceed the hardware capabilities.
160 * Furthermore, since the report zone command cannot be split, make
161 * sure that the allocated buffer can always be mapped by limiting the
162 * number of pages allocated to the HBA max segments limit.
164 nr_zones
= min(nr_zones
, sdkp
->nr_zones
);
165 bufsize
= roundup((nr_zones
+ 1) * 64, SECTOR_SIZE
);
166 bufsize
= min_t(size_t, bufsize
,
167 queue_max_hw_sectors(q
) << SECTOR_SHIFT
);
168 bufsize
= min_t(size_t, bufsize
, queue_max_segments(q
) << PAGE_SHIFT
);
170 while (bufsize
>= SECTOR_SIZE
) {
171 buf
= __vmalloc(bufsize
,
172 GFP_KERNEL
| __GFP_ZERO
| __GFP_NORETRY
);
184 * sd_zbc_zone_sectors - Get the device zone size in number of 512B sectors.
185 * @sdkp: The target disk
187 static inline sector_t
sd_zbc_zone_sectors(struct scsi_disk
*sdkp
)
189 return logical_to_sectors(sdkp
->device
, sdkp
->zone_blocks
);
192 int sd_zbc_report_zones(struct gendisk
*disk
, sector_t sector
,
193 unsigned int nr_zones
, report_zones_cb cb
, void *data
)
195 struct scsi_disk
*sdkp
= scsi_disk(disk
);
196 sector_t capacity
= logical_to_sectors(sdkp
->device
, sdkp
->capacity
);
199 size_t offset
, buflen
= 0;
203 if (!sd_is_zoned(sdkp
))
204 /* Not a zoned device */
208 /* Device gone or invalid */
211 buf
= sd_zbc_alloc_report_buffer(sdkp
, nr_zones
, &buflen
);
215 while (zone_idx
< nr_zones
&& sector
< capacity
) {
216 ret
= sd_zbc_do_report_zones(sdkp
, buf
, buflen
,
217 sectors_to_logical(sdkp
->device
, sector
), true);
222 nr
= min(nr_zones
, get_unaligned_be32(&buf
[0]) / 64);
226 for (i
= 0; i
< nr
&& zone_idx
< nr_zones
; i
++) {
228 ret
= sd_zbc_parse_report(sdkp
, buf
+ offset
, zone_idx
,
235 sector
+= sd_zbc_zone_sectors(sdkp
) * i
;
244 static blk_status_t
sd_zbc_cmnd_checks(struct scsi_cmnd
*cmd
)
246 struct request
*rq
= cmd
->request
;
247 struct scsi_disk
*sdkp
= scsi_disk(rq
->rq_disk
);
248 sector_t sector
= blk_rq_pos(rq
);
250 if (!sd_is_zoned(sdkp
))
251 /* Not a zoned device */
252 return BLK_STS_IOERR
;
254 if (sdkp
->device
->changed
)
255 return BLK_STS_IOERR
;
257 if (sector
& (sd_zbc_zone_sectors(sdkp
) - 1))
258 /* Unaligned request */
259 return BLK_STS_IOERR
;
264 #define SD_ZBC_INVALID_WP_OFST (~0u)
265 #define SD_ZBC_UPDATING_WP_OFST (SD_ZBC_INVALID_WP_OFST - 1)
267 static int sd_zbc_update_wp_offset_cb(struct blk_zone
*zone
, unsigned int idx
,
270 struct scsi_disk
*sdkp
= data
;
272 lockdep_assert_held(&sdkp
->zones_wp_offset_lock
);
274 sdkp
->zones_wp_offset
[idx
] = sd_zbc_get_zone_wp_offset(zone
);
279 static void sd_zbc_update_wp_offset_workfn(struct work_struct
*work
)
281 struct scsi_disk
*sdkp
;
285 sdkp
= container_of(work
, struct scsi_disk
, zone_wp_offset_work
);
287 spin_lock_bh(&sdkp
->zones_wp_offset_lock
);
288 for (zno
= 0; zno
< sdkp
->nr_zones
; zno
++) {
289 if (sdkp
->zones_wp_offset
[zno
] != SD_ZBC_UPDATING_WP_OFST
)
292 spin_unlock_bh(&sdkp
->zones_wp_offset_lock
);
293 ret
= sd_zbc_do_report_zones(sdkp
, sdkp
->zone_wp_update_buf
,
295 zno
* sdkp
->zone_blocks
, true);
296 spin_lock_bh(&sdkp
->zones_wp_offset_lock
);
298 sd_zbc_parse_report(sdkp
, sdkp
->zone_wp_update_buf
+ 64,
299 zno
, sd_zbc_update_wp_offset_cb
,
302 spin_unlock_bh(&sdkp
->zones_wp_offset_lock
);
304 scsi_device_put(sdkp
->device
);
308 * sd_zbc_prepare_zone_append() - Prepare an emulated ZONE_APPEND command.
309 * @cmd: the command to setup
310 * @lba: the LBA to patch
311 * @nr_blocks: the number of LBAs to be written
313 * Called from sd_setup_read_write_cmnd() for REQ_OP_ZONE_APPEND.
314 * @sd_zbc_prepare_zone_append() handles the necessary zone wrote locking and
315 * patching of the lba for an emulated ZONE_APPEND command.
317 * In case the cached write pointer offset is %SD_ZBC_INVALID_WP_OFST it will
318 * schedule a REPORT ZONES command and return BLK_STS_IOERR.
320 blk_status_t
sd_zbc_prepare_zone_append(struct scsi_cmnd
*cmd
, sector_t
*lba
,
321 unsigned int nr_blocks
)
323 struct request
*rq
= cmd
->request
;
324 struct scsi_disk
*sdkp
= scsi_disk(rq
->rq_disk
);
325 unsigned int wp_offset
, zno
= blk_rq_zone_no(rq
);
328 ret
= sd_zbc_cmnd_checks(cmd
);
329 if (ret
!= BLK_STS_OK
)
332 if (!blk_rq_zone_is_seq(rq
))
333 return BLK_STS_IOERR
;
335 /* Unlock of the write lock will happen in sd_zbc_complete() */
336 if (!blk_req_zone_write_trylock(rq
))
337 return BLK_STS_ZONE_RESOURCE
;
339 spin_lock_bh(&sdkp
->zones_wp_offset_lock
);
340 wp_offset
= sdkp
->zones_wp_offset
[zno
];
342 case SD_ZBC_INVALID_WP_OFST
:
344 * We are about to schedule work to update a zone write pointer
345 * offset, which will cause the zone append command to be
346 * requeued. So make sure that the scsi device does not go away
347 * while the work is being processed.
349 if (scsi_device_get(sdkp
->device
)) {
353 sdkp
->zones_wp_offset
[zno
] = SD_ZBC_UPDATING_WP_OFST
;
354 schedule_work(&sdkp
->zone_wp_offset_work
);
356 case SD_ZBC_UPDATING_WP_OFST
:
357 ret
= BLK_STS_DEV_RESOURCE
;
360 wp_offset
= sectors_to_logical(sdkp
->device
, wp_offset
);
361 if (wp_offset
+ nr_blocks
> sdkp
->zone_blocks
) {
368 spin_unlock_bh(&sdkp
->zones_wp_offset_lock
);
370 blk_req_zone_write_unlock(rq
);
375 * sd_zbc_setup_zone_mgmt_cmnd - Prepare a zone ZBC_OUT command. The operations
376 * can be RESET WRITE POINTER, OPEN, CLOSE or FINISH.
377 * @cmd: the command to setup
378 * @op: Operation to be performed
379 * @all: All zones control
381 * Called from sd_init_command() for REQ_OP_ZONE_RESET, REQ_OP_ZONE_RESET_ALL,
382 * REQ_OP_ZONE_OPEN, REQ_OP_ZONE_CLOSE or REQ_OP_ZONE_FINISH requests.
384 blk_status_t
sd_zbc_setup_zone_mgmt_cmnd(struct scsi_cmnd
*cmd
,
385 unsigned char op
, bool all
)
387 struct request
*rq
= cmd
->request
;
388 sector_t sector
= blk_rq_pos(rq
);
389 struct scsi_disk
*sdkp
= scsi_disk(rq
->rq_disk
);
390 sector_t block
= sectors_to_logical(sdkp
->device
, sector
);
393 ret
= sd_zbc_cmnd_checks(cmd
);
394 if (ret
!= BLK_STS_OK
)
398 memset(cmd
->cmnd
, 0, cmd
->cmd_len
);
399 cmd
->cmnd
[0] = ZBC_OUT
;
404 put_unaligned_be64(block
, &cmd
->cmnd
[2]);
406 rq
->timeout
= SD_TIMEOUT
;
407 cmd
->sc_data_direction
= DMA_NONE
;
408 cmd
->transfersize
= 0;
414 static bool sd_zbc_need_zone_wp_update(struct request
*rq
)
416 switch (req_op(rq
)) {
417 case REQ_OP_ZONE_APPEND
:
418 case REQ_OP_ZONE_FINISH
:
419 case REQ_OP_ZONE_RESET
:
420 case REQ_OP_ZONE_RESET_ALL
:
423 case REQ_OP_WRITE_ZEROES
:
424 case REQ_OP_WRITE_SAME
:
425 return blk_rq_zone_is_seq(rq
);
432 * sd_zbc_zone_wp_update - Update cached zone write pointer upon cmd completion
433 * @cmd: Completed command
434 * @good_bytes: Command reply bytes
436 * Called from sd_zbc_complete() to handle the update of the cached zone write
437 * pointer value in case an update is needed.
439 static unsigned int sd_zbc_zone_wp_update(struct scsi_cmnd
*cmd
,
440 unsigned int good_bytes
)
442 int result
= cmd
->result
;
443 struct request
*rq
= cmd
->request
;
444 struct scsi_disk
*sdkp
= scsi_disk(rq
->rq_disk
);
445 unsigned int zno
= blk_rq_zone_no(rq
);
446 enum req_opf op
= req_op(rq
);
449 * If we got an error for a command that needs updating the write
450 * pointer offset cache, we must mark the zone wp offset entry as
451 * invalid to force an update from disk the next time a zone append
454 spin_lock_bh(&sdkp
->zones_wp_offset_lock
);
456 if (result
&& op
!= REQ_OP_ZONE_RESET_ALL
) {
457 if (op
== REQ_OP_ZONE_APPEND
) {
458 /* Force complete completion (no retry) */
460 scsi_set_resid(cmd
, blk_rq_bytes(rq
));
464 * Force an update of the zone write pointer offset on
465 * the next zone append access.
467 if (sdkp
->zones_wp_offset
[zno
] != SD_ZBC_UPDATING_WP_OFST
)
468 sdkp
->zones_wp_offset
[zno
] = SD_ZBC_INVALID_WP_OFST
;
469 goto unlock_wp_offset
;
473 case REQ_OP_ZONE_APPEND
:
474 rq
->__sector
+= sdkp
->zones_wp_offset
[zno
];
476 case REQ_OP_WRITE_ZEROES
:
477 case REQ_OP_WRITE_SAME
:
479 if (sdkp
->zones_wp_offset
[zno
] < sd_zbc_zone_sectors(sdkp
))
480 sdkp
->zones_wp_offset
[zno
] +=
481 good_bytes
>> SECTOR_SHIFT
;
483 case REQ_OP_ZONE_RESET
:
484 sdkp
->zones_wp_offset
[zno
] = 0;
486 case REQ_OP_ZONE_FINISH
:
487 sdkp
->zones_wp_offset
[zno
] = sd_zbc_zone_sectors(sdkp
);
489 case REQ_OP_ZONE_RESET_ALL
:
490 memset(sdkp
->zones_wp_offset
, 0,
491 sdkp
->nr_zones
* sizeof(unsigned int));
498 spin_unlock_bh(&sdkp
->zones_wp_offset_lock
);
504 * sd_zbc_complete - ZBC command post processing.
505 * @cmd: Completed command
506 * @good_bytes: Command reply bytes
507 * @sshdr: command sense header
509 * Called from sd_done() to handle zone commands errors and updates to the
510 * device queue zone write pointer offset cahce.
512 unsigned int sd_zbc_complete(struct scsi_cmnd
*cmd
, unsigned int good_bytes
,
513 struct scsi_sense_hdr
*sshdr
)
515 int result
= cmd
->result
;
516 struct request
*rq
= cmd
->request
;
518 if (op_is_zone_mgmt(req_op(rq
)) &&
520 sshdr
->sense_key
== ILLEGAL_REQUEST
&&
521 sshdr
->asc
== 0x24) {
523 * INVALID FIELD IN CDB error: a zone management command was
524 * attempted on a conventional zone. Nothing to worry about,
525 * so be quiet about the error.
527 rq
->rq_flags
|= RQF_QUIET
;
528 } else if (sd_zbc_need_zone_wp_update(rq
))
529 good_bytes
= sd_zbc_zone_wp_update(cmd
, good_bytes
);
531 if (req_op(rq
) == REQ_OP_ZONE_APPEND
)
532 blk_req_zone_write_unlock(rq
);
538 * sd_zbc_check_zoned_characteristics - Check zoned block device characteristics
540 * @buf: Buffer where to store the VPD page data
542 * Read VPD page B6, get information and check that reads are unconstrained.
544 static int sd_zbc_check_zoned_characteristics(struct scsi_disk
*sdkp
,
548 if (scsi_get_vpd_page(sdkp
->device
, 0xb6, buf
, 64)) {
549 sd_printk(KERN_NOTICE
, sdkp
,
550 "Read zoned characteristics VPD page failed\n");
554 if (sdkp
->device
->type
!= TYPE_ZBC
) {
557 sdkp
->zones_optimal_open
= get_unaligned_be32(&buf
[8]);
558 sdkp
->zones_optimal_nonseq
= get_unaligned_be32(&buf
[12]);
559 sdkp
->zones_max_open
= 0;
562 sdkp
->urswrz
= buf
[4] & 1;
563 sdkp
->zones_optimal_open
= 0;
564 sdkp
->zones_optimal_nonseq
= 0;
565 sdkp
->zones_max_open
= get_unaligned_be32(&buf
[16]);
569 * Check for unconstrained reads: host-managed devices with
570 * constrained reads (drives failing read after write pointer)
574 if (sdkp
->first_scan
)
575 sd_printk(KERN_NOTICE
, sdkp
,
576 "constrained reads devices are not supported\n");
584 * sd_zbc_check_capacity - Check the device capacity
586 * @buf: command buffer
587 * @zblock: zone size in number of blocks
589 * Get the device zone size and check that the device capacity as reported
590 * by READ CAPACITY matches the max_lba value (plus one) of the report zones
591 * command reply for devices with RC_BASIS == 0.
593 * Returns 0 upon success or an error code upon failure.
595 static int sd_zbc_check_capacity(struct scsi_disk
*sdkp
, unsigned char *buf
,
603 /* Do a report zone to get max_lba and the size of the first zone */
604 ret
= sd_zbc_do_report_zones(sdkp
, buf
, SD_BUF_SIZE
, 0, false);
608 if (sdkp
->rc_basis
== 0) {
609 /* The max_lba field is the capacity of this device */
610 max_lba
= get_unaligned_be64(&buf
[8]);
611 if (sdkp
->capacity
!= max_lba
+ 1) {
612 if (sdkp
->first_scan
)
613 sd_printk(KERN_WARNING
, sdkp
,
614 "Changing capacity from %llu to max LBA+1 %llu\n",
615 (unsigned long long)sdkp
->capacity
,
616 (unsigned long long)max_lba
+ 1);
617 sdkp
->capacity
= max_lba
+ 1;
621 /* Get the size of the first reported zone */
623 zone_blocks
= get_unaligned_be64(&rec
[8]);
624 if (logical_to_sectors(sdkp
->device
, zone_blocks
) > UINT_MAX
) {
625 if (sdkp
->first_scan
)
626 sd_printk(KERN_NOTICE
, sdkp
,
627 "Zone size too large\n");
631 *zblocks
= zone_blocks
;
636 static void sd_zbc_revalidate_zones_cb(struct gendisk
*disk
)
638 struct scsi_disk
*sdkp
= scsi_disk(disk
);
640 swap(sdkp
->zones_wp_offset
, sdkp
->rev_wp_offset
);
643 static int sd_zbc_revalidate_zones(struct scsi_disk
*sdkp
,
645 unsigned int nr_zones
)
647 struct gendisk
*disk
= sdkp
->disk
;
651 * Make sure revalidate zones are serialized to ensure exclusive
652 * updates of the scsi disk data.
654 mutex_lock(&sdkp
->rev_mutex
);
657 * Revalidate the disk zones to update the device request queue zone
658 * bitmaps and the zone write pointer offset array. Do this only once
659 * the device capacity is set on the second revalidate execution for
660 * disk scan or if something changed when executing a normal revalidate.
662 if (sdkp
->first_scan
) {
663 sdkp
->zone_blocks
= zone_blocks
;
664 sdkp
->nr_zones
= nr_zones
;
668 if (sdkp
->zone_blocks
== zone_blocks
&&
669 sdkp
->nr_zones
== nr_zones
&&
670 disk
->queue
->nr_zones
== nr_zones
)
673 sdkp
->rev_wp_offset
= kvcalloc(nr_zones
, sizeof(u32
), GFP_NOIO
);
674 if (!sdkp
->rev_wp_offset
) {
679 ret
= blk_revalidate_disk_zones(disk
, sd_zbc_revalidate_zones_cb
);
681 kvfree(sdkp
->rev_wp_offset
);
682 sdkp
->rev_wp_offset
= NULL
;
685 mutex_unlock(&sdkp
->rev_mutex
);
690 int sd_zbc_read_zones(struct scsi_disk
*sdkp
, unsigned char *buf
)
692 struct gendisk
*disk
= sdkp
->disk
;
693 struct request_queue
*q
= disk
->queue
;
694 unsigned int nr_zones
;
699 if (!sd_is_zoned(sdkp
))
701 * Device managed or normal SCSI disk,
702 * no special handling required
706 /* Check zoned block device characteristics (unconstrained reads) */
707 ret
= sd_zbc_check_zoned_characteristics(sdkp
, buf
);
711 /* Check the device capacity reported by report zones */
712 ret
= sd_zbc_check_capacity(sdkp
, buf
, &zone_blocks
);
716 /* The drive satisfies the kernel restrictions: set it up */
717 blk_queue_flag_set(QUEUE_FLAG_ZONE_RESETALL
, q
);
718 blk_queue_required_elevator_features(q
, ELEVATOR_F_ZBD_SEQ_WRITE
);
719 nr_zones
= round_up(sdkp
->capacity
, zone_blocks
) >> ilog2(zone_blocks
);
721 /* READ16/WRITE16 is mandatory for ZBC disks */
722 sdkp
->device
->use_16_for_rw
= 1;
723 sdkp
->device
->use_10_for_rw
= 0;
725 ret
= sd_zbc_revalidate_zones(sdkp
, zone_blocks
, nr_zones
);
730 * On the first scan 'chunk_sectors' isn't setup yet, so calling
731 * blk_queue_max_zone_append_sectors() will result in a WARN(). Defer
732 * this setting to the second scan.
734 if (sdkp
->first_scan
)
737 max_append
= min_t(u32
, logical_to_sectors(sdkp
->device
, zone_blocks
),
738 q
->limits
.max_segments
<< (PAGE_SHIFT
- 9));
739 max_append
= min_t(u32
, max_append
, queue_max_hw_sectors(q
));
741 blk_queue_max_zone_append_sectors(q
, max_append
);
751 void sd_zbc_print_zones(struct scsi_disk
*sdkp
)
753 if (!sd_is_zoned(sdkp
) || !sdkp
->capacity
)
756 if (sdkp
->capacity
& (sdkp
->zone_blocks
- 1))
757 sd_printk(KERN_NOTICE
, sdkp
,
758 "%u zones of %u logical blocks + 1 runt zone\n",
762 sd_printk(KERN_NOTICE
, sdkp
,
763 "%u zones of %u logical blocks\n",
768 int sd_zbc_init_disk(struct scsi_disk
*sdkp
)
770 if (!sd_is_zoned(sdkp
))
773 sdkp
->zones_wp_offset
= NULL
;
774 spin_lock_init(&sdkp
->zones_wp_offset_lock
);
775 sdkp
->rev_wp_offset
= NULL
;
776 mutex_init(&sdkp
->rev_mutex
);
777 INIT_WORK(&sdkp
->zone_wp_offset_work
, sd_zbc_update_wp_offset_workfn
);
778 sdkp
->zone_wp_update_buf
= kzalloc(SD_BUF_SIZE
, GFP_KERNEL
);
779 if (!sdkp
->zone_wp_update_buf
)
785 void sd_zbc_release_disk(struct scsi_disk
*sdkp
)
787 kvfree(sdkp
->zones_wp_offset
);
788 sdkp
->zones_wp_offset
= NULL
;
789 kfree(sdkp
->zone_wp_update_buf
);
790 sdkp
->zone_wp_update_buf
= NULL
;