libzbc
zbc.h
1 // SPDX-License-Identifier: BSD-2-Clause
2 // SPDX-License-Identifier: LGPL-3.0-or-later
3 /*
4  * This file is part of libzbc.
5  *
6  * Copyright (C) 2009-2014, HGST, Inc. All rights reserved.
7  * Copyright (C) 2016, Western Digital. All rights reserved.
8  *
9  * Authors: Damien Le Moal (damien.lemoal@wdc.com)
10  * Christoph Hellwig (hch@infradead.org)
11  * Christophe Louargant (christophe.louargant@wdc.com)
12  */
13 
14 #ifndef _LIBZBC_H_
15 #define _LIBZBC_H_
16 
17 #ifdef __cplusplus
18 extern "C" {
19 #endif
20 
21 #include <stdio.h>
22 #include <unistd.h>
23 #include <stdbool.h>
24 #include <stdint.h>
25 #include <fcntl.h>
26 #include <errno.h>
27 #include <sys/uio.h>
28 
58 extern void zbc_set_log_level(char const *log_level);
59 
66 
71 
76 
82 
88 
89 };
90 
97 extern const char *zbc_zone_type_str(enum zbc_zone_type type);
98 
106 
111 
115  ZBC_ZC_EMPTY = 0x01,
116 
122 
128 
134 
139 
143  ZBC_ZC_FULL = 0x0e,
144 
149 
150 };
151 
158 extern const char *zbc_zone_condition_str(enum zbc_zone_condition cond);
159 
167 
176 
184  ZBC_ZA_NON_SEQ = 0x0002,
185 };
186 
198 struct zbc_zone {
199 
203  uint64_t zbz_length;
204 
208  uint64_t zbz_start;
209 
214 
218  uint8_t zbz_type;
219 
223  uint8_t zbz_condition;
224 
228  uint8_t zbz_attributes;
229 
233  uint8_t __pad[5];
234 
235 };
236 
238 #define zbc_zone_type(z) ((int)(z)->zbz_type)
239 
241 #define zbc_zone_conventional(z) ((z)->zbz_type == ZBC_ZT_CONVENTIONAL)
242 
244 #define zbc_zone_sequential_req(z) ((z)->zbz_type == ZBC_ZT_SEQUENTIAL_REQ)
245 
247 #define zbc_zone_sequential_pref(z) ((z)->zbz_type == ZBC_ZT_SEQUENTIAL_PREF)
248 
250 #define zbc_zone_sequential(z) (zbc_zone_sequential_req(z) || \
251  zbc_zone_sequential_pref(z))
252 
254 #define zbc_zone_condition(z) ((int)(z)->zbz_condition)
255 
257 #define zbc_zone_not_wp(z) ((z)->zbz_condition == ZBC_ZC_NOT_WP)
258 
260 #define zbc_zone_empty(z) ((z)->zbz_condition == ZBC_ZC_EMPTY)
261 
263 #define zbc_zone_imp_open(z) ((z)->zbz_condition == ZBC_ZC_IMP_OPEN)
264 
266 #define zbc_zone_exp_open(z) ((z)->zbz_condition == ZBC_ZC_EXP_OPEN)
267 
269 #define zbc_zone_is_open(z) (zbc_zone_imp_open(z) || \
270  zbc_zone_exp_open(z))
271 
273 #define zbc_zone_closed(z) ((z)->zbz_condition == ZBC_ZC_CLOSED)
274 
276 #define zbc_zone_full(z) ((z)->zbz_condition == ZBC_ZC_FULL)
277 
279 #define zbc_zone_rdonly(z) ((z)->zbz_condition == ZBC_ZC_RDONLY)
280 
282 #define zbc_zone_offline(z) ((z)->zbz_condition == ZBC_ZC_OFFLINE)
283 
285 #define zbc_zone_rwp_recommended(z) ((z)->zbz_attributes & \
286  ZBC_ZA_RWP_RECOMMENDED)
287 
289 #define zbc_zone_non_seq(z) ((z)->zbz_attributes & ZBC_ZA_NON_SEQ)
290 
292 #define zbc_zone_start(z) ((unsigned long long)(z)->zbz_start)
293 
295 #define zbc_zone_length(z) ((unsigned long long)(z)->zbz_length)
296 
298 #define zbc_zone_wp(z) ((unsigned long long)(z)->zbz_write_pointer)
299 
303 #define ZBC_DEVICE_INFO_LENGTH 32
304 
311 
316 
320  ZBC_DT_BLOCK = 0x01,
321 
325  ZBC_DT_SCSI = 0x02,
326 
330  ZBC_DT_ATA = 0x03,
331 
335  ZBC_DT_FAKE = 0x04,
336 
337 };
338 
345 extern const char *zbc_device_type_str(enum zbc_dev_type type);
346 
360 
365 
372 
377 
384 
391 
392 };
393 
400 extern const char *zbc_device_model_str(enum zbc_dev_model model);
401 
405 struct zbc_device;
406 
413 
419  ZBC_UNRESTRICTED_READ = 0x00000001,
420 
421 };
422 
427 #define ZBC_NOT_REPORTED ((uint32_t)0xFFFFFFFF)
428 
433 #define ZBC_NO_LIMIT ((uint32_t)0xFFFFFFFF)
434 
441 
446 
451 
456 
460  uint32_t zbd_flags;
461 
465  uint64_t zbd_sectors;
466 
470  uint32_t zbd_lblock_size;
471 
475  uint64_t zbd_lblocks;
476 
480  uint32_t zbd_pblock_size;
481 
485  uint64_t zbd_pblocks;
486 
492 
499 
507 
514 
515 };
516 
522 #define zbc_lba2sect(info, lba) (((lba) * (info)->zbd_lblock_size) >> 9)
523 
529 #define zbc_sect2lba(info, sect) (((sect) << 9) / (info)->zbd_lblock_size)
530 
536 enum zbc_sk {
537 
540 
543 
546 
549 
552 };
553 
561 
564 
567 
570 
573 
576 
579 
582 
585 
588 
591 
594 };
595 
602 struct zbc_errno {
603 
605  enum zbc_sk sk;
606 
609 
610 };
611 
622 extern void zbc_errno(struct zbc_device *dev, struct zbc_errno *err);
623 
630 extern const char *zbc_sk_str(enum zbc_sk sk);
631 
638 extern const char *zbc_asc_ascq_str(enum zbc_asc_ascq asc_ascq);
639 
658 extern int zbc_device_is_zoned(const char *filename, bool fake,
659  struct zbc_device_info *info);
660 
670 
672  ZBC_O_DRV_BLOCK = 0x01000000,
673 
675  ZBC_O_DRV_SCSI = 0x02000000,
676 
678  ZBC_O_DRV_ATA = 0x04000000,
679 
681  ZBC_O_DRV_FAKE = 0x08000000,
682 
683 };
684 
707 extern int zbc_open(const char *filename, int flags, struct zbc_device **dev);
708 
718 extern int zbc_close(struct zbc_device *dev);
719 
728 extern void zbc_get_device_info(struct zbc_device *dev,
729  struct zbc_device_info *info);
730 
738 extern void zbc_print_device_info(struct zbc_device_info *info, FILE *out);
739 
753 
757  ZBC_RO_ALL = 0x00,
758 
762  ZBC_RO_EMPTY = 0x01,
763 
768 
773 
778 
782  ZBC_RO_FULL = 0x05,
783 
788 
793 
794  /* 08h to 0Fh Reserved */
795 
800 
805 
806  /* 12h to 3Eh Reserved */
807 
812 
817 
818 };
819 
838 extern int zbc_report_zones(struct zbc_device *dev,
839  uint64_t sector , enum zbc_reporting_options ro,
840  struct zbc_zone *zones, unsigned int *nr_zones);
841 
856 static inline int zbc_report_nr_zones(struct zbc_device *dev, uint64_t sector,
857  enum zbc_reporting_options ro,
858  unsigned int *nr_zones)
859 {
860  return zbc_report_zones(dev, sector, ro, NULL, nr_zones);
861 }
862 
881 extern int zbc_list_zones(struct zbc_device *dev,
882  uint64_t sector, enum zbc_reporting_options ro,
883  struct zbc_zone **zones, unsigned int *nr_zones);
884 
891 
896 
901 
906 
911 
912 };
913 
923 
927  ZBC_OP_ALL_ZONES = 0x0000001,
928 
929 };
930 
949 extern int zbc_zone_operation(struct zbc_device *dev, uint64_t sector,
950  enum zbc_zone_op op, unsigned int flags);
951 
971 static inline int zbc_open_zone(struct zbc_device *dev,
972  uint64_t sector, unsigned int flags)
973 {
974  return zbc_zone_operation(dev, sector,
975  ZBC_OP_OPEN_ZONE, flags);
976 }
977 
994 static inline int zbc_close_zone(struct zbc_device *dev,
995  uint64_t sector, unsigned int flags)
996 {
997  return zbc_zone_operation(dev, sector,
998  ZBC_OP_CLOSE_ZONE, flags);
999 }
1000 
1018 static inline int zbc_finish_zone(struct zbc_device *dev,
1019  uint64_t sector, unsigned int flags)
1020 {
1021  return zbc_zone_operation(dev, sector,
1022  ZBC_OP_FINISH_ZONE, flags);
1023 }
1024 
1041 static inline int zbc_reset_zone(struct zbc_device *dev,
1042  uint64_t sector, unsigned int flags)
1043 {
1044  return zbc_zone_operation(dev, sector,
1045  ZBC_OP_RESET_ZONE, flags);
1046 }
1047 
1070 extern ssize_t zbc_pread(struct zbc_device *dev, void *buf,
1071  size_t count, uint64_t offset);
1072 
1096 extern ssize_t zbc_pwrite(struct zbc_device *dev, const void *buf,
1097  size_t count, uint64_t offset);
1098 
1112 extern ssize_t zbc_preadv(struct zbc_device *dev,
1113  const struct iovec *iov, int iovcnt,
1114  uint64_t offset);
1115 
1129 extern ssize_t zbc_pwritev(struct zbc_device *dev,
1130  const struct iovec *iov, int iovcnt,
1131  uint64_t offset);
1132 
1149 extern int zbc_map_iov(const void *buf, size_t sectors,
1150  struct iovec *iov, int iovcnt, size_t iovlen);
1151 
1161 extern int zbc_flush(struct zbc_device *dev);
1162 
1167 #ifdef __cplusplus
1168 }
1169 #endif
1170 
1171 #endif /* _LIBZBC_H_ */
int zbc_map_iov(const void *buf, size_t sectors, struct iovec *iov, int iovcnt, size_t iovlen)
Map a buffer to an I/O vector.
Definition: zbc.h:419
Definition: zbc.h:578
uint64_t zbd_pblocks
Definition: zbc.h:485
Definition: zbc.h:910
uint32_t zbd_opt_nr_open_seq_pref
Definition: zbc.h:498
Definition: zbc.h:138
Definition: zbc.h:672
Definition: zbc.h:767
Definition: zbc.h:75
zbc_zone_condition
Zone condition definitions.
Definition: zbc.h:105
Definition: zbc.h:900
const char * zbc_sk_str(enum zbc_sk sk)
Returns a string describing a sense key.
Definition: zbc.h:539
uint64_t zbz_write_pointer
Definition: zbc.h:213
zbc_zone_attributes
Zone attributes definitions.
Definition: zbc.h:166
Definition: zbc.h:542
Definition: zbc.h:590
Definition: zbc.h:927
int zbc_device_is_zoned(const char *filename, bool fake, struct zbc_device_info *info)
Test if a device is a zoned block device.
enum zbc_sk sk
Definition: zbc.h:605
uint8_t zbz_attributes
Definition: zbc.h:228
enum zbc_dev_type zbd_type
Definition: zbc.h:445
Definition: zbc.h:148
Definition: zbc.h:133
Definition: zbc.h:175
Definition: zbc.h:811
const char * zbc_asc_ascq_str(enum zbc_asc_ascq asc_ascq)
Returns a string describing a sense code.
Definition: zbc.h:675
Definition: zbc.h:115
Definition: zbc.h:127
Definition: zbc.h:315
uint64_t zbd_max_rw_sectors
Definition: zbc.h:491
uint32_t zbd_max_nr_open_seq_req
Definition: zbc.h:513
enum zbc_asc_ascq asc_ascq
Definition: zbc.h:608
zbc_zone_op
Zone operation codes definitions.
Definition: zbc.h:890
int zbc_flush(struct zbc_device *dev)
Flush a device write cache.
const char * zbc_zone_type_str(enum zbc_zone_type type)
returns a string describing a zone type
zbc_dev_type
Device type definitions.
Definition: zbc.h:310
uint8_t __pad[5]
Definition: zbc.h:233
Definition: zbc.h:581
Definition: zbc.h:681
void zbc_print_device_info(struct zbc_device_info *info, FILE *out)
Print a device information.
Definition: zbc.h:545
zbc_asc_ascq
SCSI Additional sense codes and qualifiers definitions.
Definition: zbc.h:560
Definition: zbc.h:782
zbc_dev_flags
Device flags definitions.
Definition: zbc.h:412
int zbc_zone_operation(struct zbc_device *dev, uint64_t sector, enum zbc_zone_op op, unsigned int flags)
Execute an operation on a zone.
Definition: zbc.h:895
Definition: zbc.h:757
Definition: zbc.h:563
zbc_zone_type
Zone type definitions.
Definition: zbc.h:65
Zone information data structure.
Definition: zbc.h:198
uint8_t zbz_type
Definition: zbc.h:218
Device information data structure.
Definition: zbc.h:440
Definition: zbc.h:325
Definition: zbc.h:376
ssize_t zbc_preadv(struct zbc_device *dev, const struct iovec *iov, int iovcnt, uint64_t offset)
Read sectors from a device using mutliple buffers.
uint32_t zbd_pblock_size
Definition: zbc.h:480
Definition: zbc.h:551
zbc_zone_op_flags
Zone operation flag definitions.
Definition: zbc.h:922
ssize_t zbc_pwritev(struct zbc_device *dev, const struct iovec *iov, int iovcnt, uint64_t offset)
Write sectors to a device unsig multiple buffers.
Definition: zbc.h:792
const char * zbc_device_model_str(enum zbc_dev_model model)
Returns a device zone model name.
Definition: zbc.h:569
Definition: zbc.h:772
Definition: zbc.h:587
zbc_dev_model
Device model definitions.
Definition: zbc.h:359
Definition: zbc.h:81
Definition: zbc.h:816
ssize_t zbc_pwrite(struct zbc_device *dev, const void *buf, size_t count, uint64_t offset)
Write sectors to a device.
Definition: zbc.h:905
Definition: zbc.h:87
Definition: zbc.h:804
int zbc_open(const char *filename, int flags, struct zbc_device **dev)
Open a ZBC device.
Definition: zbc.h:330
Definition: zbc.h:371
Definition: zbc.h:799
#define ZBC_DEVICE_INFO_LENGTH
Definition: zbc.h:303
Definition: zbc.h:762
const char * zbc_zone_condition_str(enum zbc_zone_condition cond)
Returns a string describing a zone condition.
Definition: zbc.h:548
Definition: zbc.h:364
Definition: zbc.h:70
zbc_oflags
ZBC device open flags.
Definition: zbc.h:669
int zbc_list_zones(struct zbc_device *dev, uint64_t sector, enum zbc_reporting_options ro, struct zbc_zone **zones, unsigned int *nr_zones)
Get zone information.
uint64_t zbz_length
Definition: zbc.h:203
Definition: zbc.h:593
Definition: zbc.h:383
Definition: zbc.h:787
void zbc_errno(struct zbc_device *dev, struct zbc_errno *err)
Get detailed error code of last operation.
uint64_t zbd_sectors
Definition: zbc.h:465
zbc_reporting_options
Reporting options definitions.
Definition: zbc.h:752
enum zbc_dev_model zbd_model
Definition: zbc.h:450
Definition: zbc.h:110
Detailed error information data structure.
Definition: zbc.h:602
Definition: zbc.h:777
uint64_t zbz_start
Definition: zbc.h:208
Definition: zbc.h:678
Definition: zbc.h:320
ssize_t zbc_pread(struct zbc_device *dev, void *buf, size_t count, uint64_t offset)
Read sectors form a device.
Definition: zbc.h:121
uint32_t zbd_flags
Definition: zbc.h:460
Definition: zbc.h:390
uint32_t zbd_lblock_size
Definition: zbc.h:470
uint8_t zbz_condition
Definition: zbc.h:223
uint64_t zbd_lblocks
Definition: zbc.h:475
Definition: zbc.h:335
char zbd_vendor_id[ZBC_DEVICE_INFO_LENGTH]
Definition: zbc.h:455
int zbc_report_zones(struct zbc_device *dev, uint64_t sector, enum zbc_reporting_options ro, struct zbc_zone *zones, unsigned int *nr_zones)
Get zone information.
void zbc_set_log_level(char const *log_level)
Set the library log level.
Definition: zbc.h:143
const char * zbc_device_type_str(enum zbc_dev_type type)
Returns a device type name.
void zbc_get_device_info(struct zbc_device *dev, struct zbc_device_info *info)
Get a ZBC device information.
uint32_t zbd_opt_nr_non_seq_write_seq_pref
Definition: zbc.h:506
zbc_sk
SCSI Sense keys definitions.
Definition: zbc.h:536
int zbc_close(struct zbc_device *dev)
Close a ZBC device.
Definition: zbc.h:184