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 
63 struct zbc_device;
64 
71 
76 
81 
87 
93 
100 
104  ZBC_ZT_GAP = 0x05,
105 };
106 
113 extern const char *zbc_zone_type_str(enum zbc_zone_type type);
114 
122 
127 
131  ZBC_ZC_EMPTY = 0x01,
132 
138 
144 
150 
155 
160 
164  ZBC_ZC_FULL = 0x0e,
165 
170 
171 };
172 
179 extern const char *zbc_zone_condition_str(enum zbc_zone_condition cond);
180 
188 
197 
205  ZBC_ZA_NON_SEQ = 0x0002,
206 };
207 
219 struct zbc_zone {
220 
224  uint64_t zbz_length;
225 
229  uint64_t zbz_start;
230 
235 
239  uint8_t zbz_type;
240 
244  uint8_t zbz_condition;
245 
249  uint8_t zbz_attributes;
250 
254  uint8_t __pad[5];
255 
256 };
257 
259 #define zbc_zone_type(z) ((int)(z)->zbz_type)
260 
262 #define zbc_zone_conventional(z) ((z)->zbz_type == ZBC_ZT_CONVENTIONAL)
263 
265 #define zbc_zone_sequential_req(z) ((z)->zbz_type == ZBC_ZT_SEQUENTIAL_REQ)
266 
268 #define zbc_zone_sequential_pref(z) ((z)->zbz_type == ZBC_ZT_SEQUENTIAL_PREF)
269 
271 #define zbc_zone_sobr(z) ((z)->zbz_type == ZBC_ZT_SEQ_OR_BEF_REQ)
272 
274 #define zbc_zone_sequential(z) (zbc_zone_sequential_req(z) || \
275  zbc_zone_sequential_pref(z))
276 
278 #define zbc_zone_gap(z) ((z)->zbz_type == ZBC_ZT_GAP)
279 
281 #define zbc_zone_condition(z) ((int)(z)->zbz_condition)
282 
284 #define zbc_zone_not_wp(z) ((z)->zbz_condition == ZBC_ZC_NOT_WP)
285 
287 #define zbc_zone_empty(z) ((z)->zbz_condition == ZBC_ZC_EMPTY)
288 
290 #define zbc_zone_imp_open(z) ((z)->zbz_condition == ZBC_ZC_IMP_OPEN)
291 
293 #define zbc_zone_exp_open(z) ((z)->zbz_condition == ZBC_ZC_EXP_OPEN)
294 
296 #define zbc_zone_is_open(z) (zbc_zone_imp_open(z) || \
297  zbc_zone_exp_open(z))
298 
300 #define zbc_zone_closed(z) ((z)->zbz_condition == ZBC_ZC_CLOSED)
301 
303 #define zbc_zone_full(z) ((z)->zbz_condition == ZBC_ZC_FULL)
304 
306 #define zbc_zone_rdonly(z) ((z)->zbz_condition == ZBC_ZC_RDONLY)
307 
309 #define zbc_zone_offline(z) ((z)->zbz_condition == ZBC_ZC_OFFLINE)
310 
312 #define zbc_zone_inactive(z) ((z)->zbz_condition == ZBC_ZC_INACTIVE)
313 
315 #define zbc_zone_rwp_recommended(z) ((z)->zbz_attributes & \
316  ZBC_ZA_RWP_RECOMMENDED)
317 
319 #define zbc_zone_non_seq(z) ((z)->zbz_attributes & ZBC_ZA_NON_SEQ)
320 
322 #define zbc_zone_start(z) ((unsigned long long)(z)->zbz_start)
323 
325 #define zbc_zone_length(z) ((unsigned long long)(z)->zbz_length)
326 
328 #define zbc_zone_wp(z) ((unsigned long long)(z)->zbz_write_pointer)
329 
334  ZBC_ZDF_SHIFTING_BOUNDARIES = 1 << 0,
335  ZBC_ZDF_VALID_ZONE_TYPE = 1 << 1,
336 };
337 
347 
352 
356  uint64_t zbm_end_sector;
357 
361  uint32_t zbm_nr_zones;
362 
367  uint8_t zbm_id;
368 
373  uint8_t zbm_type;
374 
379  uint16_t zbm_flags;
380 
384  uint8_t __pad[4];
385 };
386 
388 static inline unsigned int zbc_zone_domain_id(struct zbc_zone_domain *d)
389 {
390  return d->zbm_id;
391 }
392 
394 static inline unsigned int zbc_zone_domain_type(struct zbc_zone_domain *d)
395 {
396  return d->zbm_type;
397 }
398 
400 static inline uint64_t zbc_zone_domain_start_sect(struct zbc_zone_domain *d)
401 {
402  return d->zbm_start_sector;
403 }
404 
406 extern uint64_t zbc_zone_domain_start_lba(struct zbc_device *dev,
407  struct zbc_zone_domain *d);
408 
410 extern uint64_t zbc_zone_domain_end_lba(struct zbc_device *dev,
411  struct zbc_zone_domain *d);
412 
414 static inline uint64_t zbc_zone_domain_end_sect(struct zbc_zone_domain *d)
415 {
416  return d->zbm_end_sector;
417 }
418 
420 extern uint64_t zbc_zone_domain_high_sect(struct zbc_device *dev,
421  struct zbc_zone_domain *d);
422 
424 static inline unsigned int zbc_zone_domain_nr_zones(struct zbc_zone_domain *d)
425 {
426  return d->zbm_nr_zones;
427 }
428 
430 static inline uint64_t zbc_zone_domain_sect_size(struct zbc_zone_domain *d)
431 {
432  return zbc_zone_domain_end_sect(d) -
433  zbc_zone_domain_start_sect(d) + 1LL;
434 }
435 
436 static inline unsigned int zbc_zone_domain_zone_size(struct zbc_zone_domain *d)
437 {
438  return (d->zbm_end_sector + 1LL - d->zbm_start_sector) /
439  d->zbm_nr_zones;
440 }
441 
442 static inline unsigned int zbc_zone_domain_flags(struct zbc_zone_domain *d)
443 {
444  return d->zbm_flags;
445 }
446 
454 #define ZBC_RESTRICT_ZONE_ACTIVATE 0x01 /* No activate/deactivate */
455 #define ZBC_RESTRICT_WP_RESET 0x02 /* No write pointer reset */
456 
461 #define ZBC_NR_ZONE_TYPES 4
462 
470 
475 
479  uint64_t zbi_end_sector;
480 
485  uint32_t zbi_length;
486 
490  uint8_t zbi_dom_id;
491 
496  uint8_t zbi_type;
497 
501  uint8_t __pad[2];
502 };
503 
513 
518  uint16_t zbr_number;
519 
524  uint8_t zbr_dom_id;
525 
530  uint8_t zbr_type;
531 
536  uint8_t zbr_actv_flags;
537 
541  uint8_t zbr_nr_domains;
542 
546  uint8_t zbr_restr;
547 
551  uint8_t __pad[2];
552 
558 };
559 
561 static inline int zbc_zone_realm_number(struct zbc_zone_realm *r)
562 {
563  return r->zbr_number;
564 }
565 
567 static inline int zbc_zone_realm_domain(struct zbc_zone_realm *r)
568 {
569  return r->zbr_dom_id;
570 }
571 
573 static inline int zbc_zone_realm_type(struct zbc_zone_realm *r)
574 {
575  return r->zbr_type;
576 }
577 
579 static inline bool zbc_zone_realm_conventional(struct zbc_zone_realm *r)
580 {
581  return (r->zbr_type == ZBC_ZT_CONVENTIONAL);
582 }
583 
585 static inline uint8_t zbc_zone_realm_actv_flags(struct zbc_zone_realm *r)
586 {
587  return r->zbr_actv_flags;
588 }
589 
591 static inline uint8_t zbc_zone_realm_restrictions(struct zbc_zone_realm *r)
592 {
593  return r->zbr_restr;
594 }
595 
597 static inline
598 unsigned int zbc_zone_realm_nr_domains(struct zbc_zone_realm *r)
599 {
600  return r->zbr_nr_domains;
601 }
602 
604 static inline bool zbc_zone_realm_sobr(struct zbc_zone_realm *r)
605 {
606  return (r->zbr_type == ZBC_ZT_SEQ_OR_BEF_REQ);
607 }
608 
610 static inline bool zbc_zone_realm_sequential(struct zbc_zone_realm *r)
611 {
612  return (r->zbr_type == ZBC_ZT_SEQUENTIAL_REQ);
613 }
614 
616 static inline bool zbc_zone_realm_seq_pref(struct zbc_zone_realm *r)
617 {
618  return (r->zbr_type == ZBC_ZT_SEQUENTIAL_PREF);
619 }
620 
622 static inline unsigned int zbc_realm_zone_type(struct zbc_zone_realm *r,
623  unsigned int dom_id)
624 {
625  return r->zbr_ri[dom_id].zbi_type;
626 }
627 
629 static inline uint64_t zbc_realm_start_sector(struct zbc_zone_realm *r,
630  unsigned int dom_id)
631 {
632  return r->zbr_ri[dom_id].zbi_start_sector;
633 }
634 
636 extern uint64_t zbc_realm_start_lba(struct zbc_device *dev,
637  struct zbc_zone_realm *r,
638  unsigned int dom_id);
639 
641 static inline uint64_t zbc_realm_end_sector(struct zbc_zone_realm *r,
642  unsigned int dom_id)
643 {
644  return r->zbr_ri[dom_id].zbi_end_sector;
645 }
646 
648 extern uint64_t zbc_realm_end_lba(struct zbc_device *dev,
649  struct zbc_zone_realm *r,
650  unsigned int dom_id);
651 
653 extern uint64_t zbc_realm_high_sector(struct zbc_device *dev,
654  struct zbc_zone_realm *r,
655  unsigned int dom_id);
656 
658 static inline uint64_t zbc_realm_sector_length(struct zbc_zone_realm *r,
659  unsigned int dom_id)
660 {
661  return zbc_realm_end_sector(r, dom_id) -
662  zbc_realm_start_sector(r, dom_id) + 1LL;
663 }
664 
666 static inline uint64_t zbc_realm_lblock_length(struct zbc_device *dev,
667  struct zbc_zone_realm *r,
668  unsigned int dom_id)
669 {
670  return zbc_realm_end_lba(dev, r, dom_id) -
671  zbc_realm_start_lba(dev, r, dom_id) + 1LL;
672 }
673 
675 static inline uint32_t zbc_realm_length(struct zbc_zone_realm *r,
676  unsigned int dom_id)
677 {
678  return r->zbr_ri[dom_id].zbi_length;
679 }
680 
682 static inline bool zbc_realm_activation_allowed(struct zbc_zone_realm *r)
683 {
684  return !(r->zbr_restr & ZBC_RESTRICT_ZONE_ACTIVATE);
685 }
686 
688 static inline bool zbc_realm_wp_reset_allowed(struct zbc_zone_realm *r)
689 {
690  return !(r->zbr_restr & ZBC_RESTRICT_WP_RESET);
691 }
692 
693 static inline bool zbc_realm_actv_as_dom_id(struct zbc_zone_realm *r,
694  unsigned int dom_id)
695 {
696  return (bool)(r->zbr_actv_flags & (1 << dom_id));
697 }
698 
700 static inline bool zbc_realm_actv_as_type(struct zbc_zone_realm *r,
701  enum zbc_zone_type zt)
702 {
703  int i;
704 
705  for (i = 0; i < r->zbr_nr_domains; i++) {
706  if (zt == r->zbr_ri[i].zbi_type)
707  return (bool)(r->zbr_actv_flags & (1 << i));
708  }
709 
710  return false;
711 }
712 
714 static inline bool zbc_zone_realm_actv_as_conv(struct zbc_zone_realm *r)
715 {
716  int i;
717 
718  for (i = 0; i < r->zbr_nr_domains; i++) {
719  if ((r->zbr_ri[i].zbi_type == ZBC_ZT_CONVENTIONAL ||
721  (r->zbr_actv_flags & (1 << i)))
722  return true;
723  }
724 
725  return false;
726 }
727 
729 static inline bool zbc_zone_realm_actv_as_seq(struct zbc_zone_realm *r)
730 {
731  int i;
732 
733  for (i = 0; i < r->zbr_nr_domains; i++) {
734  if ((r->zbr_ri[i].zbi_type == ZBC_ZT_SEQUENTIAL_REQ ||
736  (r->zbr_actv_flags & (1 << i)))
737  return true;
738  }
739 
740  return false;
741 }
742 
744 static inline
745 struct zbc_realm_item *zbc_realm_item_by_type(struct zbc_zone_realm *r,
746  enum zbc_zone_type zt)
747 {
748  int i;
749 
750  for (i = 0; i < r->zbr_nr_domains; i++) {
751  if (zt == r->zbr_ri[i].zbi_type)
752  return &r->zbr_ri[i];
753  }
754 
755  return NULL;
756 }
757 
765 struct zbc_actv_res {
766 
770  uint64_t zbe_start_zone;
771 
775  uint64_t zbe_nr_zones;
776 
780  uint8_t zbe_domain;
781 
785  uint8_t zbe_type;
786 
790  uint8_t zbe_condition;
791 
792 };
793 
795 #define zbc_actv_res_type(r) ((int)(r)->zbe_type)
796 
798 #define zbc_actv_res_conventional(r) ((r)->zbe_type == ZBC_ZT_CONVENTIONAL)
799 
801 #define zbc_actv_res_seq_req(r) ((r)->zbe_type == ZBC_ZT_SEQUENTIAL_REQ)
802 
804 #define zbc_actv_res_seq_pref(r) ((r)->zbe_type == ZBC_ZT_SEQUENTIAL_PREF)
805 
807 #define zbc_actv_res_sobr(r) ((r)->zbe_type == ZBC_ZT_SEQ_OR_BEF_REQ)
808 
810 #define zbc_actv_res_nonseq(r) (zbc_actv_res_conventional(r) || \
811  zbc_actv_res_sobr(r))
812 
814 #define zbc_actv_res_seq(r) (zbc_actv_res_seq_req(r) || \
815  zbc_actv_res_seq_pref(r))
816 
827  uint32_t zbt_nr_zones;
828 
833 
840  uint8_t zbt_urswrz;
841 
842 };
843 
847 #define ZBC_DEVICE_INFO_LENGTH 32
848 
855 
860 
864  ZBC_DT_SCSI = 0x02,
865 
869  ZBC_DT_ATA = 0x03,
870 
871 };
872 
879 extern const char *zbc_device_type_str(enum zbc_dev_type type);
880 
894 
899 
906 
911 
918 
925 
926 };
927 
934 extern const char *zbc_device_model_str(enum zbc_dev_model model);
935 
942 
948  ZBC_UNRESTRICTED_READ = 0x00000001,
949 
955 
961 
966 
971 
976 
981 
986  ZBC_NOZSRC_SUPPORT = 0x000000100,
987 
991  ZBC_CONV_ZONE_SUPPORT = 0x00000200,
992 
997 
1002 
1007 
1012  ZBC_GAP_ZONE_SUPPORT = 0x00002000,
1013 
1018 
1023 
1028 
1033 
1038 
1043 };
1044 
1049 #define ZBC_NOT_REPORTED ((uint32_t)0xFFFFFFFF)
1050 
1055 #define ZBC_NO_LIMIT ((uint32_t)0xFFFFFFFF)
1056 
1063 
1068 
1073 
1078 
1082  uint32_t zbd_flags;
1083 
1087  uint64_t zbd_sectors;
1088 
1093 
1097  uint64_t zbd_lblocks;
1098 
1103 
1107  uint64_t zbd_pblocks;
1108 
1114 
1121 
1129 
1136 
1142 
1147  uint32_t zbd_snoz;
1148 
1149 };
1150 
1154 static inline bool zbc_device_is_zdr(struct zbc_device_info *info)
1155 {
1156  return (info->zbd_flags & ZBC_ZONE_DOMAINS_SUPPORT) ||
1158 }
1159 
1164 static inline bool zbc_zone_count_supported(struct zbc_device_info *info)
1165 {
1166  /*
1167  * Assume that ZD/ZR devices support zone op counts.
1168  * If this is a regular SMR device, check the support flag
1169  * that is set during the scan.
1170  */
1171  return zbc_device_is_zdr(info) ||
1173 }
1174 
1180 #define zbc_lba2sect(info, lba) (((lba) * (info)->zbd_lblock_size) >> 9)
1181 
1182 #define zbc_lba2sect_end(info, lba) ((((lba + 1) * (info)->zbd_lblock_size) >> 9) - 1)
1183 
1189 #define zbc_sect2lba(info, sect) (((sect) << 9) / (info)->zbd_lblock_size)
1190 
1196 enum zbc_sk {
1197 
1200 
1203 
1206 
1209 
1212 
1215 };
1216 
1224 
1227 
1230 
1233 
1236 
1239 
1242 
1245 
1248 
1251 
1254 
1257 
1260 
1263 
1266 
1269 
1272 
1275 
1278 
1281 };
1282 
1292 struct zbc_err_ext {
1293 
1295  enum zbc_sk sk;
1296 
1299 
1301  unsigned long long err_info;
1302 
1304  unsigned long long err_csinfo;
1305 
1306  /*** Conversion Boundary Failure field (48 bits) */
1307  uint64_t err_cbf;
1308 
1310  uint16_t err_za;
1311 };
1312 
1326 extern void zbc_errno_ext(struct zbc_device *dev,
1327  struct zbc_err_ext *err, size_t size);
1328 
1329 /* Legacy zbc_errno structure */
1330 struct zbc_errno {
1331  enum zbc_sk sk;
1332  enum zbc_asc_ascq asc_ascq;
1333 };
1334 
1348 extern void zbc_errno(struct zbc_device *dev, struct zbc_errno *err);
1349 
1356 extern const char *zbc_sk_str(enum zbc_sk sk);
1357 
1364 extern const char *zbc_asc_ascq_str(enum zbc_asc_ascq asc_ascq);
1365 
1370 extern char const *zbc_version(void);
1371 
1387 extern int zbc_device_is_zoned(const char *filename, bool unused,
1388  struct zbc_device_info *info);
1389 
1399 
1400  /*
1401  * Block device backend is removed, keep zero mask
1402  * defined for backwards compatibility.
1403  */
1404  ZBC_O_DRV_BLOCK = 0x00000000,
1405 
1407  ZBC_O_DRV_SCSI = 0x02000000,
1408 
1410  ZBC_O_DRV_ATA = 0x04000000,
1411 
1412 };
1413 
1434 extern int zbc_open(const char *filename, int flags, struct zbc_device **dev);
1435 
1445 extern int zbc_close(struct zbc_device *dev);
1446 
1455 extern void zbc_get_device_info(struct zbc_device *dev,
1456  struct zbc_device_info *info);
1457 
1465 extern void zbc_print_device_info(struct zbc_device_info *info, FILE *out);
1466 
1480 
1485 
1490 
1495 
1500 
1505 
1510 
1515 
1520 
1525 
1526  /* 09h to 0Fh Reserved */
1527 
1532 
1537 
1538  /* 12h to 3Dh Reserved */
1539 
1545 
1550 
1555 
1556 };
1557 
1558 /* Compatibility names from earlier version of libzbc */
1559 #define zbc_reporting_options zbc_zone_reporting_options
1560 #define ZBC_RO_ALL ZBC_RZ_RO_ALL
1561 #define ZBC_RO_EMPTY ZBC_RZ_RO_EMPTY
1562 #define ZBC_RO_IMP_OPEN ZBC_RZ_RO_IMP_OPEN
1563 #define ZBC_RO_EXP_OPEN ZBC_RZ_RO_EXP_OPEN
1564 #define ZBC_RO_CLOSED ZBC_RZ_RO_CLOSED
1565 #define ZBC_RO_FULL ZBC_RZ_RO_FULL
1566 #define ZBC_RO_RDONLY ZBC_RZ_RO_RDONLY
1567 #define ZBC_RO_OFFLINE ZBC_RZ_RO_OFFLINE
1568 #define ZBC_RO_INACTIVE ZBC_RZ_RO_INACTIVE
1569 #define ZBC_RO_RWP_RECOMMENDED ZBC_RZ_RO_RWP_RECMND
1570 #define ZBC_RO_NON_SEQ ZBC_RZ_RO_NON_SEQ
1571 #define ZBC_RO_GAP ZBC_RZ_RO_GAP
1572 #define ZBC_RO_NOT_WP ZBC_RZ_RO_NOT_WP
1573 #define ZBC_RO_PARTIAL ZBC_RZ_RO_PARTIAL
1574 
1593 extern int zbc_report_zones(struct zbc_device *dev, uint64_t sector,
1595  struct zbc_zone *zones, unsigned int *nr_zones);
1596 
1611 static inline int zbc_report_nr_zones(struct zbc_device *dev, uint64_t sector,
1613  unsigned int *nr_zones)
1614 {
1615  return zbc_report_zones(dev, sector, ro, NULL, nr_zones);
1616 }
1617 
1636 extern int zbc_list_zones(struct zbc_device *dev,
1637  uint64_t sector, enum zbc_zone_reporting_options ro,
1638  struct zbc_zone **zones, unsigned int *nr_zones);
1639 
1646 
1651 
1656 
1661 
1666 
1667 };
1668 
1678 
1682  ZBC_OP_ALL_ZONES = 0x0000001,
1683 
1684 };
1685 
1704 extern int zbc_zone_operation(struct zbc_device *dev, uint64_t sector,
1705  enum zbc_zone_op op, unsigned int flags);
1706 
1726 extern int zbc_zone_group_op(struct zbc_device *dev, uint64_t sector,
1727  unsigned int count, enum zbc_zone_op op,
1728  unsigned int flags);
1729 
1749 static inline int zbc_open_zone(struct zbc_device *dev,
1750  uint64_t sector, unsigned int flags)
1751 {
1752  return zbc_zone_operation(dev, sector,
1753  ZBC_OP_OPEN_ZONE, flags);
1754 }
1755 
1776 static inline int zbc_open_zones(struct zbc_device *dev, uint64_t sector,
1777  unsigned int count, unsigned int flags)
1778 {
1779  return zbc_zone_group_op(dev, sector, count,
1780  ZBC_OP_OPEN_ZONE, flags);
1781 }
1782 
1799 static inline int zbc_close_zone(struct zbc_device *dev,
1800  uint64_t sector, unsigned int flags)
1801 {
1802  return zbc_zone_operation(dev, sector,
1803  ZBC_OP_CLOSE_ZONE, flags);
1804 }
1805 
1823 static inline int zbc_close_zones(struct zbc_device *dev, uint64_t sector,
1824  unsigned int count, unsigned int flags)
1825 {
1826  return zbc_zone_group_op(dev, sector, count,
1827  ZBC_OP_CLOSE_ZONE, flags);
1828 }
1829 
1847 static inline int zbc_finish_zone(struct zbc_device *dev,
1848  uint64_t sector, unsigned int flags)
1849 {
1850  return zbc_zone_operation(dev, sector,
1851  ZBC_OP_FINISH_ZONE, flags);
1852 }
1853 
1871 static inline int zbc_finish_zones(struct zbc_device *dev, uint64_t sector,
1872  unsigned int count, unsigned int flags)
1873 {
1874  return zbc_zone_group_op(dev, sector, count,
1875  ZBC_OP_FINISH_ZONE, flags);
1876 }
1877 
1894 static inline int zbc_reset_zone(struct zbc_device *dev,
1895  uint64_t sector, unsigned int flags)
1896 {
1897  return zbc_zone_operation(dev, sector,
1898  ZBC_OP_RESET_ZONE, flags);
1899 }
1900 
1918 static inline int zbc_reset_zones(struct zbc_device *dev, uint64_t sector,
1919  unsigned int count, unsigned int flags)
1920 {
1921  return zbc_zone_group_op(dev, sector, count,
1922  ZBC_OP_RESET_ZONE, flags);
1923 }
1924 
1932 
1933  /* Report all zone domains */
1934  ZBC_RZD_RO_ALL = 0x00,
1935 
1936  /* Report all zone domains that for which all zones are active */
1937  ZBC_RZD_RO_ALL_ACTIVE = 0x01,
1938 
1939  /* Report all zone domains that have active zones */
1940  ZBC_RZD_RO_ACTIVE = 0x02,
1941 
1942  /* Report all zone domains that do not have any active zones */
1943  ZBC_RZD_RO_INACTIVE = 0x03,
1944 };
1945 
1965 extern int zbc_report_domains(struct zbc_device *dev, uint64_t sector,
1966  enum zbc_domain_report_options ro,
1967  struct zbc_zone_domain *domains,
1968  unsigned int nr_domains);
1969 
1988 extern int zbc_list_domains(struct zbc_device *dev, uint64_t sector,
1989  enum zbc_domain_report_options ro,
1990  struct zbc_zone_domain **pdomains,
1991  unsigned int *pnr_domains);
1992 
2000 
2001  /* Report all realms */
2002  ZBC_RR_RO_ALL = 0x00,
2003 
2004  /* Report all realms that contain active SOBR zones */
2005  ZBC_RR_RO_SOBR = 0x01,
2006 
2007  /* Report all realms that contain active SWR zones */
2008  ZBC_RR_RO_SWR = 0x02,
2009 
2010  /* Report all realms that contain active SWP zones */
2011  ZBC_RR_RO_SWP = 0x03,
2012 };
2013 
2030 extern int zbc_report_realms(struct zbc_device *dev, uint64_t sector,
2031  enum zbc_realm_report_options ro,
2032  struct zbc_zone_realm *realms,
2033  unsigned int *nr_realms);
2034 
2048 static inline int zbc_report_nr_realms(struct zbc_device *dev,
2049  unsigned int *nr_realms)
2050 {
2051  return zbc_report_realms(dev, 0LL, ZBC_RR_RO_ALL, NULL, nr_realms);
2052 }
2053 
2072 extern int zbc_list_zone_realms(struct zbc_device *dev, uint64_t sector,
2073  enum zbc_realm_report_options ro,
2074  struct zbc_zone_realm **prealms,
2075  unsigned int *pnr_realms);
2076 
2089 extern int zbc_zone_activate(struct zbc_device *dev, bool zsrc, bool all,
2090  bool use_32_byte_cdb, uint64_t start_zone,
2091  unsigned int nr_zones, unsigned int domain_id,
2092  struct zbc_actv_res *actv_recs,
2093  unsigned int *nr_actv_recs);
2094 
2107 extern int zbc_zone_query(struct zbc_device *dev, bool zsrc, bool all,
2108  bool use_32_byte_cdb, uint64_t start_zone,
2109  unsigned int nr_zones, unsigned int domain_id,
2110  struct zbc_actv_res *actv_recs,
2111  unsigned int *nr_actv_recs);
2112 
2123 extern int zbc_get_nr_actv_records(struct zbc_device *dev, bool zsrc, bool all,
2124  bool use_32_byte_cdb, uint64_t start_zone,
2125  unsigned int nr_zones,
2126  unsigned int domain_id);
2127 
2140 extern int zbc_zone_query_list(struct zbc_device *dev, bool zsrc, bool all,
2141  bool use_32_byte_cdb, uint64_t start_zone,
2142  unsigned int nr_zones, unsigned int domain_id,
2143  struct zbc_actv_res **pactv_recs,
2144  unsigned int *pnr_actv_recs);
2156 extern int zbc_zone_activation_ctl(struct zbc_device *dev,
2157  struct zbc_zd_dev_control *ctl, bool set);
2158 
2166 
2168  unsigned long long max_open_zones;
2169 
2171  unsigned long long max_exp_open_seq_zones;
2172 
2174  unsigned long long max_imp_open_seq_zones;
2175 
2177  unsigned long long max_imp_open_sobr_zones;
2178 
2180  unsigned long long min_empty_zones;
2181 
2183  unsigned long long zones_emptied;
2184 
2186  unsigned long long max_non_seq_zones;
2187 
2189  unsigned long long subopt_write_cmds;
2190 
2192  unsigned long long cmds_above_opt_lim;
2193 
2195  unsigned long long failed_exp_opens;
2196 
2198  unsigned long long read_rule_fails;
2199 
2201  unsigned long long write_rule_fails;
2202 };
2203 
2214 extern int zbc_get_zbd_stats(struct zbc_device *dev,
2215  struct zbc_zoned_blk_dev_stats *stats);
2216 
2239 extern ssize_t zbc_pread(struct zbc_device *dev, void *buf,
2240  size_t count, uint64_t offset);
2241 
2265 extern ssize_t zbc_pwrite(struct zbc_device *dev, const void *buf,
2266  size_t count, uint64_t offset);
2267 
2281 extern ssize_t zbc_preadv(struct zbc_device *dev,
2282  const struct iovec *iov, int iovcnt,
2283  uint64_t offset);
2284 
2298 extern ssize_t zbc_pwritev(struct zbc_device *dev,
2299  const struct iovec *iov, int iovcnt,
2300  uint64_t offset);
2301 
2318 extern int zbc_map_iov(const void *buf, size_t sectors,
2319  struct iovec *iov, int iovcnt, size_t iovlen);
2320 
2330 extern int zbc_flush(struct zbc_device *dev);
2331 
2336 #ifdef __cplusplus
2337 }
2338 #endif
2339 
2340 #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:948
Definition: zbc.h:1241
Definition: zbc.h:1027
Definition: zbc.h:1017
uint64_t zbd_pblocks
Definition: zbc.h:1107
Definition: zbc.h:1665
uint32_t zbd_opt_nr_open_seq_pref
Definition: zbc.h:1120
uint64_t zbc_realm_high_sector(struct zbc_device *dev, struct zbc_zone_realm *r, unsigned int dom_id)
Get realm highest 512B sector for a particular domain.
uint8_t zbr_type
Definition: zbc.h:530
Definition: zbc.h:1274
uint64_t zbi_end_sector
Definition: zbc.h:479
Definition: zbc.h:1509
Definition: zbc.h:159
Definition: zbc.h:1554
uint64_t zbm_start_sector
Definition: zbc.h:351
int zbc_get_zbd_stats(struct zbc_device *dev, struct zbc_zoned_blk_dev_stats *stats)
Get Zoned Block Device statistics.
Definition: zbc.h:80
Definition: zbc.h:1235
zbc_zone_domain_flags
Zone domain flags.
Definition: zbc.h:333
zbc_zone_condition
Zone condition definitions.
Definition: zbc.h:121
Definition: zbc.h:1655
const char * zbc_sk_str(enum zbc_sk sk)
Returns a string describing a sense key.
uint8_t zbm_id
Definition: zbc.h:367
Definition: zbc.h:1199
uint64_t zbz_write_pointer
Definition: zbc.h:234
int zbc_list_zones(struct zbc_device *dev, uint64_t sector, enum zbc_zone_reporting_options ro, struct zbc_zone **zones, unsigned int *nr_zones)
Get zone information.
zbc_zone_attributes
Zone attributes definitions.
Definition: zbc.h:187
Definition: zbc.h:1202
struct zbc_realm_item zbr_ri[ZBC_NR_ZONE_TYPES]
Definition: zbc.h:557
uint8_t zbr_nr_domains
Definition: zbc.h:541
Definition: zbc.h:1262
Definition: zbc.h:1682
uint8_t zbi_type
Definition: zbc.h:496
Zone Activation Results record.
Definition: zbc.h:765
Definition: zbc.h:1247
uint8_t zbz_attributes
Definition: zbc.h:249
int zbc_zone_activate(struct zbc_device *dev, bool zsrc, bool all, bool use_32_byte_cdb, uint64_t start_zone, unsigned int nr_zones, unsigned int domain_id, struct zbc_actv_res *actv_recs, unsigned int *nr_actv_recs)
Activate the specified zones at a new zone domain.
enum zbc_dev_type zbd_type
Definition: zbc.h:1067
Definition: zbc.h:169
Definition: zbc.h:149
Definition: zbc.h:196
const char * zbc_asc_ascq_str(enum zbc_asc_ascq asc_ascq)
Returns a string describing a sense code.
uint32_t zbi_length
Definition: zbc.h:485
Definition: zbc.h:1407
Definition: zbc.h:131
Definition: zbc.h:143
uint8_t zbr_dom_id
Definition: zbc.h:524
Zone domain descriptor.
Definition: zbc.h:346
zbc_realm_report_options
REPORT REALMS reporting options definitions.
Definition: zbc.h:1999
Definition: zbc.h:859
uint64_t zbd_max_rw_sectors
Definition: zbc.h:1113
uint32_t zbd_max_nr_open_seq_req
Definition: zbc.h:1135
zbc_zone_op
Zone operation codes definitions.
Definition: zbc.h:1645
Definition: zbc.h:1504
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
uint64_t zbc_realm_end_lba(struct zbc_device *dev, struct zbc_zone_realm *r, unsigned int dom_id)
Get realm end logical block for a particular domain.
Zone realm descriptor.
Definition: zbc.h:512
uint16_t err_za
Definition: zbc.h:1310
zbc_dev_type
Device type definitions.
Definition: zbc.h:854
Definition: zbc.h:986
Definition: zbc.h:1042
Definition: zbc.h:1524
uint64_t zbi_start_sector
Definition: zbc.h:474
uint8_t __pad[5]
Definition: zbc.h:254
Definition: zbc.h:1244
enum zbc_sk sk
Definition: zbc.h:1295
void zbc_print_device_info(struct zbc_device_info *info, FILE *out)
Print a device information.
Definition: zbc.h:1208
uint64_t zbc_realm_start_lba(struct zbc_device *dev, struct zbc_zone_realm *r, unsigned int dom_id)
Get realm start logical block for a particular domain.
zbc_asc_ascq
SCSI Additional sense codes and qualifiers definitions.
Definition: zbc.h:1223
zbc_domain_report_options
REPORT ZONE DOMAINS reporting options definitions.
Definition: zbc.h:1931
uint8_t zbr_restr
Definition: zbc.h:546
#define ZBC_RESTRICT_ZONE_ACTIVATE
Definition: zbc.h:454
unsigned long long max_exp_open_seq_zones
Definition: zbc.h:2171
Definition: zbc.h:1519
zbc_dev_flags
Device flags definitions.
Definition: zbc.h:941
uint8_t __pad[2]
Definition: zbc.h:501
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.
uint16_t zbm_flags
Definition: zbc.h:379
Definition: zbc.h:1032
Definition: zbc.h:1650
Definition: zbc.h:1484
Definition: zbc.h:960
Definition: zbc.h:1226
zbc_zone_type
Zone type definitions.
Definition: zbc.h:70
int zbc_zone_group_op(struct zbc_device *dev, uint64_t sector, unsigned int count, enum zbc_zone_op op, unsigned int flags)
Execute an operation on a group of zones.
Zone information data structure.
Definition: zbc.h:219
unsigned long long failed_exp_opens
Definition: zbc.h:2195
uint32_t zbd_max_activation
Definition: zbc.h:1141
Definition: zbc.h:1037
int zbc_report_domains(struct zbc_device *dev, uint64_t sector, enum zbc_domain_report_options ro, struct zbc_zone_domain *domains, unsigned int nr_domains)
Get zone domain information.
uint8_t zbt_urswrz
URSWRZ setting. Zero value means off.
Definition: zbc.h:840
uint8_t zbz_type
Definition: zbc.h:239
Device information data structure.
Definition: zbc.h:1062
enum zbc_asc_ascq asc_ascq
Definition: zbc.h:1298
Definition: zbc.h:864
unsigned long long err_info
Definition: zbc.h:1301
Definition: zbc.h:910
unsigned long long max_non_seq_zones
Definition: zbc.h:2186
ssize_t zbc_preadv(struct zbc_device *dev, const struct iovec *iov, int iovcnt, uint64_t offset)
Read sectors from a device using multiple buffers.
int zbc_list_domains(struct zbc_device *dev, uint64_t sector, enum zbc_domain_report_options ro, struct zbc_zone_domain **pdomains, unsigned int *pnr_domains)
List zone domain information.
uint32_t zbd_pblock_size
Definition: zbc.h:1102
Definition: zbc.h:1214
zbc_zone_op_flags
Zone operation flag definitions.
Definition: zbc.h:1677
ssize_t zbc_pwritev(struct zbc_device *dev, const struct iovec *iov, int iovcnt, uint64_t offset)
Write sectors to a device usig multiple buffers.
int zbc_zone_query(struct zbc_device *dev, bool zsrc, bool all, bool use_32_byte_cdb, uint64_t start_zone, unsigned int nr_zones, unsigned int domain_id, struct zbc_actv_res *actv_recs, unsigned int *nr_actv_recs)
Query about possible results of zone activation.
uint8_t __pad[4]
Definition: zbc.h:384
uint16_t zbr_number
Definition: zbc.h:518
const char * zbc_device_model_str(enum zbc_dev_model model)
Returns a device zone model name.
uint8_t __pad[2]
Definition: zbc.h:551
unsigned long long max_open_zones
Definition: zbc.h:2168
int zbc_zone_query_list(struct zbc_device *dev, bool zsrc, bool all, bool use_32_byte_cdb, uint64_t start_zone, unsigned int nr_zones, unsigned int domain_id, struct zbc_actv_res **pactv_recs, unsigned int *pnr_actv_recs)
Query about possible activation results of a number of zones.
int zbc_device_is_zoned(const char *filename, bool unused, struct zbc_device_info *info)
Test if a device is a zoned block device.
Definition: zbc.h:1022
Definition: zbc.h:1232
Definition: zbc.h:104
Definition: zbc.h:980
Definition: zbc.h:1494
Definition: zbc.h:1259
unsigned long long min_empty_zones
Definition: zbc.h:2180
int zbc_report_realms(struct zbc_device *dev, uint64_t sector, enum zbc_realm_report_options ro, struct zbc_zone_realm *realms, unsigned int *nr_realms)
Get zone realm information.
Detailed error information data structure.
Definition: zbc.h:1292
zbc_dev_model
Device model definitions.
Definition: zbc.h:893
uint64_t zbm_end_sector
Definition: zbc.h:356
Definition: zbc.h:154
Definition: zbc.h:86
unsigned long long subopt_write_cmds
Definition: zbc.h:2189
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:1660
Definition: zbc.h:954
uint8_t zbr_actv_flags
Definition: zbc.h:536
int zbc_list_zone_realms(struct zbc_device *dev, uint64_t sector, enum zbc_realm_report_options ro, struct zbc_zone_realm **prealms, unsigned int *pnr_realms)
List zone realm information.
Definition: zbc.h:92
uint64_t zbc_zone_domain_end_lba(struct zbc_device *dev, struct zbc_zone_domain *d)
Get zone domain end logical block.
char const * zbc_version(void)
return libzbc version as a string.
Definition: zbc.h:1531
int zbc_open(const char *filename, int flags, struct zbc_device **dev)
Open a ZBC device.
Definition: zbc.h:869
uint8_t zbe_condition
Zone condition of all zones in this range.
Definition: zbc.h:790
Definition: zbc.h:905
void zbc_errno_ext(struct zbc_device *dev, struct zbc_err_ext *err, size_t size)
Get detailed error code of last operation.
#define ZBC_DEVICE_INFO_LENGTH
Definition: zbc.h:847
uint16_t zbt_max_activate
Maximum number of LBA realms that can be activated at once.
Definition: zbc.h:832
uint8_t zbe_domain
Domain ID of all zones in this range.
Definition: zbc.h:780
Definition: zbc.h:991
Definition: zbc.h:1489
const char * zbc_zone_condition_str(enum zbc_zone_condition cond)
Returns a string describing a zone condition.
Zone realm item.
Definition: zbc.h:469
unsigned long long cmds_above_opt_lim
Definition: zbc.h:2192
unsigned long long max_imp_open_seq_zones
Definition: zbc.h:2174
Definition: zbc.h:1211
Definition: zbc.h:898
Definition: zbc.h:75
uint32_t zbd_snoz
Definition: zbc.h:1147
Definition: zbc.h:1253
zbc_oflags
ZBC device open flags.
Definition: zbc.h:1398
Definition: zbc.h:965
uint8_t zbi_dom_id
Definition: zbc.h:490
Definition: zbc.h:1280
uint64_t zbz_length
Definition: zbc.h:224
Definition: zbc.h:1265
uint64_t zbe_nr_zones
Number of contiguous activated zones.
Definition: zbc.h:775
Definition: zbc.h:917
Definition: zbc.h:99
Definition: zbc.h:1006
unsigned long long zones_emptied
Definition: zbc.h:2183
void zbc_errno(struct zbc_device *dev, struct zbc_errno *err)
Get legacy error code of last operation.
uint64_t zbd_sectors
Definition: zbc.h:1087
Definition: zbc.h:1012
Definition: zbc.h:1549
uint8_t zbm_type
Definition: zbc.h:373
unsigned long long read_rule_fails
Definition: zbc.h:2198
int zbc_report_zones(struct zbc_device *dev, uint64_t sector, enum zbc_zone_reporting_options ro, struct zbc_zone *zones, unsigned int *nr_zones)
Get zone information.
uint8_t zbe_type
Zone type of all zones in this range.
Definition: zbc.h:785
Zone Domains device control structure.
Definition: zbc.h:823
enum zbc_dev_model zbd_model
Definition: zbc.h:1072
Definition: zbc.h:126
uint32_t zbt_nr_zones
Default number of zones to activate.
Definition: zbc.h:827
Definition: zbc.h:1330
uint64_t zbz_start
Definition: zbc.h:229
Definition: zbc.h:1410
Definition: zbc.h:970
ssize_t zbc_pread(struct zbc_device *dev, void *buf, size_t count, uint64_t offset)
Read sectors from a device.
uint32_t zbm_nr_zones
Definition: zbc.h:361
Definition: zbc.h:1536
Definition: zbc.h:137
Definition: zbc.h:1514
uint32_t zbd_flags
Definition: zbc.h:1082
uint64_t zbc_zone_domain_high_sect(struct zbc_device *dev, struct zbc_zone_domain *d)
Get zone domain highest 512B sector.
Definition: zbc.h:924
unsigned long long err_csinfo
Definition: zbc.h:1304
uint32_t zbd_lblock_size
Definition: zbc.h:1092
int zbc_get_nr_actv_records(struct zbc_device *dev, bool zsrc, bool all, bool use_32_byte_cdb, uint64_t start_zone, unsigned int nr_zones, unsigned int domain_id)
Return the expected number of activation records.
uint8_t zbz_condition
Definition: zbc.h:244
int zbc_zone_activation_ctl(struct zbc_device *dev, struct zbc_zd_dev_control *ctl, bool set)
Read or change persistent XMR device settings.
#define ZBC_NR_ZONE_TYPES
Definition: zbc.h:461
uint64_t zbd_lblocks
Definition: zbc.h:1097
Definition: zbc.h:1001
Definition: zbc.h:1544
char zbd_vendor_id[ZBC_DEVICE_INFO_LENGTH]
Definition: zbc.h:1077
void zbc_set_log_level(char const *log_level)
Set the library log level.
Definition: zbc.h:164
const char * zbc_device_type_str(enum zbc_dev_type type)
Returns a device type name.
Definition: zbc.h:1499
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:1128
unsigned long long write_rule_fails
Definition: zbc.h:2201
zbc_zone_reporting_options
REPORT ZONES reporting options definitions.
Definition: zbc.h:1479
zbc_sk
SCSI Sense keys definitions.
Definition: zbc.h:1196
Zoned Block Device Statistics.
Definition: zbc.h:2165
Definition: zbc.h:975
uint64_t zbe_start_zone
Starting zone ID.
Definition: zbc.h:770
Definition: zbc.h:1205
int zbc_close(struct zbc_device *dev)
Close a ZBC device.
Definition: zbc.h:996
uint64_t zbc_zone_domain_start_lba(struct zbc_device *dev, struct zbc_zone_domain *d)
Get zone domain start logical block.
unsigned long long max_imp_open_sobr_zones
Definition: zbc.h:2177
Definition: zbc.h:205