Hello community,
here is the log from the commit of package libzbc for openSUSE:Factory checked
in at 2016-12-08 00:31:12
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/libzbc (Old)
and /work/SRC/openSUSE:Factory/.libzbc.new (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "libzbc"
Changes:
--------
--- /work/SRC/openSUSE:Factory/libzbc/libzbc.changes 2016-10-10
16:21:46.000000000 +0200
+++ /work/SRC/openSUSE:Factory/.libzbc.new/libzbc.changes 2016-12-08
00:31:13.000000000 +0100
@@ -1,0 +2,7 @@
+Tue Nov 29 10:31:02 UTC 2016 - jeng...@inai.de
+
+- Update to new upstream release 4.3.3
+ * block backend driver: support latest "official" kernel
+ interface queued up for kernel 4.10 release.
+
+-------------------------------------------------------------------
Old:
----
v4.3.0.tar.gz
New:
----
v4.3.3.tar.gz
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Other differences:
------------------
++++++ libzbc.spec ++++++
--- /var/tmp/diff_new_pack.N3MIOt/_old 2016-12-08 00:31:14.000000000 +0100
+++ /var/tmp/diff_new_pack.N3MIOt/_new 2016-12-08 00:31:14.000000000 +0100
@@ -17,8 +17,8 @@
Name: libzbc
-%define lname libzbc-4_3_0
-Version: 4.3.0
+%define lname libzbc-4_3_3
+Version: 4.3.3
Release: 0
Summary: Library for manipulating ZBC and ZAC disks
License: BSD-2-Clause and LGPL-3.0+
++++++ v4.3.0.tar.gz -> v4.3.3.tar.gz ++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/libzbc-4.3.0/.gitignore new/libzbc-4.3.3/.gitignore
--- old/libzbc-4.3.0/.gitignore 2016-08-18 04:04:10.000000000 +0200
+++ new/libzbc-4.3.3/.gitignore 2016-11-15 07:55:55.000000000 +0100
@@ -26,6 +26,7 @@
*.hex
zbc_info
+zbc_inquiry
zbc_report_zones
zbc_reset_write_ptr
zbc_close_zone
@@ -98,3 +99,8 @@
tools/lkvs/m4/ltversion.m4
tools/lkvs/m4/lt~obsolete.m4
+tools/lkvs/src/examples/lkvsfileput
+tools/lkvs/src/examples/lkvsget
+tools/lkvs/src/examples/lkvsmultiget
+tools/lkvs/src/examples/lkvsmultiput
+tools/lkvs/src/examples/lkvsput
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/libzbc-4.3.0/configure.ac
new/libzbc-4.3.3/configure.ac
--- old/libzbc-4.3.0/configure.ac 2016-08-18 04:04:10.000000000 +0200
+++ new/libzbc-4.3.3/configure.ac 2016-11-15 07:55:55.000000000 +0100
@@ -1,5 +1,5 @@
-AC_INIT([libzbc], [4.3.0], [damien.lem...@hgst.com, adam.manzana...@hgst.com])
+AC_INIT([libzbc], [4.3.3], [damien.lem...@wdc.com, adam.manzana...@wdc.com])
AC_CONFIG_AUX_DIR([build-aux])
AC_CONFIG_MACRO_DIR([m4])
AC_CONFIG_HEADER([include/config.h])
@@ -24,6 +24,12 @@
CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
CC="$PTHREAD_CC"
+# Checks for header files.
+AC_CHECK_HEADER(scsi/scsi.h, [], [AC_MSG_ERROR([Couldn't find scsi/scsi.h])])
+AC_CHECK_HEADER(scsi/sg.h, [], [AC_MSG_ERROR([Couldn't find scsi/sg.h])])
+AC_CHECK_HEADER(libgen.h, [], [AC_MSG_ERROR([Couldn't find libgen.h])])
+AC_CHECK_HEADERS([linux/fs.h linux/blkzoned.h])
+
# Conditionals
# Build gzbc only if GTK3 is installed.
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/libzbc-4.3.0/lib/zbc.h new/libzbc-4.3.3/lib/zbc.h
--- old/libzbc-4.3.0/lib/zbc.h 2016-08-18 04:04:10.000000000 +0200
+++ new/libzbc-4.3.3/lib/zbc.h 2016-11-15 07:55:55.000000000 +0100
@@ -18,7 +18,8 @@
/***** Including files *****/
-#include <libzbc/zbc.h>
+#include "config.h"
+#include "libzbc/zbc.h"
#include "zbc_log.h"
#include <stdlib.h>
@@ -199,22 +200,26 @@
extern int
zbc_scsi_get_zbd_chars(zbc_device_t *dev);
-extern int
-zbc_scsi_report_zones(zbc_device_t *dev,
- uint64_t start_lba,
- enum zbc_reporting_options ro,
- uint64_t *max_lba,
- zbc_zone_t *zones,
- unsigned int *nr_zones);
-
+/**
+ * SCSI backend driver open zone method.
+ * Used in block device backend too.
+ */
extern int
zbc_scsi_open_zone(zbc_device_t *dev,
uint64_t start_lba);
+/**
+ * SCSI backend driver close zone method.
+ * Used in block device backend too.
+ */
extern int
zbc_scsi_close_zone(zbc_device_t *dev,
uint64_t start_lba);
+/**
+ * SCSI backend driver finish zone method.
+ * Used in block device backend too.
+ */
extern int
zbc_scsi_finish_zone(zbc_device_t *dev,
uint64_t start_lba);
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/libzbc-4.3.0/lib/zbc_block.c
new/libzbc-4.3.3/lib/zbc_block.c
--- old/libzbc-4.3.0/lib/zbc_block.c 2016-08-18 04:04:10.000000000 +0200
+++ new/libzbc-4.3.3/lib/zbc_block.c 2016-11-15 07:55:55.000000000 +0100
@@ -24,23 +24,41 @@
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
+#include <limits.h>
#include <linux/fs.h>
#include "zbc.h"
#include "zbc_sg.h"
-/***** Macro and types definitions *****/
+#ifdef HAVE_LINUX_BLKZONED_H
+#include <linux/blkzoned.h>
+#endif
-/**
- * Block device descriptor data.
- */
-typedef struct zbc_block_device {
+/***** Inline functions *****/
+
+static inline uint64_t zbc_block_lba2bytes(struct zbc_device *dev,
+ uint64_t lba)
+{
+ return lba * dev->zbd_info.zbd_logical_block_size;
+}
- struct zbc_device dev;
+static inline uint64_t zbc_block_bytes2lba(struct zbc_device *dev,
+ uint64_t bytes)
+{
+ return bytes / dev->zbd_info.zbd_logical_block_size;
+}
- unsigned int zone_sectors;
+static inline uint64_t zbc_block_lba2sector(struct zbc_device *dev,
+ uint64_t lba)
+{
+ return zbc_block_lba2bytes(dev, lba) >> 9;
+}
-} zbc_block_device_t;
+static inline uint64_t zbc_block_sector2lba(struct zbc_device *dev,
+ uint64_t sector)
+{
+ return zbc_block_bytes2lba(dev, sector << 9);
+}
/***** Definition of private functions *****/
@@ -55,70 +73,34 @@
}
/**
- * Convert device address to block device handle address.
- */
-static inline zbc_block_device_t *
-zbc_dev_to_block_dev(struct zbc_device *dev)
-{
- return container_of(dev, struct zbc_block_device, dev);
-}
-
-/**
* Test if the block device is zoned.
*/
static int
zbc_block_device_is_zoned(struct zbc_device *dev)
{
- zbc_block_device_t *bdev = zbc_dev_to_block_dev(dev);
- unsigned long long start, len;
- unsigned int type, nr_zones;
- int is_zoned = 0;
char str[128];
- FILE *zoned;
- int ret = 1;
+ FILE *file;
- /* Check zoned attributes, if any */
+ /* Check that this is a zoned block device */
snprintf(str, sizeof(str),
"/sys/block/%s/queue/zoned",
basename(dev->zbd_filename));
- zoned = fopen(str, "r");
- if ( ! zoned ) {
- /* Not a zoned block device or no kernel support */
- return 0;
+ file = fopen(str, "r");
+ if ( file ) {
+ memset(str, 0, sizeof(str));
+ fscanf(file, "%s", str);
}
+ fclose(file);
- while( 1 ) {
-
- start = len = 0;
- type = -1;
- nr_zones = 0;
- ret = fscanf(zoned, "%llu %llu %u %u", &start, &len, &type, &nr_zones);
- if ( (ret == EOF) || (ret != 4) ) {
- break;
- }
-
- if ( nr_zones == 0 ) {
- /* Not a zoned block device */
- ret = 0;
- break;
- }
-
- if ( type >= 2 ) {
- if ( type == 2 ) {
- dev->zbd_info.zbd_model = ZBC_DM_HOST_MANAGED;
- } else {
- dev->zbd_info.zbd_model = ZBC_DM_HOST_AWARE;
- }
- bdev->zone_sectors = len;
- is_zoned = 1;
- break;
- }
-
+ if ( strcmp(str, "host-aware") == 0 ) {
+ dev->zbd_info.zbd_model = ZBC_DM_HOST_AWARE;
+ return 1;
+ } else if ( strcmp(str, "host-managed") == 0 ) {
+ dev->zbd_info.zbd_model = ZBC_DM_HOST_MANAGED;
+ return 1;
}
- fclose(zoned);
-
- return is_zoned;
+ return 0;
}
@@ -147,7 +129,7 @@
}
}
- return( len );
+ return len;
}
@@ -167,11 +149,10 @@
file = fopen(str, "r");
if ( file ) {
len = zbc_block_get_str(file, str);
- if ( len ) {
+ if ( len )
n = snprintf(dev->zbd_info.zbd_vendor_id,
ZBC_DEVICE_INFO_LENGTH,
"%s ", str);
- }
fclose(file);
}
@@ -181,11 +162,10 @@
file = fopen(str, "r");
if ( file ) {
len = zbc_block_get_str(file, str);
- if ( len ) {
+ if ( len )
n += snprintf(&dev->zbd_info.zbd_vendor_id[n],
ZBC_DEVICE_INFO_LENGTH - n,
"%s ", str);
- }
fclose(file);
}
@@ -195,11 +175,10 @@
file = fopen(str, "r");
if ( file ) {
len = zbc_block_get_str(file, str);
- if ( len ) {
+ if ( len )
snprintf(&dev->zbd_info.zbd_vendor_id[n],
ZBC_DEVICE_INFO_LENGTH - n,
"%s", str);
- }
fclose(file);
ret = 1;
}
@@ -210,10 +189,10 @@
/**
* Test if the device can be handled
- * and set a the block device info.
+ * and get the block device info.
*/
static int
-zbc_block_set_info(struct zbc_device *dev)
+zbc_block_get_info(struct zbc_device *dev)
{
unsigned long long size64;
struct stat st;
@@ -236,10 +215,9 @@
}
/* Is this a zoned device ? And do we have kernel support ? */
- if ( ! zbc_block_device_is_zoned(dev) ) {
+ if ( ! zbc_block_device_is_zoned(dev) )
/* Not a zoned block device: ignore */
return -ENXIO;
- }
/* Get logical block size */
ret = ioctl(dev->zbd_fd, BLKSSZGET, &size32);
@@ -312,9 +290,8 @@
}
/* Use SG_IO to get zone characteristics (maximum number of open zones,
etc) */
- if ( zbc_scsi_get_zbd_chars(dev) ) {
+ if ( zbc_scsi_get_zbd_chars(dev) )
return -ENXIO;
- }
/* Get maximum command size */
zbc_sg_get_max_cmd_blocks(dev);
@@ -331,13 +308,17 @@
int flags,
struct zbc_device **pdev)
{
- zbc_block_device_t *bdev;
struct zbc_device *dev;
int fd, ret;
zbc_debug("%s: ########## Trying BLOCK driver ##########\n",
filename);
+#ifndef HAVE_LINUX_BLKZONED_H
+ zbc_debug("libzbc compiled without block driver support\n");
+ return -ENXIO;
+#endif
+
/* Open block device: always add write mode for discard (reset zone) */
fd = open(filename, zbc_open_flags(flags) | O_WRONLY);
if ( fd < 0 ) {
@@ -351,24 +332,19 @@
/* Allocate a handle */
ret = -ENOMEM;
- bdev = calloc(1, sizeof(*bdev));
- if ( ! bdev ) {
+ dev = calloc(1, sizeof(struct zbc_device));
+ if ( ! dev )
goto out;
- }
- bdev->zone_sectors = 0;
- dev = &bdev->dev;
dev->zbd_fd = fd;
dev->zbd_filename = strdup(filename);
- if ( ! dev->zbd_filename ) {
+ if ( ! dev->zbd_filename )
goto out_free_dev;
- }
- /* Set the fake device information */
- ret = zbc_block_set_info(dev);
- if ( ret != 0 ) {
+ /* Get device information */
+ ret = zbc_block_get_info(dev);
+ if ( ret != 0 )
goto out_free_filename;
- }
*pdev = dev;
@@ -383,13 +359,12 @@
out_free_dev:
- free(bdev);
+ free(dev);
out:
- if ( fd >= 0 ) {
+ if ( fd >= 0 )
close(fd);
- }
zbc_debug("%s: ########## BLOCK driver failed %d ##########\n",
filename,
@@ -405,23 +380,23 @@
static int
zbc_block_close(zbc_device_t *dev)
{
- zbc_block_device_t *bdev = zbc_dev_to_block_dev(dev);
int ret = 0;
/* Close device */
- if ( close(dev->zbd_fd) < 0 ) {
+ if ( close(dev->zbd_fd) < 0 )
ret = -errno;
- }
if ( ret == 0 ) {
free(dev->zbd_filename);
- free(bdev);
+ free(dev);
}
return ret;
}
+#ifdef HAVE_LINUX_BLKZONED_H
+
/**
* Flush the device.
*/
@@ -435,9 +410,51 @@
}
/**
- * Get the block device zone information: use SG_IO, but
- * sync the device first to ensure that the current write
- * pointer value is returned.
+ * Test if a zone should be reported depending
+ * on the specified reporting options.
+ */
+static bool
+zbc_block_must_report(struct zbc_zone *zone,
+ enum zbc_reporting_options ro)
+{
+ enum zbc_reporting_options options = ro & (~ZBC_RO_PARTIAL);
+
+ switch ( options ) {
+ case ZBC_RO_ALL:
+ return true;
+ case ZBC_RO_EMPTY:
+ return zbc_zone_empty(zone);
+ case ZBC_RO_IMP_OPEN:
+ return zbc_zone_imp_open(zone);
+ case ZBC_RO_EXP_OPEN:
+ return zbc_zone_exp_open(zone);
+ case ZBC_RO_CLOSED:
+ return zbc_zone_closed(zone);
+ case ZBC_RO_FULL:
+ return zbc_zone_full(zone);
+ case ZBC_RO_RDONLY:
+ return zbc_zone_rdonly(zone);
+ case ZBC_RO_OFFLINE:
+ return zbc_zone_offline(zone);
+ case ZBC_RO_RESET:
+ return zbc_zone_need_reset(zone);
+ case ZBC_RO_NON_SEQ:
+ return zbc_zone_non_seq(zone);
+ case ZBC_RO_NOT_WP:
+ return zbc_zone_not_wp(zone);
+ default:
+ break;
+ }
+
+ return false;
+
+
+}
+
+#define ZBC_BLOCK_ZONE_REPORT_NR_ZONES 8192
+
+/**
+ * Get the block device zone information.
*/
static int
zbc_block_report_zones(struct zbc_device *dev,
@@ -447,11 +464,77 @@
struct zbc_zone *zones,
unsigned int *nr_zones)
{
+ struct zbc_zone zone;
+ struct blk_zone_report *rep;
+ struct blk_zone *blkz;
+ unsigned int i, n = 0;
+ int ret;
+
+ rep = malloc(sizeof(struct blk_zone_report) +
+ sizeof(struct blk_zone) * ZBC_BLOCK_ZONE_REPORT_NR_ZONES);
+ if ( ! rep ) {
+ zbc_error("%s: No memory for report zones\n",
+ dev->zbd_filename);
+ return -ENOMEM;
+ }
+ blkz = (struct blk_zone *)(rep + 1);
+
+ while ( ((! *nr_zones) || (n < *nr_zones))
+ && (start_lba < dev->zbd_info.zbd_logical_blocks) ) {
+
+ /* Get zone info */
+ memset(rep, 0, sizeof(struct blk_zone_report) +
+ sizeof(struct blk_zone) * ZBC_BLOCK_ZONE_REPORT_NR_ZONES);
+ rep->sector = zbc_block_lba2sector(dev, start_lba);
+ rep->nr_zones = ZBC_BLOCK_ZONE_REPORT_NR_ZONES;
+
+ ret = ioctl(dev->zbd_fd, BLKREPORTZONE, rep);
+ if ( ret != 0 ) {
+ ret = -errno;
+ zbc_error("%s: ioctl BLKREPORTZONE at %llu failed %d (%s)\n",
+ dev->zbd_filename,
+ (unsigned long long)start_lba,
+ errno,
+ strerror(errno));
+ goto out;
+ }
+
+ for(i = 0; i < rep->nr_zones; i++) {
+
+ if ( (*nr_zones && (n >= *nr_zones))
+ || (start_lba >= dev->zbd_info.zbd_logical_blocks) )
+ break;
+
+ memset(&zone, 0, sizeof(struct zbc_zone));
+ zone.zbz_type = blkz[i].type;
+ zone.zbz_condition = blkz[i].cond;
+ zone.zbz_length = zbc_block_sector2lba(dev, blkz[i].len);
+ zone.zbz_start = zbc_block_sector2lba(dev, blkz[i].start);
+ zone.zbz_write_pointer = zbc_block_sector2lba(dev, blkz[i].wp);
+ if ( blkz[i].reset )
+ zone.zbz_flags |= ZBC_ZF_NEED_RESET;
+ if ( blkz[i].non_seq )
+ zone.zbz_flags |= ZBC_ZF_NON_SEQ;
+
+ if ( zbc_block_must_report(&zone, ro) ) {
+ if ( zones )
+ memcpy(&zones[n], &zone, sizeof(struct zbc_zone));
+ n++;
+ }
+
+ start_lba += zbc_zone_length(&zone);
+
+ }
+
+ }
+
+ /* Return number of zones */
+ *nr_zones = n;
- fdatasync(dev->zbd_fd);
+out:
+ free(rep);
- return zbc_scsi_report_zones(dev, start_lba, ro,
- max_lba, zones, nr_zones);
+ return ret;
}
@@ -460,7 +543,7 @@
*/
static int
zbc_block_open_zone(zbc_device_t *dev,
- uint64_t start_lba)
+ uint64_t start_lba)
{
return zbc_scsi_open_zone(dev, start_lba);
}
@@ -470,7 +553,7 @@
*/
static int
zbc_block_close_zone(zbc_device_t *dev,
- uint64_t start_lba)
+ uint64_t start_lba)
{
return zbc_scsi_close_zone(dev, start_lba);
}
@@ -480,37 +563,130 @@
*/
static int
zbc_block_finish_zone(zbc_device_t *dev,
- uint64_t start_lba)
+ uint64_t start_lba)
{
return zbc_scsi_finish_zone(dev, start_lba);
}
/**
+ * Reset a single zone write pointer.
+ */
+static int
+zbc_block_reset_one(struct zbc_device *dev,
+ uint64_t start_lba)
+{
+ struct blk_zone_range range;
+ struct zbc_zone zone;
+ unsigned int nr_zones = 1;
+ int ret;
+
+ /* Get zone info */
+ ret = zbc_block_report_zones(dev, start_lba,
+ ZBC_RO_ALL, NULL,
+ &zone, &nr_zones);
+ if (ret)
+ return ret;
+ if (! nr_zones ) {
+ zbc_error("%s: Invalid LBA\n",
+ dev->zbd_filename);
+ return -EINVAL;
+ }
+
+ if (zbc_zone_conventional(&zone)
+ || zbc_zone_empty(&zone))
+ return 0;
+
+ /* Reset zone */
+ range.sector = zbc_block_lba2sector(dev, zbc_zone_start_lba(&zone));
+ range.nr_sectors = zbc_block_lba2sector(dev, zbc_zone_length(&zone));
+ ret = ioctl(dev->zbd_fd, BLKRESETZONE, &range);
+ if ( ret != 0 ) {
+ ret = -errno;
+ zbc_error("%s: ioctl BLKRESETZONE failed %d (%s)\n",
+ dev->zbd_filename,
+ errno,
+ strerror(errno));
+ }
+
+ return ret;
+
+}
+
+/**
+ * Reset all zones write pointer.
+ */
+static int
+zbc_block_reset_all(struct zbc_device *dev)
+{
+ struct zbc_zone *zones;
+ unsigned int i, nr_zones;
+ struct blk_zone_range range;
+ uint64_t start_lba = 0;
+ int ret;
+
+ zones = malloc(sizeof(struct zbc_zone) * ZBC_BLOCK_ZONE_REPORT_NR_ZONES);
+ if ( ! zones ) {
+ zbc_error("%s: No memory for report zones\n",
+ dev->zbd_filename);
+ return -ENOMEM;
+ }
+
+ while ( 1 ) {
+
+ /* Get zone info */
+ nr_zones = ZBC_BLOCK_ZONE_REPORT_NR_ZONES;
+ ret = zbc_block_report_zones(dev, start_lba,
+ ZBC_RO_ALL, NULL,
+ zones, &nr_zones);
+ if (ret || (! nr_zones))
+ break;
+
+ for (i = 0; i < nr_zones; i++) {
+
+ start_lba = zbc_zone_next_lba(&zones[i]);
+
+ if (zbc_zone_conventional(&zones[i])
+ || zbc_zone_empty(&zones[i]))
+ continue;
+
+ /* Reset zone */
+ range.sector = zbc_block_lba2sector(dev,
zbc_zone_start_lba(&zones[i]));
+ range.nr_sectors = zbc_block_lba2sector(dev,
zbc_zone_length(&zones[i]));
+ ret = ioctl(dev->zbd_fd, BLKRESETZONE, &range);
+ if ( ret != 0 ) {
+ ret = -errno;
+ zbc_error("%s: ioctl BLKRESETZONE failed %d (%s)\n",
+ dev->zbd_filename,
+ errno,
+ strerror(errno));
+ goto out;
+ }
+
+ }
+
+ }
+
+out:
+ free(zones);
+
+ return ret;
+
+}
+
+/**
* Reset zone(s) write pointer: use BLKDISCARD ioctl.
*/
static int
zbc_block_reset_wp(struct zbc_device *dev,
uint64_t start_lba)
{
- zbc_block_device_t *bdev = zbc_dev_to_block_dev(dev);
- uint64_t range[2];
- if ( start_lba == (uint64_t)-1 ) {
- /* Reset all zones */
- range[0] = 0;
- range[1] = dev->zbd_info.zbd_logical_blocks *
dev->zbd_info.zbd_logical_block_size;
- } else {
- /* Reset only the zone at start_lba */
- range[0] = start_lba * dev->zbd_info.zbd_logical_block_size;
- range[1] = bdev->zone_sectors << 9;
- }
-
- /* Discard */
- if ( ioctl(dev->zbd_fd, BLKDISCARD, &range) != 0 ) {
- return -errno;
- }
+ if ( start_lba == (uint64_t)-1 )
+ /* All zones */
+ return zbc_block_reset_all(dev);
- return 0;
+ /* One zone */
+ return zbc_block_reset_one(dev, start_lba);
}
@@ -529,13 +705,12 @@
/* Read */
ret = pread(dev->zbd_fd,
buf,
- lba_count * dev->zbd_info.zbd_logical_block_size,
- (zone->zbz_start + lba_ofst) *
dev->zbd_info.zbd_logical_block_size);
- if ( ret < 0 ) {
+ zbc_block_lba2bytes(dev, lba_count),
+ zbc_block_lba2bytes(dev, zone->zbz_start + lba_ofst));
+ if ( ret < 0 )
ret = -errno;
- } else {
- ret /= dev->zbd_info.zbd_logical_block_size;
- }
+ else
+ ret = zbc_block_bytes2lba(dev, ret);
return ret;
@@ -556,18 +731,90 @@
/* Read */
ret = pwrite(dev->zbd_fd,
buf,
- lba_count * dev->zbd_info.zbd_logical_block_size,
- (zone->zbz_start + lba_ofst) *
dev->zbd_info.zbd_logical_block_size);
- if ( ret < 0 ) {
+ zbc_block_lba2bytes(dev, lba_count),
+ zbc_block_lba2bytes(dev, zone->zbz_start + lba_ofst));
+ if ( ret < 0 )
ret = -errno;
- } else {
- ret /= dev->zbd_info.zbd_logical_block_size;
- }
+ else
+ ret = zbc_block_bytes2lba(dev, ret);
return ret;
}
+#else /* HAVE_LINUX_BLKZONED_H */
+
+static int
+zbc_block_report_zones(struct zbc_device *dev,
+ uint64_t start_lba,
+ enum zbc_reporting_options ro,
+ uint64_t *max_lba,
+ struct zbc_zone *zones,
+ unsigned int *nr_zones)
+{
+ return -EOPNOTSUPP;
+}
+
+static int
+zbc_block_open_zone(zbc_device_t *dev,
+ uint64_t start_lba)
+{
+ return -EOPNOTSUPP;
+}
+
+static int
+zbc_block_close_zone(zbc_device_t *dev,
+ uint64_t start_lba)
+{
+ return -EOPNOTSUPP;
+}
+
+static int
+zbc_block_finish_zone(zbc_device_t *dev,
+ uint64_t start_lba)
+{
+ return -EOPNOTSUPP;
+}
+
+
+static int
+zbc_block_reset_wp(struct zbc_device *dev,
+ uint64_t start_lba)
+{
+ return -EOPNOTSUPP;
+}
+
+static int32_t
+zbc_block_pread(struct zbc_device *dev,
+ zbc_zone_t *zone,
+ void *buf,
+ uint32_t lba_count,
+ uint64_t lba_ofst)
+{
+ return -EOPNOTSUPP;
+}
+
+static int32_t
+zbc_block_pwrite(struct zbc_device *dev,
+ zbc_zone_t *zone,
+ const void *buf,
+ uint32_t lba_count,
+ uint64_t lba_ofst)
+{
+ return -EOPNOTSUPP;
+}
+
+static int
+zbc_block_flush(struct zbc_device *dev,
+ uint64_t lba_offset,
+ uint32_t lba_count,
+ int immediate)
+{
+ return -EOPNOTSUPP;
+}
+
+#endif /* HAVE_LINUX_BLKZONED_H */
+
struct zbc_ops zbc_block_ops = {
.zbd_open = zbc_block_open,
.zbd_close = zbc_block_close,
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/libzbc-4.3.0/lib/zbc_scsi.c
new/libzbc-4.3.3/lib/zbc_scsi.c
--- old/libzbc-4.3.0/lib/zbc_scsi.c 2016-08-18 04:04:10.000000000 +0200
+++ new/libzbc-4.3.3/lib/zbc_scsi.c 2016-11-15 07:55:55.000000000 +0100
@@ -299,7 +299,7 @@
/**
* Get a SCSI device zone information.
*/
-int
+static int
zbc_scsi_report_zones(zbc_device_t *dev,
uint64_t start_lba,
enum zbc_reporting_options ro,
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/libzbc-4.3.0/test/scripts/zbc_test_lib.sh
new/libzbc-4.3.3/test/scripts/zbc_test_lib.sh
--- old/libzbc-4.3.0/test/scripts/zbc_test_lib.sh 2016-08-18
04:04:10.000000000 +0200
+++ new/libzbc-4.3.3/test/scripts/zbc_test_lib.sh 2016-11-15
07:55:55.000000000 +0100
@@ -32,6 +32,7 @@
# Store argument
device=$2
+ device_base=`basename ${device}`
bin_path=$3
# Test name
@@ -48,7 +49,7 @@
rm -f ${log_file}
# Zone info file
- zone_info_file="/tmp/${test_name}_zone_info.log"
+ zone_info_file="/tmp/${test_name}_zone_info.${device_base}.log"
rm -f ${zone_info_file}
# Dump zone info file
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/libzbc-4.3.0/test/zbc_test.sh
new/libzbc-4.3.3/test/zbc_test.sh
--- old/libzbc-4.3.0/test/zbc_test.sh 2016-08-18 04:04:10.000000000 +0200
+++ new/libzbc-4.3.3/test/zbc_test.sh 2016-11-15 07:55:55.000000000 +0100
@@ -18,6 +18,7 @@
fi
device_file=${1}
+device_base=`basename ${device_file}`
# Check credentials
if [ $(id -u) -ne 0 ]; then
@@ -25,16 +26,13 @@
exit 1
fi
-# Set file names
-log_file=${log_path}/${testname}.log
-
# Test function
function zbc_run_test()
{
declare -i run_test_ret=0
ZBC_TEST_SUB_SCR_PATH=${ZBC_TEST_SCR_PATH}/${1}
- ZBC_TEST_SUB_LOG_PATH=${ZBC_TEST_LOG_PATH}/${1}
+ ZBC_TEST_SUB_LOG_PATH=${ZBC_TEST_LOG_PATH}/${device_base}/${1}
if [ ! -d ${ZBC_TEST_SUB_SCR_PATH} ]; then
echo "Test script directory ${ZBC_TEST_SUB_SCR_PATH} does not exist"
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/libzbc-4.3.0/tools/read_zone/zbc_read_zone.c
new/libzbc-4.3.3/tools/read_zone/zbc_read_zone.c
--- old/libzbc-4.3.0/tools/read_zone/zbc_read_zone.c 2016-08-18
04:04:10.000000000 +0200
+++ new/libzbc-4.3.3/tools/read_zone/zbc_read_zone.c 2016-11-15
07:55:55.000000000 +0100
@@ -41,7 +41,7 @@
/**
* System time in usecs.
*/
-static __inline__ unsigned long long
+static inline unsigned long long
zbc_read_zone_usec(void)
{
struct timeval tv;
@@ -264,7 +264,7 @@
ret = 1;
goto out;
}
- ret = posix_memalign((void **) &iobuf, info.zbd_logical_block_size,
iosize);
+ ret = posix_memalign((void **) &iobuf, sysconf(_SC_PAGESIZE), iosize);
if ( ret != 0 ) {
fprintf(stderr,
"No memory for I/O buffer (%zu B)\n",
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/libzbc-4.3.0/tools/report_zones/zbc_report_zones.c
new/libzbc-4.3.3/tools/report_zones/zbc_report_zones.c
--- old/libzbc-4.3.0/tools/report_zones/zbc_report_zones.c 2016-08-18
04:04:10.000000000 +0200
+++ new/libzbc-4.3.3/tools/report_zones/zbc_report_zones.c 2016-11-15
07:55:55.000000000 +0100
@@ -29,7 +29,7 @@
char **argv)
{
struct zbc_device_info info;
- unsigned long long lba = 0;
+ unsigned long long lba = 0, nr_lba = 0;
struct zbc_device *dev;
enum zbc_reporting_options ro = ZBC_RO_ALL;
int i, ret = 1;
@@ -232,10 +232,27 @@
}
printf("%u / %u zone%s:\n", nz, nr_zones, (nz > 1) ? "s" : "");
+ lba = 0;
for(i = 0; i < (int)nz; i++) {
+
z = &zones[i];
+
+ if (ro == ZBC_RO_ALL) {
+ /* Check */
+ if (zbc_zone_start_lba(z) != lba) {
+ printf("[WARNING] Zone %05d: LBA %llu should be %llu\n",
+ i,
+ zbc_zone_start_lba(z),
+ lba);
+ lba = zbc_zone_start_lba(z);
+ }
+ nr_lba += zbc_zone_length(z);
+ lba += zbc_zone_length(z);
+ }
+
if ( zbc_zone_conventional(z) ) {
- printf("Zone %05d: type 0x%x (%s), cond 0x%x (%s), LBA %llu, %llu
sectors, wp N/A\n",
+ printf("Zone %05d: type 0x%x (%s), cond 0x%x (%s), LBA %llu, "
+ "%llu sectors, wp N/A\n",
i,
zbc_zone_type(z),
zbc_zone_type_str(zbc_zone_type(z)),
@@ -243,19 +260,41 @@
zbc_zone_condition_str(zbc_zone_condition(z)),
zbc_zone_start_lba(z),
zbc_zone_length(z));
- } else {
- printf("Zone %05d: type 0x%x (%s), cond 0x%x (%s), need_reset %d,
non_seq %d, LBA %llu, %llu sectors, wp %llu\n",
- i,
- zbc_zone_type(z),
- zbc_zone_type_str(zbc_zone_type(z)),
- zbc_zone_condition(z),
- zbc_zone_condition_str(zbc_zone_condition(z)),
- zbc_zone_need_reset(z),
- zbc_zone_non_seq(z),
- zbc_zone_start_lba(z),
- zbc_zone_length(z),
- zbc_zone_wp_lba(z));
+ continue;
+ }
+
+ if ( zbc_zone_sequential(z) ) {
+ printf("Zone %05d: type 0x%x (%s), cond 0x%x (%s), need_reset %d, "
+ "non_seq %d, LBA %llu, %llu sectors, wp %llu\n",
+ i,
+ zbc_zone_type(z),
+ zbc_zone_type_str(zbc_zone_type(z)),
+ zbc_zone_condition(z),
+ zbc_zone_condition_str(zbc_zone_condition(z)),
+ zbc_zone_need_reset(z),
+ zbc_zone_non_seq(z),
+ zbc_zone_start_lba(z),
+ zbc_zone_length(z),
+ zbc_zone_wp_lba(z));
+ continue;
}
+
+ printf("Zone %05d: unknown type 0x%x, LBA %llu, %llu sectors\n",
+ i,
+ zbc_zone_type(z),
+ zbc_zone_start_lba(z),
+ zbc_zone_length(z));
+
+ }
+
+ if ( ro == ZBC_RO_ALL ) {
+ /* Check */
+ if ( nr_lba != info.zbd_logical_blocks ) {
+ printf("[WARNING] %llu logical blocks reported "
+ "but capacity is %llu logical blocks\n",
+ nr_lba,
+ (unsigned long long)info.zbd_logical_blocks);
+ }
}
out:
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/libzbc-4.3.0/tools/write_zone/zbc_write_zone.c
new/libzbc-4.3.3/tools/write_zone/zbc_write_zone.c
--- old/libzbc-4.3.0/tools/write_zone/zbc_write_zone.c 2016-08-18
04:04:10.000000000 +0200
+++ new/libzbc-4.3.3/tools/write_zone/zbc_write_zone.c 2016-11-15
07:55:55.000000000 +0100
@@ -268,11 +268,10 @@
zbc_zone_wp_lba(iozone));
/* Check I/O size alignment */
- if ( zbc_zone_sequential_req(iozone) ) {
+ if ( zbc_zone_sequential_req(iozone) )
ioalign = info.zbd_physical_block_size;
- } else {
+ else
ioalign = info.zbd_logical_block_size;
- }
if ( iosize % ioalign ) {
fprintf(stderr,
"Invalid I/O size %zu (must be aligned on %zu)\n",
@@ -283,7 +282,7 @@
}
/* Get an I/O buffer */
- ret = posix_memalign((void **) &iobuf, ioalign, iosize);
+ ret = posix_memalign((void **) &iobuf, sysconf(_SC_PAGESIZE), iosize);
if ( ret != 0 ) {
fprintf(stderr,
"No memory for I/O buffer (%zu B)\n",
