libzbc
 All Data Structures Functions Variables Enumerations Enumerator Modules
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 #include <stdio.h>
18 #include <unistd.h>
19 #include <stdbool.h>
20 #include <stdint.h>
21 #include <fcntl.h>
22 #include <errno.h>
23 #include <sys/uio.h>
24 
54 extern void zbc_set_log_level(char const *log_level);
55 
62 
67 
72 
78 
84 
85 };
86 
93 extern const char *zbc_zone_type_str(enum zbc_zone_type type);
94 
102 
107 
111  ZBC_ZC_EMPTY = 0x01,
112 
118 
124 
130 
135 
139  ZBC_ZC_FULL = 0x0e,
140 
145 
146 };
147 
154 extern const char *zbc_zone_condition_str(enum zbc_zone_condition cond);
155 
163 
172 
180  ZBC_ZA_NON_SEQ = 0x0002,
181 };
182 
194 struct zbc_zone {
195 
199  uint64_t zbz_length;
200 
204  uint64_t zbz_start;
205 
210 
214  uint8_t zbz_type;
215 
219  uint8_t zbz_condition;
220 
224  uint8_t zbz_attributes;
225 
229  uint8_t __pad[5];
230 
231 };
232 
234 #define zbc_zone_type(z) ((int)(z)->zbz_type)
235 
237 #define zbc_zone_conventional(z) ((z)->zbz_type == ZBC_ZT_CONVENTIONAL)
238 
240 #define zbc_zone_sequential_req(z) ((z)->zbz_type == ZBC_ZT_SEQUENTIAL_REQ)
241 
243 #define zbc_zone_sequential_pref(z) ((z)->zbz_type == ZBC_ZT_SEQUENTIAL_PREF)
244 
246 #define zbc_zone_sequential(z) (zbc_zone_sequential_req(z) || \
247  zbc_zone_sequential_pref(z))
248 
250 #define zbc_zone_condition(z) ((int)(z)->zbz_condition)
251 
253 #define zbc_zone_not_wp(z) ((z)->zbz_condition == ZBC_ZC_NOT_WP)
254 
256 #define zbc_zone_empty(z) ((z)->zbz_condition == ZBC_ZC_EMPTY)
257 
259 #define zbc_zone_imp_open(z) ((z)->zbz_condition == ZBC_ZC_IMP_OPEN)
260 
262 #define zbc_zone_exp_open(z) ((z)->zbz_condition == ZBC_ZC_EXP_OPEN)
263 
265 #define zbc_zone_is_open(z) (zbc_zone_imp_open(z) || \
266  zbc_zone_exp_open(z))
267 
269 #define zbc_zone_closed(z) ((z)->zbz_condition == ZBC_ZC_CLOSED)
270 
272 #define zbc_zone_full(z) ((z)->zbz_condition == ZBC_ZC_FULL)
273 
275 #define zbc_zone_rdonly(z) ((z)->zbz_condition == ZBC_ZC_RDONLY)
276 
278 #define zbc_zone_offline(z) ((z)->zbz_condition == ZBC_ZC_OFFLINE)
279 
281 #define zbc_zone_rwp_recommended(z) ((z)->zbz_attributes & \
282  ZBC_ZA_RWP_RECOMMENDED)
283 
285 #define zbc_zone_non_seq(z) ((z)->zbz_attributes & ZBC_ZA_NON_SEQ)
286 
288 #define zbc_zone_start(z) ((unsigned long long)(z)->zbz_start)
289 
291 #define zbc_zone_length(z) ((unsigned long long)(z)->zbz_length)
292 
294 #define zbc_zone_wp(z) ((unsigned long long)(z)->zbz_write_pointer)
295 
299 #define ZBC_DEVICE_INFO_LENGTH 32
300 
307 
312 
316  ZBC_DT_BLOCK = 0x01,
317 
321  ZBC_DT_SCSI = 0x02,
322 
326  ZBC_DT_ATA = 0x03,
327 
331  ZBC_DT_FAKE = 0x04,
332 
333 };
334 
341 extern const char *zbc_device_type_str(enum zbc_dev_type type);
342 
356 
361 
368 
373 
380 
387 
388 };
389 
396 extern const char *zbc_device_model_str(enum zbc_dev_model model);
397 
401 struct zbc_device;
402 
409 
415  ZBC_UNRESTRICTED_READ = 0x00000001,
416 
417 };
418 
423 #define ZBC_NOT_REPORTED ((uint32_t)0xFFFFFFFF)
424 
429 #define ZBC_NO_LIMIT ((uint32_t)0xFFFFFFFF)
430 
437 
442 
447 
452 
456  uint32_t zbd_flags;
457 
461  uint64_t zbd_sectors;
462 
466  uint32_t zbd_lblock_size;
467 
471  uint64_t zbd_lblocks;
472 
476  uint32_t zbd_pblock_size;
477 
481  uint64_t zbd_pblocks;
482 
488 
495 
503 
510 
511 };
512 
518 #define zbc_lba2sect(info, lba) (((lba) * (info)->zbd_lblock_size) >> 9)
519 
525 #define zbc_sect2lba(info, sect) (((sect) << 9) / (info)->zbd_lblock_size)
526 
532 enum zbc_sk {
533 
536 
539 
542 
545 
548 };
549 
557 
560 
563 
566 
569 
572 
575 
578 
581 
584 
587 
590 };
591 
598 struct zbc_errno {
599 
601  enum zbc_sk sk;
602 
605 
606 };
607 
618 extern void zbc_errno(struct zbc_device *dev, struct zbc_errno *err);
619 
626 extern const char *zbc_sk_str(enum zbc_sk sk);
627 
634 extern const char *zbc_asc_ascq_str(enum zbc_asc_ascq asc_ascq);
635 
654 extern int zbc_device_is_zoned(const char *filename, bool fake,
655  struct zbc_device_info *info);
656 
666 
668  ZBC_O_DRV_BLOCK = 0x01000000,
669 
671  ZBC_O_DRV_SCSI = 0x02000000,
672 
674  ZBC_O_DRV_ATA = 0x04000000,
675 
677  ZBC_O_DRV_FAKE = 0x08000000,
678 
679 };
680 
703 extern int zbc_open(const char *filename, int flags, struct zbc_device **dev);
704 
714 extern int zbc_close(struct zbc_device *dev);
715 
724 extern void zbc_get_device_info(struct zbc_device *dev,
725  struct zbc_device_info *info);
726 
734 extern void zbc_print_device_info(struct zbc_device_info *info, FILE *out);
735 
749 
753  ZBC_RO_ALL = 0x00,
754 
758  ZBC_RO_EMPTY = 0x01,
759 
764 
769 
774 
778  ZBC_RO_FULL = 0x05,
779 
784 
789 
790  /* 08h to 0Fh Reserved */
791 
796 
801 
802  /* 12h to 3Eh Reserved */
803 
808 
813 
814 };
815 
834 extern int zbc_report_zones(struct zbc_device *dev,
835  uint64_t sector , enum zbc_reporting_options ro,
836  struct zbc_zone *zones, unsigned int *nr_zones);
837 
852 static inline int zbc_report_nr_zones(struct zbc_device *dev, uint64_t sector,
853  enum zbc_reporting_options ro,
854  unsigned int *nr_zones)
855 {
856  return zbc_report_zones(dev, sector, ro, NULL, nr_zones);
857 }
858 
877 extern int zbc_list_zones(struct zbc_device *dev,
878  uint64_t sector, enum zbc_reporting_options ro,
879  struct zbc_zone **zones, unsigned int *nr_zones);
880 
887 
892 
897 
902 
907 
908 };
909 
919 
923  ZBC_OP_ALL_ZONES = 0x0000001,
924 
925 };
926 
945 extern int zbc_zone_operation(struct zbc_device *dev, uint64_t sector,
946  enum zbc_zone_op op, unsigned int flags);
947 
967 static inline int zbc_open_zone(struct zbc_device *dev,
968  uint64_t sector, unsigned int flags)
969 {
970  return zbc_zone_operation(dev, sector,
971  ZBC_OP_OPEN_ZONE, flags);
972 }
973 
990 static inline int zbc_close_zone(struct zbc_device *dev,
991  uint64_t sector, unsigned int flags)
992 {
993  return zbc_zone_operation(dev, sector,
994  ZBC_OP_CLOSE_ZONE, flags);
995 }
996 
1014 static inline int zbc_finish_zone(struct zbc_device *dev,
1015  uint64_t sector, unsigned int flags)
1016 {
1017  return zbc_zone_operation(dev, sector,
1018  ZBC_OP_FINISH_ZONE, flags);
1019 }
1020 
1037 static inline int zbc_reset_zone(struct zbc_device *dev,
1038  uint64_t sector, unsigned int flags)
1039 {
1040  return zbc_zone_operation(dev, sector,
1041  ZBC_OP_RESET_ZONE, flags);
1042 }
1043 
1066 extern ssize_t zbc_pread(struct zbc_device *dev, void *buf,
1067  size_t count, uint64_t offset);
1068 
1092 extern ssize_t zbc_pwrite(struct zbc_device *dev, const void *buf,
1093  size_t count, uint64_t offset);
1094 
1108 extern ssize_t zbc_preadv(struct zbc_device *dev,
1109  const struct iovec *iov, int iovcnt,
1110  uint64_t offset);
1111 
1125 extern ssize_t zbc_pwritev(struct zbc_device *dev,
1126  const struct iovec *iov, int iovcnt,
1127  uint64_t offset);
1128 
1145 extern int zbc_map_iov(const void *buf, size_t sectors,
1146  struct iovec *iov, int iovcnt, size_t iovlen);
1147 
1157 extern int zbc_flush(struct zbc_device *dev);
1158 
1163 #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:415
Definition: zbc.h:574
uint64_t zbd_pblocks
Definition: zbc.h:481
Definition: zbc.h:906
uint32_t zbd_opt_nr_open_seq_pref
Definition: zbc.h:494
Definition: zbc.h:134
Definition: zbc.h:668
Definition: zbc.h:763
Definition: zbc.h:71
zbc_zone_condition
Zone condition definitions.
Definition: zbc.h:101
Definition: zbc.h:896
const char * zbc_sk_str(enum zbc_sk sk)
Returns a string describing a sense key.
Definition: zbc.h:535
uint64_t zbz_write_pointer
Definition: zbc.h:209
zbc_zone_attributes
Zone attributes definitions.
Definition: zbc.h:162
Definition: zbc.h:538
Definition: zbc.h:586
Definition: zbc.h:923
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:601
uint8_t zbz_attributes
Definition: zbc.h:224
enum zbc_dev_type zbd_type
Definition: zbc.h:441
Definition: zbc.h:144
Definition: zbc.h:129
Definition: zbc.h:171
Definition: zbc.h:807
const char * zbc_asc_ascq_str(enum zbc_asc_ascq asc_ascq)
Returns a string describing a sense code.
Definition: zbc.h:671
Definition: zbc.h:111
Definition: zbc.h:123
Definition: zbc.h:311
uint64_t zbd_max_rw_sectors
Definition: zbc.h:487
uint32_t zbd_max_nr_open_seq_req
Definition: zbc.h:509
enum zbc_asc_ascq asc_ascq
Definition: zbc.h:604
zbc_zone_op
Zone operation codes definitions.
Definition: zbc.h:886
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:306
uint8_t __pad[5]
Definition: zbc.h:229
Definition: zbc.h:577
Definition: zbc.h:677
void zbc_print_device_info(struct zbc_device_info *info, FILE *out)
Print a device information.
Definition: zbc.h:541
zbc_asc_ascq
SCSI Additional sense codes and qualifiers definitions.
Definition: zbc.h:556
Definition: zbc.h:778
zbc_dev_flags
Device flags definitions.
Definition: zbc.h:408
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:891
Definition: zbc.h:753
Definition: zbc.h:559
zbc_zone_type
Zone type definitions.
Definition: zbc.h:61
Zone information data structure.
Definition: zbc.h:194
uint8_t zbz_type
Definition: zbc.h:214
Device information data structure.
Definition: zbc.h:436
Definition: zbc.h:321
Definition: zbc.h:372
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:476
Definition: zbc.h:547
zbc_zone_op_flags
Zone operation flag definitions.
Definition: zbc.h:918
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:788
const char * zbc_device_model_str(enum zbc_dev_model model)
Returns a device zone model name.
Definition: zbc.h:565
Definition: zbc.h:768
Definition: zbc.h:583
zbc_dev_model
Device model definitions.
Definition: zbc.h:355
Definition: zbc.h:77
Definition: zbc.h:812
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:901
Definition: zbc.h:83
Definition: zbc.h:800
int zbc_open(const char *filename, int flags, struct zbc_device **dev)
Open a ZBC device.
Definition: zbc.h:326
Definition: zbc.h:367
Definition: zbc.h:795
#define ZBC_DEVICE_INFO_LENGTH
Definition: zbc.h:299
Definition: zbc.h:758
const char * zbc_zone_condition_str(enum zbc_zone_condition cond)
Returns a string describing a zone condition.
Definition: zbc.h:544
Definition: zbc.h:360
Definition: zbc.h:66
zbc_oflags
ZBC device open flags.
Definition: zbc.h:665
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:199
Definition: zbc.h:589
Definition: zbc.h:379
Definition: zbc.h:783
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:461
zbc_reporting_options
Reporting options definitions.
Definition: zbc.h:748
enum zbc_dev_model zbd_model
Definition: zbc.h:446
Definition: zbc.h:106
Detailed error information data structure.
Definition: zbc.h:598
Definition: zbc.h:773
uint64_t zbz_start
Definition: zbc.h:204
Definition: zbc.h:674
Definition: zbc.h:316
ssize_t zbc_pread(struct zbc_device *dev, void *buf, size_t count, uint64_t offset)
Read sectors form a device.
Definition: zbc.h:117
uint32_t zbd_flags
Definition: zbc.h:456
Definition: zbc.h:386
uint32_t zbd_lblock_size
Definition: zbc.h:466
uint8_t zbz_condition
Definition: zbc.h:219
uint64_t zbd_lblocks
Definition: zbc.h:471
Definition: zbc.h:331
char zbd_vendor_id[ZBC_DEVICE_INFO_LENGTH]
Definition: zbc.h:451
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:139
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:502
zbc_sk
SCSI Sense keys definitions.
Definition: zbc.h:532
int zbc_close(struct zbc_device *dev)
Close a ZBC device.
Definition: zbc.h:180