This test program is used by one of the srp tests.
Signed-off-by: Bart Van Assche <bart.vanass...@wdc.com>
---
src/.gitignore | 1 +
src/Makefile | 4 +
src/discontiguous-io.cpp | 340 +++++++++++++++++++++++++++++++++++++++
3 files changed, 345 insertions(+)
create mode 100644 src/discontiguous-io.cpp
diff --git a/src/.gitignore b/src/.gitignore
index 68da6e6fa69e..d0400392538b 100644
--- a/src/.gitignore
+++ b/src/.gitignore
@@ -1,3 +1,4 @@
+/discontiguous-io
/loblksize
/loop_get_status_null
/openclose
diff --git a/src/Makefile b/src/Makefile
index d7ae832fc4fd..57e7126eb2a4 100644
--- a/src/Makefile
+++ b/src/Makefile
@@ -1,4 +1,5 @@
TARGETS := \
+ discontiguous-io \
loblksize \
loop_get_status_null \
openclose \
@@ -16,4 +17,7 @@ clean:
%: %.c
$(CC) -Wall -o $@ $(CPPFLAGS) $(CFLAGS) $^
+%: %.cpp
+ $(CXX) -Wall -Wextra -Wno-sign-compare -Werror -o $@ $(CPPFLAGS)
$(CFLAGS) $^
+
.PHONY: all clean
diff --git a/src/discontiguous-io.cpp b/src/discontiguous-io.cpp
new file mode 100644
index 000000000000..3761cc605576
--- /dev/null
+++ b/src/discontiguous-io.cpp
@@ -0,0 +1,340 @@
+// Copyright (c) 2015 SanDisk Corporation
+// Copyright (c) 2016-2018 Western Digital Corporation or its affiliates
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License
+// as published by the Free Software Foundation; either version 2
+// of the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc.
+
+#include <cassert>
+#include <cstring> // memset()
+#include <fcntl.h> // O_RDONLY
+#include <iomanip>
+#include <iostream>
+#include <linux/fs.h> // BLKSSZGET
+#include <scsi/sg.h> // sg_io_hdr_t
+#include <sys/ioctl.h>
+#include <unistd.h> // open()
+#include <vector>
+
+class file_descriptor {
+public:
+ file_descriptor(int fd = -1)
+ : m_fd(fd)
+ { }
+ ~file_descriptor()
+ { if (m_fd >= 0) close(m_fd); }
+ operator int() const
+ { return m_fd; }
+
+private:
+ file_descriptor(const file_descriptor &);
+ file_descriptor &operator=(const file_descriptor &);
+
+ int m_fd;
+};
+
+class iovec_t {
+public:
+ iovec_t()
+ { }
+ ~iovec_t()
+ { }
+ size_t size() const
+ { return m_v.size(); }
+ const sg_iovec_t& operator[](const int i) const
+ { return m_v[i]; }
+ sg_iovec_t& operator[](const int i)
+ { return m_v[i]; }
+ void append(void *addr, size_t len) {
+ m_v.resize(m_v.size() + 1);
+ auto p = m_v.end() - 1;
+ p->iov_base = addr;
+ p->iov_len = len;
+ }
+ const void *address() const {
+ return &*m_v.begin();
+ }
+ size_t data_len() const {
+ size_t len = 0;
+ for (auto p = m_v.begin(); p != m_v.end(); ++p)
+ len += p->iov_len;
+ return len;
+ }
+ void trunc(size_t len) {
+ size_t s = 0;
+ for (auto p = m_v.begin(); p != m_v.end(); ++p) {
+ s += p->iov_len;
+ if (s >= len) {
+ p->iov_len -= s - len;
+ assert(p->iov_len > 0 ||
+ (p->iov_len == 0 && len == 0));
+ m_v.resize(p - m_v.begin() + 1);
+ break;
+ }
+ }
+ }
+ std::ostream& write(std::ostream& os) const {
+ for (auto p = m_v.begin(); p != m_v.end(); ++p)
+ os.write((const char *)p->iov_base, p->iov_len);
+ return os;
+ }
+
+private:
+ iovec_t(const iovec_t &);
+ iovec_t &operator=(const iovec_t &);
+
+ std::vector<sg_iovec_t> m_v;
+};
+
+static unsigned block_size;
+
+static void dumphex(std::ostream &os, const void *a, size_t len)
+{
+ for (int i = 0; i < len; i += 16) {
+ os << std::hex << std::setfill('0') << std::setw(16)
+ << (uintptr_t)a + i << ':';
+ for (int j = i; j < i + 16 && j < len; j++) {
+ if (j % 4 == 0)
+ os << ' ';
+ os << std::hex << std::setfill('0') << std::setw(2)
+ << (unsigned)((uint8_t*)a)[j];
+ }
+ os << " ";
+ for (int j = i; j < i + 16 && j < len; j++) {
+ unsigned char c = ((uint8_t*)a)[j];
+ os << (c >= ' ' && c < 128 ? (char)c : '.');
+ }
+ os << '\n';
+ }
+}
+
+enum {
+ MAX_READ_WRITE_6_LBA = 0x1fffff,
+ MAX_READ_WRITE_6_LENGTH = 0xff,
+};
+
+static ssize_t sg_read(const file_descriptor &fd, uint32_t lba,
+ const iovec_t &v)
+{
+ if (lba > MAX_READ_WRITE_6_LBA)
+ return -1;
+
+ if (v.data_len() == 0 || (v.data_len() % block_size) != 0)
+ return -1;
+
+ if (v.data_len() / block_size > MAX_READ_WRITE_6_LENGTH)
+ return -1;
+
+ int sg_version;
+ if (ioctl(fd, SG_GET_VERSION_NUM, &sg_version) < 0 ||
+ sg_version < 30000)
+ return -1;
+
+ uint8_t read6[6] = {
+ 0x08, (uint8_t)(lba >> 16), (uint8_t)(lba >> 8),
+ (uint8_t)(lba), (uint8_t)(v.data_len() / block_size),
+ 0
+ };
+ unsigned char sense_buffer[32];
+ sg_io_hdr_t h;
+
+ memset(&h, 0, sizeof(h));
+ h.interface_id = 'S';
+ h.cmdp = read6;
+ h.cmd_len = sizeof(read6);
+ h.dxfer_direction = SG_DXFER_FROM_DEV;
+ h.iovec_count = v.size();
+ h.dxfer_len = v.data_len();
+ h.dxferp = const_cast<void*>(v.address());
+ h.sbp = sense_buffer;
+ h.mx_sb_len = sizeof(sense_buffer);
+ h.timeout = 1000; /* 1000 millisecs == 1 second */
+ if (ioctl(fd, SG_IO, &h) < 0) {
+ std::cerr << "READ(6) ioctl failed with errno " << errno
+ << '\n';
+ return -1;
+ }
+ uint32_t result = h.status | (h.msg_status << 8) |
+ (h.host_status << 16) | (h.driver_status << 24);
+ if (result) {
+ std::cerr << "READ(6) failed with status 0x" << std::hex
+ << result << "\n";
+ if (h.status == 2) {
+ std::cerr << "Sense buffer:\n";
+ dumphex(std::cerr, sense_buffer, h.sb_len_wr);
+ }
+ return -1;
+ }
+ return v.data_len() - h.resid;
+}
+
+static ssize_t sg_write(const file_descriptor &fd, uint32_t lba,
+ const iovec_t &v)
+{
+ if (lba > MAX_READ_WRITE_6_LBA)
+ return -1;
+
+ if (v.data_len() == 0) {
+ std::cerr << "Write buffer is empty.\n";
+ return -1;
+ }
+
+ if ((v.data_len() % block_size) != 0) {
+ std::cerr << "Write buffer size " << v.data_len()
+ << " is not a multiple of the block size "
+ << block_size << ".\n";
+ return -1;
+ }
+
+ if (v.data_len() / block_size > MAX_READ_WRITE_6_LENGTH) {
+ std::cerr << "Write buffer size " << v.data_len()
+ << " > " << MAX_READ_WRITE_6_LENGTH << ".\n";
+ return -1;
+ }
+
+ int sg_version;
+ if (ioctl(fd, SG_GET_VERSION_NUM, &sg_version) < 0) {
+ std::cerr << "SG_GET_VERSION_NUM ioctl failed with errno "
+ << errno << '\n';
+ return -1;
+ }
+
+ if (sg_version < 30000) {
+ std::cerr << "Error: sg version 3 is not supported\n";
+ return -1;
+ }
+
+ uint8_t write6[6] = {
+ 0x0a, (uint8_t)(lba >> 16), (uint8_t)(lba >> 8),
+ (uint8_t)(lba), (uint8_t)(v.data_len() / block_size),
+ 0
+ };
+ unsigned char sense_buffer[32];
+ sg_io_hdr_t h;
+
+ memset(&h, 0, sizeof(h));
+ h.interface_id = 'S';
+ h.cmdp = write6;
+ h.cmd_len = sizeof(write6);
+ h.dxfer_direction = SG_DXFER_TO_DEV;
+ h.iovec_count = v.size();
+ h.dxfer_len = v.data_len();
+ h.dxferp = const_cast<void*>(v.address());
+ h.sbp = sense_buffer;
+ h.mx_sb_len = sizeof(sense_buffer);
+ h.timeout = 1000; /* 1000 millisecs == 1 second */
+ if (ioctl(fd, SG_IO, &h) < 0) {
+ std::cerr << "WRITE(6) ioctl failed with errno " << errno
+ << '\n';
+ return -1;
+ }
+ uint32_t result = h.status | (h.msg_status << 8) |
+ (h.host_status << 16) | (h.driver_status << 24);
+ if (result) {
+ std::cerr << "WRITE(6) failed with status 0x" << std::hex
+ << result << "\n";
+ if (h.status == 2) {
+ std::cerr << "Sense buffer:\n";
+ dumphex(std::cerr, sense_buffer, h.sb_len_wr);
+ }
+ return -1;
+ }
+ return v.data_len() - h.resid;
+}
+
+static void usage()
+{
+ std::cout << "Usage: [-h] [-l <length_in_bytes>] [-o <lba_in_bytes>]
[-s] [-w] <dev>\n";
+}
+
+int main(int argc, char **argv)
+{
+ bool scattered = false, write = false;
+ uint32_t offs = 0;
+ const char *dev;
+ int c;
+ std::vector<uint8_t> buf;
+ size_t len = 512;
+
+ while ((c = getopt(argc, argv, "hl:o:sw")) != EOF) {
+ switch (c) {
+ case 'l': len = strtoul(optarg, NULL, 0); break;
+ case 'o': offs = strtoul(optarg, NULL, 0); break;
+ case 's': scattered = true; break;
+ case 'w': write = true; break;
+ default: usage(); goto out;
+ }
+ }
+
+ if (argc - optind < 1) {
+ std::cerr << "Too few arguments.\n";
+ goto out;
+ }
+
+ dev = argv[optind];
+ buf.resize(len);
+ {
+ file_descriptor fd(open(dev, O_RDONLY));
+ if (fd < 0) {
+ std::cerr << "Failed to open " << dev << "\n";
+ goto out;
+ }
+ if (ioctl(fd, BLKSSZGET, &block_size) < 0) {
+ std::cerr << "Failed to query block size of " << dev
+ << "\n";
+ goto out;
+ }
+ if (offs % block_size) {
+ std::cerr << "LBA is not a multiple of the block
size.\n";
+ goto out;
+ }
+ iovec_t iov;
+ if (scattered) {
+ buf.resize(buf.size() * 2);
+ unsigned char *p = &*buf.begin();
+ for (int i = 0; i < len / 4; i++)
+ iov.append(p + 4 + i * 8,
+ std::min(4ul, len - i * 4));
+ } else {
+ iov.append(&*buf.begin(), buf.size());
+ }
+ if (write) {
+ for (int i = 0; i < iov.size(); i++) {
+ sg_iovec_t& e = iov[i];
+ size_t prevgcount = std::cin.gcount();
+ if (!std::cin.read((char *)e.iov_base,
+ e.iov_len)) {
+ e.iov_len = std::cin.gcount() -
+ prevgcount;
+ break;
+ }
+ }
+ ssize_t len = sg_write(fd, offs / block_size, iov);
+ if (len >= 0)
+ std::cout << "Wrote " << len << "/"
+ << iov.data_len()
+ << " bytes of data.\n";
+ } else {
+ ssize_t len = sg_read(fd, offs / block_size, iov);
+ if (len >= 0) {
+ std::cerr << "Read " << len
+ << " bytes of data:\n";
+ iov.trunc(len);
+ iov.write(std::cout);
+ }
+ }
+ }
+
+ out:
+ return 0;
+}
--
2.17.1
