Gh0st
/
linux
mirror of https://github.com/torvalds/linux.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

virtio: clean up features qword/dword terms 

virtio pci uses word to mean "16 bits". mmio uses it to mean
"32 bits".

To avoid confusion, let's avoid the term in core virtio
altogether. Just say U64 to mean "64 bit".

Fixes: e7d4c1c5a5 ("virtio: introduce extended features")
Cc: Paolo Abeni <pabeni@redhat.com>
Acked-by: Jason Wang <jasowang@redhat.com>
Message-ID: <ad53b7b6be87fc524f45abaeca0bb05fb3633397.1764225384.git.mst@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
This commit is contained in:
Michael S. Tsirkin 2025-10-21 10:56:57 -04:00
parent 2828c60b24
commit 9513f25056
8 changed files with 41 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
drivers/vhost/net.c
View File

@ -69,7 +69,7 @@ MODULE_PARM_DESC(experimental_zcopytx, "Enable Zero Copy TX;"
#define VHOST_DMA_IS_DONE(len) ((__force u32)(len) >= (__force u32)VHOST_DMA_DONE_LEN) #define VHOST_DMA_IS_DONE(len) ((__force u32)(len) >= (__force u32)VHOST_DMA_DONE_LEN)
static const u64 vhost_net_features[VIRTIO_FEATURES_DWORDS] = { static const u64 vhost_net_features[VIRTIO_FEATURES_U64S] = {
VHOST_FEATURES | VHOST_FEATURES |
(1ULL << VHOST_NET_F_VIRTIO_NET_HDR) | (1ULL << VHOST_NET_F_VIRTIO_NET_HDR) |
(1ULL << VIRTIO_NET_F_MRG_RXBUF) | (1ULL << VIRTIO_NET_F_MRG_RXBUF) |
@ -1720,7 +1720,7 @@ static long vhost_net_set_owner(struct vhost_net *n)
static long vhost_net_ioctl(struct file *f, unsigned int ioctl, static long vhost_net_ioctl(struct file *f, unsigned int ioctl,
unsigned long arg) unsigned long arg)
{ {
u64 all_features[VIRTIO_FEATURES_DWORDS]; u64 all_features[VIRTIO_FEATURES_U64S];
struct vhost_net *n = f->private_data; struct vhost_net *n = f->private_data;
void __user *argp = (void __user *)arg; void __user *argp = (void __user *)arg;
u64 __user *featurep = argp; u64 __user *featurep = argp;
@ -1752,7 +1752,7 @@ static long vhost_net_ioctl(struct file *f, unsigned int ioctl,
/* Copy the net features, up to the user-provided buffer size */ /* Copy the net features, up to the user-provided buffer size */
argp += sizeof(u64); argp += sizeof(u64);
copied = min(count, VIRTIO_FEATURES_DWORDS); copied = min(count, (u64)VIRTIO_FEATURES_U64S);
if (copy_to_user(argp, vhost_net_features, if (copy_to_user(argp, vhost_net_features,
copied * sizeof(u64))) copied * sizeof(u64)))
return -EFAULT; return -EFAULT;
@ -1767,13 +1767,13 @@ static long vhost_net_ioctl(struct file *f, unsigned int ioctl,
virtio_features_zero(all_features); virtio_features_zero(all_features);
argp += sizeof(u64); argp += sizeof(u64);
copied = min(count, VIRTIO_FEATURES_DWORDS); copied = min(count, (u64)VIRTIO_FEATURES_U64S);
if (copy_from_user(all_features, argp, copied * sizeof(u64))) if (copy_from_user(all_features, argp, copied * sizeof(u64)))
return -EFAULT; return -EFAULT;
/* /*
* Any feature specified by user-space above * Any feature specified by user-space above
* VIRTIO_FEATURES_MAX is not supported by definition. * VIRTIO_FEATURES_BITS is not supported by definition.
*/ */
for (i = copied; i < count; ++i) { for (i = copied; i < count; ++i) {
if (copy_from_user(&features, featurep + 1 + i, if (copy_from_user(&features, featurep + 1 + i,
@ -1783,7 +1783,7 @@ static long vhost_net_ioctl(struct file *f, unsigned int ioctl,
return -EOPNOTSUPP; return -EOPNOTSUPP;
} }
for (i = 0; i < VIRTIO_FEATURES_DWORDS; i++) for (i = 0; i < VIRTIO_FEATURES_U64S; i++)
if (all_features[i] & ~vhost_net_features[i]) if (all_features[i] & ~vhost_net_features[i])
return -EOPNOTSUPP; return -EOPNOTSUPP;

12
drivers/virtio/virtio.c
View File

@ -53,7 +53,7 @@ static ssize_t features_show(struct device *_d,
/* We actually represent this as a bitstring, as it could be /* We actually represent this as a bitstring, as it could be
* arbitrary length in future. */ * arbitrary length in future. */
for (i = 0; i < VIRTIO_FEATURES_MAX; i++) for (i = 0; i < VIRTIO_FEATURES_BITS; i++)
len += sysfs_emit_at(buf, len, "%c", len += sysfs_emit_at(buf, len, "%c",
__virtio_test_bit(dev, i) ? '1' : '0'); __virtio_test_bit(dev, i) ? '1' : '0');
len += sysfs_emit_at(buf, len, "\n"); len += sysfs_emit_at(buf, len, "\n");
@ -272,8 +272,8 @@ static int virtio_dev_probe(struct device *_d)
int err, i; int err, i;
struct virtio_device *dev = dev_to_virtio(_d); struct virtio_device *dev = dev_to_virtio(_d);
struct virtio_driver *drv = drv_to_virtio(dev->dev.driver); struct virtio_driver *drv = drv_to_virtio(dev->dev.driver);
u64 device_features[VIRTIO_FEATURES_DWORDS]; u64 device_features[VIRTIO_FEATURES_U64S];
u64 driver_features[VIRTIO_FEATURES_DWORDS]; u64 driver_features[VIRTIO_FEATURES_U64S];
u64 driver_features_legacy; u64 driver_features_legacy;
/* We have a driver! */ /* We have a driver! */
@ -286,7 +286,7 @@ static int virtio_dev_probe(struct device *_d)
virtio_features_zero(driver_features); virtio_features_zero(driver_features);
for (i = 0; i < drv->feature_table_size; i++) { for (i = 0; i < drv->feature_table_size; i++) {
unsigned int f = drv->feature_table[i]; unsigned int f = drv->feature_table[i];
if (!WARN_ON_ONCE(f >= VIRTIO_FEATURES_MAX)) if (!WARN_ON_ONCE(f >= VIRTIO_FEATURES_BITS))
virtio_features_set_bit(driver_features, f); virtio_features_set_bit(driver_features, f);
} }
@ -303,7 +303,7 @@ static int virtio_dev_probe(struct device *_d)
} }
if (virtio_features_test_bit(device_features, VIRTIO_F_VERSION_1)) { if (virtio_features_test_bit(device_features, VIRTIO_F_VERSION_1)) {
for (i = 0; i < VIRTIO_FEATURES_DWORDS; ++i) for (i = 0; i < VIRTIO_FEATURES_U64S; ++i)
dev->features_array[i] = driver_features[i] & dev->features_array[i] = driver_features[i] &
device_features[i]; device_features[i];
} else { } else {
@ -325,7 +325,7 @@ static int virtio_dev_probe(struct device *_d)
goto err; goto err;
if (drv->validate) { if (drv->validate) {
u64 features[VIRTIO_FEATURES_DWORDS]; u64 features[VIRTIO_FEATURES_U64S];
virtio_features_copy(features, dev->features_array); virtio_features_copy(features, dev->features_array);
err = drv->validate(dev); err = drv->validate(dev);

10
drivers/virtio/virtio_debug.c
View File

@ -8,12 +8,12 @@ static struct dentry *virtio_debugfs_dir;
static int virtio_debug_device_features_show(struct seq_file *s, void *data) static int virtio_debug_device_features_show(struct seq_file *s, void *data)
{ {
u64 device_features[VIRTIO_FEATURES_DWORDS]; u64 device_features[VIRTIO_FEATURES_U64S];
struct virtio_device *dev = s->private; struct virtio_device *dev = s->private;
unsigned int i; unsigned int i;
virtio_get_features(dev, device_features); virtio_get_features(dev, device_features);
for (i = 0; i < VIRTIO_FEATURES_MAX; i++) { for (i = 0; i < VIRTIO_FEATURES_BITS; i++) {
if (virtio_features_test_bit(device_features, i)) if (virtio_features_test_bit(device_features, i))
seq_printf(s, "%u\n", i); seq_printf(s, "%u\n", i);
} }
@ -26,7 +26,7 @@ static int virtio_debug_filter_features_show(struct seq_file *s, void *data)
struct virtio_device *dev = s->private; struct virtio_device *dev = s->private;
unsigned int i; unsigned int i;
for (i = 0; i < VIRTIO_FEATURES_MAX; i++) { for (i = 0; i < VIRTIO_FEATURES_BITS; i++) {
if (virtio_features_test_bit(dev->debugfs_filter_features, i)) if (virtio_features_test_bit(dev->debugfs_filter_features, i))
seq_printf(s, "%u\n", i); seq_printf(s, "%u\n", i);
} }
@ -50,7 +50,7 @@ static int virtio_debug_filter_feature_add(void *data, u64 val)
{ {
struct virtio_device *dev = data; struct virtio_device *dev = data;
if (val >= VIRTIO_FEATURES_MAX) if (val >= VIRTIO_FEATURES_BITS)
return -EINVAL; return -EINVAL;
virtio_features_set_bit(dev->debugfs_filter_features, val); virtio_features_set_bit(dev->debugfs_filter_features, val);
@ -64,7 +64,7 @@ static int virtio_debug_filter_feature_del(void *data, u64 val)
{ {
struct virtio_device *dev = data; struct virtio_device *dev = data;
if (val >= VIRTIO_FEATURES_MAX) if (val >= VIRTIO_FEATURES_BITS)
return -EINVAL; return -EINVAL;
virtio_features_clear_bit(dev->debugfs_filter_features, val); virtio_features_clear_bit(dev->debugfs_filter_features, val);

6
drivers/virtio/virtio_pci_modern_dev.c
View File

@ -401,7 +401,7 @@ void vp_modern_get_extended_features(struct virtio_pci_modern_device *mdev,
int i; int i;
virtio_features_zero(features); virtio_features_zero(features);
for (i = 0; i < VIRTIO_FEATURES_WORDS; i++) { for (i = 0; i < VIRTIO_FEATURES_BITS / 32; i++) {
u64 cur; u64 cur;
vp_iowrite32(i, &cfg->device_feature_select); vp_iowrite32(i, &cfg->device_feature_select);
@ -427,7 +427,7 @@ vp_modern_get_driver_extended_features(struct virtio_pci_modern_device *mdev,
int i; int i;
virtio_features_zero(features); virtio_features_zero(features);
for (i = 0; i < VIRTIO_FEATURES_WORDS; i++) { for (i = 0; i < VIRTIO_FEATURES_BITS / 32; i++) {
u64 cur; u64 cur;
vp_iowrite32(i, &cfg->guest_feature_select); vp_iowrite32(i, &cfg->guest_feature_select);
@ -448,7 +448,7 @@ void vp_modern_set_extended_features(struct virtio_pci_modern_device *mdev,
struct virtio_pci_common_cfg __iomem *cfg = mdev->common; struct virtio_pci_common_cfg __iomem *cfg = mdev->common;
int i; int i;
for (i = 0; i < VIRTIO_FEATURES_WORDS; i++) { for (i = 0; i < VIRTIO_FEATURES_BITS / 32; i++) {
u32 cur = features[i >> 1] >> (32 * (i & 1)); u32 cur = features[i >> 1] >> (32 * (i & 1));
vp_iowrite32(i, &cfg->guest_feature_select); vp_iowrite32(i, &cfg->guest_feature_select);

2
include/linux/virtio.h
View File

@ -177,7 +177,7 @@ struct virtio_device {
union virtio_map vmap; union virtio_map vmap;
#ifdef CONFIG_VIRTIO_DEBUG #ifdef CONFIG_VIRTIO_DEBUG
struct dentry *debugfs_dir; struct dentry *debugfs_dir;
u64 debugfs_filter_features[VIRTIO_FEATURES_DWORDS]; u64 debugfs_filter_features[VIRTIO_FEATURES_U64S];
#endif #endif
}; };

2
include/linux/virtio_config.h
View File

@ -80,7 +80,7 @@ struct virtqueue_info {
* Returns the first 64 feature bits. * Returns the first 64 feature bits.
* @get_extended_features: * @get_extended_features:
* vdev: the virtio_device * vdev: the virtio_device
* Returns the first VIRTIO_FEATURES_MAX feature bits (all we currently * Returns the first VIRTIO_FEATURES_BITS feature bits (all we currently
* need). * need).
* @finalize_features: confirm what device features we'll be using. * @finalize_features: confirm what device features we'll be using.
* vdev: the virtio_device * vdev: the virtio_device

29
include/linux/virtio_features.h
View File

@ -4,15 +4,16 @@
#include <linux/bits.h> #include <linux/bits.h>
#define VIRTIO_FEATURES_DWORDS 2 #define VIRTIO_FEATURES_U64S 2
#define VIRTIO_FEATURES_MAX (VIRTIO_FEATURES_DWORDS * 64) #define VIRTIO_FEATURES_BITS (VIRTIO_FEATURES_U64S * 64)
#define VIRTIO_FEATURES_WORDS (VIRTIO_FEATURES_DWORDS * 2)
#define VIRTIO_BIT(b) BIT_ULL((b) & 0x3f) #define VIRTIO_BIT(b) BIT_ULL((b) & 0x3f)
#define VIRTIO_DWORD(b) ((b) >> 6) #define VIRTIO_U64(b) ((b) >> 6)
#define VIRTIO_DECLARE_FEATURES(name) \ #define VIRTIO_DECLARE_FEATURES(name) \
union { \ union { \
u64 name; \ u64 name; \
u64 name##_array[VIRTIO_FEATURES_DWORDS];\ u64 name##_array[VIRTIO_FEATURES_U64S];\
} }
static inline bool virtio_features_chk_bit(unsigned int bit) static inline bool virtio_features_chk_bit(unsigned int bit)
@ -22,9 +23,9 @@ static inline bool virtio_features_chk_bit(unsigned int bit)
* Don't care returning the correct value: the build * Don't care returning the correct value: the build
* will fail before any bad features access * will fail before any bad features access
*/ */
BUILD_BUG_ON(bit >= VIRTIO_FEATURES_MAX); BUILD_BUG_ON(bit >= VIRTIO_FEATURES_BITS);
} else { } else {
if (WARN_ON_ONCE(bit >= VIRTIO_FEATURES_MAX)) if (WARN_ON_ONCE(bit >= VIRTIO_FEATURES_BITS))
return false; return false;
} }
return true; return true;
@ -34,26 +35,26 @@ static inline bool virtio_features_test_bit(const u64 *features,
unsigned int bit) unsigned int bit)
{ {
return virtio_features_chk_bit(bit) && return virtio_features_chk_bit(bit) &&
!!(features[VIRTIO_DWORD(bit)] & VIRTIO_BIT(bit)); !!(features[VIRTIO_U64(bit)] & VIRTIO_BIT(bit));
} }
static inline void virtio_features_set_bit(u64 *features, static inline void virtio_features_set_bit(u64 *features,
unsigned int bit) unsigned int bit)
{ {
if (virtio_features_chk_bit(bit)) if (virtio_features_chk_bit(bit))
features[VIRTIO_DWORD(bit)] |= VIRTIO_BIT(bit); features[VIRTIO_U64(bit)] |= VIRTIO_BIT(bit);
} }
static inline void virtio_features_clear_bit(u64 *features, static inline void virtio_features_clear_bit(u64 *features,
unsigned int bit) unsigned int bit)
{ {
if (virtio_features_chk_bit(bit)) if (virtio_features_chk_bit(bit))
features[VIRTIO_DWORD(bit)] &= ~VIRTIO_BIT(bit); features[VIRTIO_U64(bit)] &= ~VIRTIO_BIT(bit);
} }
static inline void virtio_features_zero(u64 *features) static inline void virtio_features_zero(u64 *features)
{ {
memset(features, 0, sizeof(features[0]) * VIRTIO_FEATURES_DWORDS); memset(features, 0, sizeof(features[0]) * VIRTIO_FEATURES_U64S);
} }
static inline void virtio_features_from_u64(u64 *features, u64 from) static inline void virtio_features_from_u64(u64 *features, u64 from)
@ -66,7 +67,7 @@ static inline bool virtio_features_equal(const u64 *f1, const u64 *f2)
{ {
int i; int i;
for (i = 0; i < VIRTIO_FEATURES_DWORDS; ++i) for (i = 0; i < VIRTIO_FEATURES_U64S; ++i)
if (f1[i] != f2[i]) if (f1[i] != f2[i])
return false; return false;
return true; return true;
@ -74,14 +75,14 @@ static inline bool virtio_features_equal(const u64 *f1, const u64 *f2)
static inline void virtio_features_copy(u64 *to, const u64 *from) static inline void virtio_features_copy(u64 *to, const u64 *from)
{ {
memcpy(to, from, sizeof(to[0]) * VIRTIO_FEATURES_DWORDS); memcpy(to, from, sizeof(to[0]) * VIRTIO_FEATURES_U64S);
} }
static inline void virtio_features_andnot(u64 *to, const u64 *f1, const u64 *f2) static inline void virtio_features_andnot(u64 *to, const u64 *f1, const u64 *f2)
{ {
int i; int i;
for (i = 0; i < VIRTIO_FEATURES_DWORDS; i++) for (i = 0; i < VIRTIO_FEATURES_U64S; i++)
to[i] = f1[i] & ~f2[i]; to[i] = f1[i] & ~f2[i];
} }

8
include/linux/virtio_pci_modern.h
View File

@ -107,7 +107,7 @@ void vp_modern_set_extended_features(struct virtio_pci_modern_device *mdev,
static inline u64 static inline u64
vp_modern_get_features(struct virtio_pci_modern_device *mdev) vp_modern_get_features(struct virtio_pci_modern_device *mdev)
{ {
u64 features_array[VIRTIO_FEATURES_DWORDS]; u64 features_array[VIRTIO_FEATURES_U64S];
vp_modern_get_extended_features(mdev, features_array); vp_modern_get_extended_features(mdev, features_array);
return features_array[0]; return features_array[0];
@ -116,11 +116,11 @@ vp_modern_get_features(struct virtio_pci_modern_device *mdev)
static inline u64 static inline u64
vp_modern_get_driver_features(struct virtio_pci_modern_device *mdev) vp_modern_get_driver_features(struct virtio_pci_modern_device *mdev)
{ {
u64 features_array[VIRTIO_FEATURES_DWORDS]; u64 features_array[VIRTIO_FEATURES_U64S];
int i; int i;
vp_modern_get_driver_extended_features(mdev, features_array); vp_modern_get_driver_extended_features(mdev, features_array);
for (i = 1; i < VIRTIO_FEATURES_DWORDS; ++i) for (i = 1; i < VIRTIO_FEATURES_U64S; ++i)
WARN_ON_ONCE(features_array[i]); WARN_ON_ONCE(features_array[i]);
return features_array[0]; return features_array[0];
} }
@ -128,7 +128,7 @@ vp_modern_get_driver_features(struct virtio_pci_modern_device *mdev)
static inline void static inline void
vp_modern_set_features(struct virtio_pci_modern_device *mdev, u64 features) vp_modern_set_features(struct virtio_pci_modern_device *mdev, u64 features)
{ {
u64 features_array[VIRTIO_FEATURES_DWORDS]; u64 features_array[VIRTIO_FEATURES_U64S];
virtio_features_from_u64(features_array, features); virtio_features_from_u64(features_array, features);
vp_modern_set_extended_features(mdev, features_array); vp_modern_set_extended_features(mdev, features_array);