githubmirror/nvme-cli

src/common.h
133 строки3 KB
Daniel Wagner
nvme: move source code to src folder
07 авг 2026, 17:49
07 авг 2026, 17:4908f3fa8
/* SPDX-License-Identifier: GPL-2.0-or-later */
#pragma once

#include <fcntl.h>
#include <string.h>
#include <stdbool.h>

#if defined(_WIN32)
#include <direct.h>
#include <io.h>
#include <sysinfoapi.h>
#endif

#include "ccan/endian/endian.h"

#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))

#define min(x, y) ((x) > (y) ? (y) : (x))
#define max(x, y) ((x) > (y) ? (x) : (y))

#ifdef __packed
#else /* __packed */
#define __packed __attribute__((__packed__))
#endif /* __packed */

/*
 * Some common functionality is implemented or named differently on Windows.
 * Provide compatibility wrappers.
 */
#if defined(_WIN32)
#define DEV_NULL "NUL"
#define mkdir(path, mode) _mkdir(path)

#define fsync _commit

static inline int getpagesize(void)
{
	SYSTEM_INFO si;

	GetSystemInfo(&si);
	return si.dwPageSize;
}
#else
#define DEV_NULL "/dev/null"
#endif

/*
 * Open file for reading or writing raw data with no line-ending translations
 * or other interpretation or decoding.
 */
#ifdef O_BINARY
#define nvme_open_rawdata(path, flags, ...) open((path), (flags) | O_BINARY, ##__VA_ARGS__)
#else
#define nvme_open_rawdata(path, flags, ...) open((path), (flags), ##__VA_ARGS__)
#endif

/*
 * VMs on arm64 can only use a subset of instructions for MMIO that provide
 * the hypervisor with a complete instruction decode. Provide assembly MMIO
 * accessors to prevent the compiler from using a possibly unsupported
 * instruction.
 *
 * See kernel commit c726200dd106 ("KVM: arm/arm64: Allow reporting non-ISV
 * data aborts to userspace") for more details.
 */
#if defined(__aarch64__)
static inline leint32_t __raw_readl(const volatile leint32_t *addr)
{
	leint32_t val;

	asm volatile("ldr %w0, %1" : "=r" (val) : "Qo" (*addr));

	return val;
}

static inline void __raw_writel(volatile leint32_t *addr, leint32_t val)
{
	asm volatile("str %w0, %1" : : "r" (val), "Qo" (*addr));
}

static inline void __raw_writeq(volatile leint64_t *addr, leint64_t val)
{
	asm volatile("str %0, %1" : : "r" (val), "Qo" (*addr));
}
#else
static inline leint32_t __raw_readl(volatile leint32_t *addr)
{
	return *addr;
}

static inline void __raw_writel(volatile leint32_t *addr, leint32_t val)
{
	*addr = val;
}

static inline void __raw_writeq(volatile leint64_t *addr, leint64_t val)
{
	*addr = val;
}
#endif

static inline uint32_t mmio_read32(void *addr)
{
	return le32_to_cpu(__raw_readl(addr));
}

/* Access 64-bit registers as 2 32-bit; Some devices fail 64-bit MMIO. */
static inline uint64_t mmio_read64(void *addr)
{
	uint32_t low, high;

	low = le32_to_cpu(__raw_readl(addr));
	high = le32_to_cpu(__raw_readl(addr + sizeof(leint32_t)));

	return ((uint64_t)high << 32) | low;
}

static inline void mmio_write32(void *addr, uint32_t value)
{
	__raw_writel(addr, cpu_to_le32(value));
}

/* Access 64-bit registers as 2 32-bit if write32 flag set; Some devices fail 64-bit MMIO. */
static inline void mmio_write64(void *addr, uint64_t value, bool write32)
{
	if (write32) {
		mmio_write32(addr, value);
		mmio_write32((uint32_t *)addr + 1, value >> 32);
		return;
	}

	__raw_writeq(addr, cpu_to_le64(value));
}