Index: Common/DtaOpenBSD.cpp
--- Common/DtaOpenBSD.cpp.orig
+++ Common/DtaOpenBSD.cpp
@@ -0,0 +1,505 @@
+/*
+ * OpenBSD storage passthrough backend for sedutil-cli.
+ *
+ * This file is part of sedutil and is distributed under the GNU General
+ * Public License, version 3 or (at your option) any later version.
+ */
+
+#include <sys/types.h>
+#include <sys/ataio.h>
+#include <sys/disklabel.h>
+#include <sys/dkio.h>
+#include <sys/ioctl.h>
+#include <sys/scsiio.h>
+#include <sys/stat.h>
+
+#include <dev/biovar.h>
+#include <dev/ic/nvmeio.h>
+
+#include <algorithm>
+#include <dirent.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <stddef.h>
+#include <string>
+
+#include "DtaAtaDrive.h"
+#include "DtaBlockStorageDevice.h"
+#include "DtaNvmeDrive.h"
+#include "DtaOpenBSD.h"
+#include "DtaSataDrive.h"
+#include "DtaScsiDrive.h"
+#include "NVMeStructures.h"
+#include "log.h"
+
+const std::string DtaOS::name = "OpenBSD";
+
+DtaOS *
+DtaOS::getDtaOS()
+{
+	return new DtaOpenBSD();
+}
+
+static bool
+rawWholeDiskName(const char *name)
+{
+	const char *p;
+
+	if (strncmp(name, "rsd", 3) != 0 && strncmp(name, "rwd", 3) != 0)
+		return false;
+	p = name + 3;
+	if (*p < '0' || *p > '9')
+		return false;
+	while (*p >= '0' && *p <= '9')
+		p++;
+	return p[0] == 'c' && p[1] == '\0';
+}
+
+static bool
+isWdDevice(const char *devref)
+{
+	const char *name = strrchr(devref, '/');
+	name = name == NULL ? devref : name + 1;
+	return strncmp(name, "rwd", 3) == 0;
+}
+
+static bool
+scsiInquiry(int fd, bool evpd, unsigned char page, unsigned char *data,
+    size_t dataLen, size_t &dataUsed)
+{
+	struct scsireq req;
+
+	dataUsed = 0;
+	if (dataLen == 0 || dataLen > 255)
+		return false;
+	memset(&req, 0, sizeof(req));
+	memset(data, 0, dataLen);
+	req.flags = SCCMD_READ;
+	req.timeout = 1000;
+	req.cmd[0] = 0x12;	/* INQUIRY */
+	req.cmd[1] = evpd ? 1 : 0;
+	req.cmd[2] = page;
+	req.cmd[4] = static_cast<unsigned char>(dataLen);
+	req.cmdlen = 6;
+	req.databuf = reinterpret_cast<caddr_t>(data);
+	req.datalen = dataLen;
+	req.senselen = SENSEBUFLEN;
+	if (ioctl(fd, SCIOCCOMMAND, &req) == -1 || req.retsts != SCCMD_OK)
+		return false;
+	dataUsed = std::min<size_t>(dataLen, req.datalen_used);
+	return true;
+}
+
+static bool
+probeSCSI(int fd, bool &isATA, bool &isSAS)
+{
+	unsigned char inquiry[96], pages[255];
+	size_t used, pageLen;
+
+	isATA = false;
+	isSAS = false;
+	if (!scsiInquiry(fd, false, 0, inquiry, sizeof(inquiry), used) ||
+	    used < 36)
+		return false;
+	isATA = memcmp(inquiry + 8, "ATA     ", 8) == 0;
+	if (!scsiInquiry(fd, true, 0, pages, sizeof(pages), used) || used < 4)
+		return true;
+	pageLen = (static_cast<size_t>(pages[2]) << 8) | pages[3];
+	pageLen = std::min(pageLen, used - 4);
+	for (size_t i = 0; i < pageLen; i++) {
+		if (pages[4 + i] == 0x89)
+			isATA = true;	/* ATA information VPD page */
+		if (pages[4 + i] == 0x90 || pages[4 + i] == 0x91)
+			isSAS = true;	/* protocol-specific SAS pages */
+	}
+	return true;
+}
+
+static bool
+populateSCSIIdentity(int fd, DTA_DEVICE_INFO &info)
+{
+	static const char hex[] = "0123456789abcdef";
+	unsigned char vpd[255];
+	std::string serial;
+	size_t used, pageLen, end, offset;
+
+	/*
+	 * Linux sedutil salts passwords with udev's ID_SERIAL_SHORT.  For a
+	 * SCSI disk, scsi_id normally derives that value from the logical-unit
+	 * NAA descriptor in VPD page 0x83.  Reproduce that value so passwords
+	 * provisioned on Linux continue to authenticate on OpenBSD.
+	 */
+	if (scsiInquiry(fd, true, 0x83, vpd, sizeof(vpd), used) && used >= 4) {
+		pageLen = (static_cast<size_t>(vpd[2]) << 8) | vpd[3];
+		end = std::min(used, pageLen + 4);
+		for (offset = 4; offset + 4 <= end; ) {
+			size_t identifierLen = vpd[offset + 3];
+			size_t next = offset + 4 + identifierLen;
+			unsigned int codeSet = vpd[offset] & 0x0f;
+			unsigned int association = (vpd[offset + 1] >> 4) & 0x03;
+			unsigned int identifierType = vpd[offset + 1] & 0x0f;
+
+			if (next > end)
+				break;
+			if (codeSet == 1 && association == 0 &&
+			    identifierType == 3 && identifierLen != 0) {
+				serial.reserve(identifierLen * 2);
+				for (size_t i = offset + 4; i < next; i++) {
+					serial.push_back(hex[vpd[i] >> 4]);
+					serial.push_back(hex[vpd[i] & 0x0f]);
+				}
+				break;
+			}
+			offset = next;
+		}
+	}
+
+	/* Fall back to the trimmed unit serial from VPD page 0x80. */
+	if (serial.empty() &&
+	    scsiInquiry(fd, true, 0x80, vpd, sizeof(vpd), used) && used >= 4) {
+		pageLen = (static_cast<size_t>(vpd[2]) << 8) | vpd[3];
+		end = std::min(used, pageLen + 4);
+		offset = 4;
+		while (offset < end && (vpd[offset] == ' ' || vpd[offset] == '\0'))
+			offset++;
+		while (end > offset && (vpd[end - 1] == ' ' || vpd[end - 1] == '\0'))
+			end--;
+		serial.assign(reinterpret_cast<const char *>(vpd + offset),
+		    end - offset);
+	}
+	if (serial.empty())
+		return false;
+
+	memset(info.serialNum, 0, sizeof(info.serialNum));
+	memcpy(info.serialNum, serial.data(),
+	    std::min(serial.size(), sizeof(info.serialNum)));
+	memset(info.passwordSalt, 0, sizeof(info.passwordSalt));
+	memcpy(info.passwordSalt, serial.data(),
+	    std::min(serial.size(), sizeof(info.passwordSalt)));
+	return true;
+}
+
+OSDEVICEHANDLE
+DtaOpenBSD::openDeviceHandle(const char *devref, bool &accessDenied)
+{
+	int fd;
+
+	accessDenied = false;
+	fd = open(devref, O_RDWR | O_CLOEXEC);
+	if (fd == -1) {
+		if (errno == EACCES || errno == EPERM || errno == EROFS)
+			accessDenied = true;
+		else if (errno != ENOENT) {
+			LOG(E) << "Failed opening " << devref << ": "
+			    << strerror(errno);
+		}
+		return INVALID_HANDLE_VALUE;
+	}
+	return handle(fd);
+}
+
+void
+DtaOpenBSD::closeDeviceHandle(OSDEVICEHANDLE h)
+{
+	if (h != INVALID_HANDLE_VALUE)
+		(void)close(handleDescriptor(h));
+}
+
+std::vector<std::string>
+DtaOpenBSD::generateDtaDriveDevRefs()
+{
+	std::vector<std::string> devrefs;
+	DIR *dir;
+	struct dirent *entry;
+
+	dir = opendir("/dev");
+	if (dir == NULL) {
+		LOG(E) << "Cannot open /dev: " << strerror(errno);
+		return devrefs;
+	}
+	while ((entry = readdir(dir)) != NULL) {
+		struct stat st;
+		std::string path;
+
+		if (!rawWholeDiskName(entry->d_name))
+			continue;
+		path = std::string("/dev/") + entry->d_name;
+		if (stat(path.c_str(), &st) == 0 && S_ISCHR(st.st_mode))
+			devrefs.push_back(path);
+	}
+	closedir(dir);
+	std::sort(devrefs.begin(), devrefs.end());
+	return devrefs;
+}
+
+void
+DtaOpenBSD::errorNoAccess(const char *devref)
+{
+	if (devref == NULL)
+		LOG(E) << "Permission denied opening raw disks; run as root";
+	else
+		LOG(E) << "Permission denied opening " << devref
+		    << "; run as root";
+}
+
+static bool
+probeNVMe(int fd, unsigned char data[4096])
+{
+	struct nvme_pt_cmd pt;
+
+	memset(&pt, 0, sizeof(pt));
+	memset(data, 0, 4096);
+	pt.pt_opcode = NVME_IDENTIFY;
+	pt.pt_cdw10 = NVME_IDENTIFY_CNS_CTRL;
+	pt.pt_databuf = reinterpret_cast<caddr_t>(data);
+	pt.pt_databuflen = 4096;
+	return ioctl(fd, NVME_PASSTHROUGH_CMD, &pt) == 0;
+}
+
+DtaOS::dictionary *
+DtaOpenBSD::getOSSpecificInformation(OSDEVICEHANDLE h, const char *devref,
+    InterfaceDeviceID &interfaceID, DTA_DEVICE_INFO &info)
+{
+	dictionary *properties = new dictionary;
+	struct disklabel label;
+	unsigned char identify[4096];
+	bool isATA, isSAS;
+	int fd = handleDescriptor(h);
+
+	memset(&label, 0, sizeof(label));
+	if (ioctl(fd, DIOCGDINFO, &label) == 0)
+		info.devSize = static_cast<uint64_t>(label.d_secperunit) *
+		    label.d_secsize;
+
+	if (probeNVMe(fd, identify)) {
+		info.devType = DEVICE_TYPE_NVME;
+		safecopy(info.serialNum, sizeof(info.serialNum), identify + 4, 20);
+		safecopy(info.modelNum, sizeof(info.modelNum), identify + 24, 40);
+		safecopy(info.firmwareRev, sizeof(info.firmwareRev), identify + 64, 8);
+		memcpy(interfaceID, identify, sizeof(interfaceID));
+		memcpy(info.passwordSalt, info.serialNum,
+		    sizeof(info.passwordSalt));
+		(*properties)["Transport"] = "NVMe";
+	} else if (isWdDevice(devref)) {
+		info.devType = DEVICE_TYPE_ATA;
+		(*properties)["Transport"] = "ATA";
+	} else if (probeSCSI(fd, isATA, isSAS)) {
+		if (isATA) {
+			info.devType = DEVICE_TYPE_ATA;
+			(*properties)["Transport"] = "ATA/SAT";
+		} else if (isSAS) {
+			(void)populateSCSIIdentity(fd, info);
+			info.devType = DEVICE_TYPE_SAS;
+			(*properties)["Transport"] = "SAS";
+		} else {
+			(void)populateSCSIIdentity(fd, info);
+			info.devType = DEVICE_TYPE_SCSI;
+			(*properties)["Transport"] = "SCSI";
+		}
+	} else {
+		/*
+		 * Preserve the upstream SAT-then-SCSI fallback for devices which
+		 * do not answer a standard SCSI INQUIRY (usually USB bridges).
+		 */
+		info.devType = DEVICE_TYPE_USB;
+		(*properties)["Transport"] = "USB/SAT";
+	}
+	(*properties)["Device"] = devref;
+	return properties;
+}
+
+void *
+DtaOpenBSD::alloc_aligned_MIN_BUFFER_LENGTH_buffer()
+{
+	void *buffer = NULL;
+	size_t length = (MIN_BUFFER_LENGTH + IO_BUFFER_ALIGNMENT - 1) /
+	    IO_BUFFER_ALIGNMENT * IO_BUFFER_ALIGNMENT;
+
+	if (posix_memalign(&buffer, IO_BUFFER_ALIGNMENT, length) != 0)
+		return NULL;
+	return buffer;
+}
+
+void
+DtaOpenBSD::free_aligned_MIN_BUFFER_LENGTH_buffer(void *buffer)
+{
+	free(buffer);
+}
+
+int
+DtaOpenBSD::PerformATACommand_via_HD(OSDEVICEHANDLE h, ATACOMMAND cmd,
+    uint8_t securityProtocol, uint16_t comID, void *buffer,
+    unsigned int &bufferlen)
+{
+	struct atareq req;
+
+	if (h == INVALID_HANDLE_VALUE)
+		return EBADF;
+	memset(&req, 0, sizeof(req));
+	req.command = static_cast<u_char>(cmd);
+	req.databuf = reinterpret_cast<caddr_t>(buffer);
+	req.datalen = bufferlen;
+	req.timeout = cmd == IDENTIFY_DEVICE ? 1000 : 60000;
+
+	switch (cmd) {
+	case IDENTIFY_DEVICE:
+		req.flags = ATACMD_READ;
+		break;
+	case TRUSTED_RECEIVE:
+		req.flags = ATACMD_READ;
+		req.features = securityProtocol;
+		req.sec_count = static_cast<u_char>(bufferlen / 512);
+		req.cylinder = comID;
+		break;
+	case TRUSTED_SEND:
+		req.flags = ATACMD_WRITE;
+		req.features = securityProtocol;
+		req.sec_count = static_cast<u_char>(bufferlen / 512);
+		req.cylinder = comID;
+		break;
+	default:
+		return EINVAL;
+	}
+
+	if (ioctl(handleDescriptor(h), ATAIOCCOMMAND, &req) == -1)
+		return errno;
+	if (req.retsts != ATACMD_OK) {
+		LOG(D4) << "ATA command failed: retsts="
+		    << static_cast<unsigned int>(req.retsts) << " error="
+		    << static_cast<unsigned int>(req.error);
+		return EIO;
+	}
+	if (cmd == IDENTIFY_DEVICE &&
+	    std::all_of(static_cast<unsigned char *>(buffer),
+	    static_cast<unsigned char *>(buffer) + bufferlen,
+	    [](unsigned char byte) { return byte == 0; }))
+		return EIO;
+	bufferlen = req.datalen;
+	return 0;
+}
+
+int
+DtaOpenBSD::PerformSCSICommand(OSDEVICEHANDLE h, int direction,
+    uint8_t *cdb, unsigned char cdbLen, void *buffer,
+    unsigned int &bufferlen, unsigned char *sense,
+    unsigned char &senseLen, SCSI_STATUS_CODE *maskedStatus,
+    unsigned int timeout)
+{
+	struct scsireq req;
+	size_t copiedSense;
+
+	if (h == INVALID_HANDLE_VALUE)
+		return -EBADF;
+	if (cdb == NULL || cdbLen > CMDBUFLEN)
+		return -EINVAL;
+
+	memset(&req, 0, sizeof(req));
+	req.flags = direction == PSC_FROM_DEV ? SCCMD_READ : SCCMD_WRITE;
+	req.timeout = timeout;
+	memcpy(req.cmd, cdb, cdbLen);
+	req.cmdlen = cdbLen;
+	req.databuf = reinterpret_cast<caddr_t>(buffer);
+	req.datalen = bufferlen;
+	req.senselen = static_cast<u_char>(std::min<size_t>(senseLen,
+	    SENSEBUFLEN));
+
+	if (ioctl(handleDescriptor(h), SCIOCCOMMAND, &req) == -1)
+		return -errno;
+
+	bufferlen = req.datalen_used;
+	copiedSense = std::min<size_t>(senseLen, req.senselen_used);
+	if (sense != NULL && copiedSense != 0)
+		memcpy(sense, req.sense, copiedSense);
+	senseLen = static_cast<unsigned char>(copiedSense);
+	if (maskedStatus != NULL)
+		*maskedStatus = static_cast<SCSI_STATUS_CODE>(req.status >> 1);
+
+	if (req.retsts == SCCMD_OK || req.retsts == SCCMD_SENSE)
+		return 0;
+	if (req.retsts == SCCMD_TIMEOUT)
+		return -ETIMEDOUT;
+	return -EIO;
+}
+
+int
+DtaOpenBSD::PerformNVMeCommand(OSDEVICEHANDLE h, uint8_t *pcmd,
+    uint32_t *status)
+{
+	struct nvme_admin_cmd *cmd;
+	struct nvme_pt_status ptStatus;
+	struct nvme_pt_cmd pt;
+
+	if (h == INVALID_HANDLE_VALUE) {
+		errno = EBADF;
+		return -1;
+	}
+	if (pcmd == NULL) {
+		errno = EINVAL;
+		return -1;
+	}
+	cmd = reinterpret_cast<struct nvme_admin_cmd *>(pcmd);
+
+	memset(&pt, 0, sizeof(pt));
+	memset(&ptStatus, 0, sizeof(ptStatus));
+	pt.pt_opcode = cmd->opcode;
+	pt.pt_nsid = cmd->nsid;
+	pt.pt_cdw10 = cmd->cdw10;
+	pt.pt_cdw11 = cmd->cdw11;
+	pt.pt_cdw12 = cmd->cdw12;
+	pt.pt_cdw13 = cmd->cdw13;
+	pt.pt_cdw14 = cmd->cdw14;
+	pt.pt_cdw15 = cmd->cdw15;
+	pt.pt_databuf = reinterpret_cast<caddr_t>(
+	    static_cast<uintptr_t>(cmd->addr));
+	pt.pt_databuflen = cmd->data_len;
+	pt.pt_status = reinterpret_cast<caddr_t>(&ptStatus);
+	pt.pt_statuslen = sizeof(ptStatus);
+
+	if (ioctl(handleDescriptor(h), NVME_PASSTHROUGH_CMD, &pt) == -1)
+		return -1;
+	if (status != NULL)
+		*status = static_cast<uint32_t>(ptStatus.ps_flags);
+	return 0;
+}
+
+DtaDrive *
+DtaDrive::getDtaDrive(Protocol protocol, const char *devref,
+    DTA_DEVICE_INFO &deviceInfo)
+{
+	switch (protocol) {
+	case AtaDrive:
+		return DtaAtaDrive::getDtaAtaDrive(devref, deviceInfo);
+	case NvmeDrive:
+		return DtaNvmeDrive::getDtaNvmeDrive(devref, deviceInfo);
+	case ScsiDrive:
+		return DtaScsiDrive::getDtaScsiDrive(devref, deviceInfo);
+	case SataDrive:
+		return DtaSataDrive::getDtaSataDrive(devref, deviceInfo);
+	default:
+		return NULL;
+	}
+}
+
+DtaAtaDrive *
+DtaAtaDrive::getDtaOSSpecificAtaDrive(OSDEVICEHANDLE h, bool translated)
+{
+	return new DtaAtaDrive(h, translated);
+}
+
+DtaNvmeDrive *
+DtaNvmeDrive::getDtaOSSpecificNvmeDrive(OSDEVICEHANDLE h)
+{
+	return new DtaNvmeDrive(h);
+}
+
+DtaScsiDrive *
+DtaScsiDrive::getDtaOSSpecificScsiDrive(OSDEVICEHANDLE h)
+{
+	return new DtaScsiDrive(h);
+}
+
+DtaSataDrive *
+DtaSataDrive::getDtaOSSpecificSataDrive(OSDEVICEHANDLE h)
+{
+	return new DtaSataDrive(h);
+}
