Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
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: e7d4c1c5a546 ("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>
+41
-40
+6
-6
drivers/vhost/net.c
+6
-6
drivers/vhost/net.c
···
69
69
70
70
#define VHOST_DMA_IS_DONE(len) ((__force u32)(len) >= (__force u32)VHOST_DMA_DONE_LEN)
71
71
72
-
static const u64 vhost_net_features[VIRTIO_FEATURES_DWORDS] = {
72
+
static const u64 vhost_net_features[VIRTIO_FEATURES_U64S] = {
73
73
VHOST_FEATURES |
74
74
(1ULL << VHOST_NET_F_VIRTIO_NET_HDR) |
75
75
(1ULL << VIRTIO_NET_F_MRG_RXBUF) |
···
1720
1720
static long vhost_net_ioctl(struct file *f, unsigned int ioctl,
1721
1721
unsigned long arg)
1722
1722
{
1723
-
u64 all_features[VIRTIO_FEATURES_DWORDS];
1723
+
u64 all_features[VIRTIO_FEATURES_U64S];
1724
1724
struct vhost_net *n = f->private_data;
1725
1725
void __user *argp = (void __user *)arg;
1726
1726
u64 __user *featurep = argp;
···
1752
1752
1753
1753
/* Copy the net features, up to the user-provided buffer size */
1754
1754
argp += sizeof(u64);
1755
-
copied = min(count, VIRTIO_FEATURES_DWORDS);
1755
+
copied = min(count, (u64)VIRTIO_FEATURES_U64S);
1756
1756
if (copy_to_user(argp, vhost_net_features,
1757
1757
copied * sizeof(u64)))
1758
1758
return -EFAULT;
···
1767
1767
1768
1768
virtio_features_zero(all_features);
1769
1769
argp += sizeof(u64);
1770
-
copied = min(count, VIRTIO_FEATURES_DWORDS);
1770
+
copied = min(count, (u64)VIRTIO_FEATURES_U64S);
1771
1771
if (copy_from_user(all_features, argp, copied * sizeof(u64)))
1772
1772
return -EFAULT;
1773
1773
1774
1774
/*
1775
1775
* Any feature specified by user-space above
1776
-
* VIRTIO_FEATURES_MAX is not supported by definition.
1776
+
* VIRTIO_FEATURES_BITS is not supported by definition.
1777
1777
*/
1778
1778
for (i = copied; i < count; ++i) {
1779
1779
if (copy_from_user(&features, featurep + 1 + i,
···
1783
1783
return -EOPNOTSUPP;
1784
1784
}
1785
1785
1786
-
for (i = 0; i < VIRTIO_FEATURES_DWORDS; i++)
1786
+
for (i = 0; i < VIRTIO_FEATURES_U64S; i++)
1787
1787
if (all_features[i] & ~vhost_net_features[i])
1788
1788
return -EOPNOTSUPP;
1789
1789
+6
-6
drivers/virtio/virtio.c
+6
-6
drivers/virtio/virtio.c
···
53
53
54
54
/* We actually represent this as a bitstring, as it could be
55
55
* arbitrary length in future. */
56
-
for (i = 0; i < VIRTIO_FEATURES_MAX; i++)
56
+
for (i = 0; i < VIRTIO_FEATURES_BITS; i++)
57
57
len += sysfs_emit_at(buf, len, "%c",
58
58
__virtio_test_bit(dev, i) ? '1' : '0');
59
59
len += sysfs_emit_at(buf, len, "\n");
···
272
272
int err, i;
273
273
struct virtio_device *dev = dev_to_virtio(_d);
274
274
struct virtio_driver *drv = drv_to_virtio(dev->dev.driver);
275
-
u64 device_features[VIRTIO_FEATURES_DWORDS];
276
-
u64 driver_features[VIRTIO_FEATURES_DWORDS];
275
+
u64 device_features[VIRTIO_FEATURES_U64S];
276
+
u64 driver_features[VIRTIO_FEATURES_U64S];
277
277
u64 driver_features_legacy;
278
278
279
279
/* We have a driver! */
···
286
286
virtio_features_zero(driver_features);
287
287
for (i = 0; i < drv->feature_table_size; i++) {
288
288
unsigned int f = drv->feature_table[i];
289
-
if (!WARN_ON_ONCE(f >= VIRTIO_FEATURES_MAX))
289
+
if (!WARN_ON_ONCE(f >= VIRTIO_FEATURES_BITS))
290
290
virtio_features_set_bit(driver_features, f);
291
291
}
292
292
···
303
303
}
304
304
305
305
if (virtio_features_test_bit(device_features, VIRTIO_F_VERSION_1)) {
306
-
for (i = 0; i < VIRTIO_FEATURES_DWORDS; ++i)
306
+
for (i = 0; i < VIRTIO_FEATURES_U64S; ++i)
307
307
dev->features_array[i] = driver_features[i] &
308
308
device_features[i];
309
309
} else {
···
325
325
goto err;
326
326
327
327
if (drv->validate) {
328
-
u64 features[VIRTIO_FEATURES_DWORDS];
328
+
u64 features[VIRTIO_FEATURES_U64S];
329
329
330
330
virtio_features_copy(features, dev->features_array);
331
331
err = drv->validate(dev);
+5
-5
drivers/virtio/virtio_debug.c
+5
-5
drivers/virtio/virtio_debug.c
···
8
8
9
9
static int virtio_debug_device_features_show(struct seq_file *s, void *data)
10
10
{
11
-
u64 device_features[VIRTIO_FEATURES_DWORDS];
11
+
u64 device_features[VIRTIO_FEATURES_U64S];
12
12
struct virtio_device *dev = s->private;
13
13
unsigned int i;
14
14
15
15
virtio_get_features(dev, device_features);
16
-
for (i = 0; i < VIRTIO_FEATURES_MAX; i++) {
16
+
for (i = 0; i < VIRTIO_FEATURES_BITS; i++) {
17
17
if (virtio_features_test_bit(device_features, i))
18
18
seq_printf(s, "%u\n", i);
19
19
}
···
26
26
struct virtio_device *dev = s->private;
27
27
unsigned int i;
28
28
29
-
for (i = 0; i < VIRTIO_FEATURES_MAX; i++) {
29
+
for (i = 0; i < VIRTIO_FEATURES_BITS; i++) {
30
30
if (virtio_features_test_bit(dev->debugfs_filter_features, i))
31
31
seq_printf(s, "%u\n", i);
32
32
}
···
50
50
{
51
51
struct virtio_device *dev = data;
52
52
53
-
if (val >= VIRTIO_FEATURES_MAX)
53
+
if (val >= VIRTIO_FEATURES_BITS)
54
54
return -EINVAL;
55
55
56
56
virtio_features_set_bit(dev->debugfs_filter_features, val);
···
64
64
{
65
65
struct virtio_device *dev = data;
66
66
67
-
if (val >= VIRTIO_FEATURES_MAX)
67
+
if (val >= VIRTIO_FEATURES_BITS)
68
68
return -EINVAL;
69
69
70
70
virtio_features_clear_bit(dev->debugfs_filter_features, val);
+3
-3
drivers/virtio/virtio_pci_modern_dev.c
+3
-3
drivers/virtio/virtio_pci_modern_dev.c
···
401
401
int i;
402
402
403
403
virtio_features_zero(features);
404
-
for (i = 0; i < VIRTIO_FEATURES_WORDS; i++) {
404
+
for (i = 0; i < VIRTIO_FEATURES_BITS / 32; i++) {
405
405
u64 cur;
406
406
407
407
vp_iowrite32(i, &cfg->device_feature_select);
···
427
427
int i;
428
428
429
429
virtio_features_zero(features);
430
-
for (i = 0; i < VIRTIO_FEATURES_WORDS; i++) {
430
+
for (i = 0; i < VIRTIO_FEATURES_BITS / 32; i++) {
431
431
u64 cur;
432
432
433
433
vp_iowrite32(i, &cfg->guest_feature_select);
···
448
448
struct virtio_pci_common_cfg __iomem *cfg = mdev->common;
449
449
int i;
450
450
451
-
for (i = 0; i < VIRTIO_FEATURES_WORDS; i++) {
451
+
for (i = 0; i < VIRTIO_FEATURES_BITS / 32; i++) {
452
452
u32 cur = features[i >> 1] >> (32 * (i & 1));
453
453
454
454
vp_iowrite32(i, &cfg->guest_feature_select);
+1
-1
include/linux/virtio.h
+1
-1
include/linux/virtio.h
+1
-1
include/linux/virtio_config.h
+1
-1
include/linux/virtio_config.h
···
80
80
* Returns the first 64 feature bits.
81
81
* @get_extended_features:
82
82
* vdev: the virtio_device
83
-
* Returns the first VIRTIO_FEATURES_MAX feature bits (all we currently
83
+
* Returns the first VIRTIO_FEATURES_BITS feature bits (all we currently
84
84
* need).
85
85
* @finalize_features: confirm what device features we'll be using.
86
86
* vdev: the virtio_device
+15
-14
include/linux/virtio_features.h
+15
-14
include/linux/virtio_features.h
···
4
4
5
5
#include <linux/bits.h>
6
6
7
-
#define VIRTIO_FEATURES_DWORDS 2
8
-
#define VIRTIO_FEATURES_MAX (VIRTIO_FEATURES_DWORDS * 64)
9
-
#define VIRTIO_FEATURES_WORDS (VIRTIO_FEATURES_DWORDS * 2)
7
+
#define VIRTIO_FEATURES_U64S 2
8
+
#define VIRTIO_FEATURES_BITS (VIRTIO_FEATURES_U64S * 64)
9
+
10
10
#define VIRTIO_BIT(b) BIT_ULL((b) & 0x3f)
11
-
#define VIRTIO_DWORD(b) ((b) >> 6)
11
+
#define VIRTIO_U64(b) ((b) >> 6)
12
+
12
13
#define VIRTIO_DECLARE_FEATURES(name) \
13
14
union { \
14
15
u64 name; \
15
-
u64 name##_array[VIRTIO_FEATURES_DWORDS];\
16
+
u64 name##_array[VIRTIO_FEATURES_U64S];\
16
17
}
17
18
18
19
static inline bool virtio_features_chk_bit(unsigned int bit)
···
23
22
* Don't care returning the correct value: the build
24
23
* will fail before any bad features access
25
24
*/
26
-
BUILD_BUG_ON(bit >= VIRTIO_FEATURES_MAX);
25
+
BUILD_BUG_ON(bit >= VIRTIO_FEATURES_BITS);
27
26
} else {
28
-
if (WARN_ON_ONCE(bit >= VIRTIO_FEATURES_MAX))
27
+
if (WARN_ON_ONCE(bit >= VIRTIO_FEATURES_BITS))
29
28
return false;
30
29
}
31
30
return true;
···
35
34
unsigned int bit)
36
35
{
37
36
return virtio_features_chk_bit(bit) &&
38
-
!!(features[VIRTIO_DWORD(bit)] & VIRTIO_BIT(bit));
37
+
!!(features[VIRTIO_U64(bit)] & VIRTIO_BIT(bit));
39
38
}
40
39
41
40
static inline void virtio_features_set_bit(u64 *features,
42
41
unsigned int bit)
43
42
{
44
43
if (virtio_features_chk_bit(bit))
45
-
features[VIRTIO_DWORD(bit)] |= VIRTIO_BIT(bit);
44
+
features[VIRTIO_U64(bit)] |= VIRTIO_BIT(bit);
46
45
}
47
46
48
47
static inline void virtio_features_clear_bit(u64 *features,
49
48
unsigned int bit)
50
49
{
51
50
if (virtio_features_chk_bit(bit))
52
-
features[VIRTIO_DWORD(bit)] &= ~VIRTIO_BIT(bit);
51
+
features[VIRTIO_U64(bit)] &= ~VIRTIO_BIT(bit);
53
52
}
54
53
55
54
static inline void virtio_features_zero(u64 *features)
56
55
{
57
-
memset(features, 0, sizeof(features[0]) * VIRTIO_FEATURES_DWORDS);
56
+
memset(features, 0, sizeof(features[0]) * VIRTIO_FEATURES_U64S);
58
57
}
59
58
60
59
static inline void virtio_features_from_u64(u64 *features, u64 from)
···
67
66
{
68
67
int i;
69
68
70
-
for (i = 0; i < VIRTIO_FEATURES_DWORDS; ++i)
69
+
for (i = 0; i < VIRTIO_FEATURES_U64S; ++i)
71
70
if (f1[i] != f2[i])
72
71
return false;
73
72
return true;
···
75
74
76
75
static inline void virtio_features_copy(u64 *to, const u64 *from)
77
76
{
78
-
memcpy(to, from, sizeof(to[0]) * VIRTIO_FEATURES_DWORDS);
77
+
memcpy(to, from, sizeof(to[0]) * VIRTIO_FEATURES_U64S);
79
78
}
80
79
81
80
static inline void virtio_features_andnot(u64 *to, const u64 *f1, const u64 *f2)
82
81
{
83
82
int i;
84
83
85
-
for (i = 0; i < VIRTIO_FEATURES_DWORDS; i++)
84
+
for (i = 0; i < VIRTIO_FEATURES_U64S; i++)
86
85
to[i] = f1[i] & ~f2[i];
87
86
}
88
87
+4
-4
include/linux/virtio_pci_modern.h
+4
-4
include/linux/virtio_pci_modern.h
···
107
107
static inline u64
108
108
vp_modern_get_features(struct virtio_pci_modern_device *mdev)
109
109
{
110
-
u64 features_array[VIRTIO_FEATURES_DWORDS];
110
+
u64 features_array[VIRTIO_FEATURES_U64S];
111
111
112
112
vp_modern_get_extended_features(mdev, features_array);
113
113
return features_array[0];
···
116
116
static inline u64
117
117
vp_modern_get_driver_features(struct virtio_pci_modern_device *mdev)
118
118
{
119
-
u64 features_array[VIRTIO_FEATURES_DWORDS];
119
+
u64 features_array[VIRTIO_FEATURES_U64S];
120
120
int i;
121
121
122
122
vp_modern_get_driver_extended_features(mdev, features_array);
123
-
for (i = 1; i < VIRTIO_FEATURES_DWORDS; ++i)
123
+
for (i = 1; i < VIRTIO_FEATURES_U64S; ++i)
124
124
WARN_ON_ONCE(features_array[i]);
125
125
return features_array[0];
126
126
}
···
128
128
static inline void
129
129
vp_modern_set_features(struct virtio_pci_modern_device *mdev, u64 features)
130
130
{
131
-
u64 features_array[VIRTIO_FEATURES_DWORDS];
131
+
u64 features_array[VIRTIO_FEATURES_U64S];
132
132
133
133
virtio_features_from_u64(features_array, features);
134
134
vp_modern_set_extended_features(mdev, features_array);