net/hns3: fix link status change from firmware
[dpdk.git] / examples / vhost_blk / vhost_blk_compat.c
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright(c) 2010-2019 Intel Corporation
3  */
4
5 #ifndef _VHOST_BLK_COMPAT_H_
6 #define _VHOST_BLK_COMPAT_H_
7
8 #include <sys/uio.h>
9 #include <stdint.h>
10 #include <linux/virtio_blk.h>
11 #include <linux/virtio_ring.h>
12
13 #include <rte_vhost.h>
14 #include "vhost_blk.h"
15 #include "blk_spec.h"
16
17 #define VHOST_MAX_VQUEUES       256
18 #define SPDK_VHOST_MAX_VQ_SIZE  1024
19
20 #define VHOST_USER_GET_CONFIG   24
21 #define VHOST_USER_SET_CONFIG   25
22
23 static int
24 vhost_blk_get_config(struct vhost_block_dev *bdev, uint8_t *config,
25                           uint32_t len)
26 {
27         struct virtio_blk_config blkcfg;
28         uint32_t blk_size;
29         uint64_t blkcnt;
30
31         if (bdev == NULL) {
32                 /* We can't just return -1 here as this GET_CONFIG message might
33                  * be caused by a QEMU VM reboot. Returning -1 will indicate an
34                  * error to QEMU, who might then decide to terminate itself.
35                  * We don't want that. A simple reboot shouldn't break the
36                  * system.
37                  *
38                  * Presenting a block device with block size 0 and block count 0
39                  * doesn't cause any problems on QEMU side and the virtio-pci
40                  * device is even still available inside the VM, but there will
41                  * be no block device created for it - the kernel drivers will
42                  * silently reject it.
43                  */
44                 blk_size = 0;
45                 blkcnt = 0;
46         } else {
47                 blk_size = bdev->blocklen;
48                 blkcnt = bdev->blockcnt;
49         }
50
51         memset(&blkcfg, 0, sizeof(blkcfg));
52         blkcfg.blk_size = blk_size;
53         /* minimum I/O size in blocks */
54         blkcfg.min_io_size = 1;
55         /* expressed in 512 Bytes sectors */
56         blkcfg.capacity = (blkcnt * blk_size) / 512;
57         /* QEMU can overwrite this value when started */
58         blkcfg.num_queues = VHOST_MAX_VQUEUES;
59
60         fprintf(stdout, "block device:blk_size = %d, blkcnt = %"PRIx64"\n",
61                 blk_size, blkcnt);
62
63         memcpy(config, &blkcfg, RTE_MIN(len, sizeof(blkcfg)));
64
65         return 0;
66 }
67
68 static enum rte_vhost_msg_result
69 extern_vhost_pre_msg_handler(int vid, void *_msg)
70 {
71         char path[PATH_MAX];
72         struct vhost_blk_ctrlr *ctrlr;
73         struct vhost_user_msg *msg = _msg;
74         int ret;
75
76         ret = rte_vhost_get_ifname(vid, path, PATH_MAX);
77         if (ret) {
78                 fprintf(stderr, "Cannot get socket name\n");
79                 return -1;
80         }
81
82         ctrlr = vhost_blk_ctrlr_find(path);
83         if (!ctrlr) {
84                 fprintf(stderr, "Controller is not ready\n");
85                 return -1;
86         }
87
88         switch ((int)msg->request) {
89         case VHOST_USER_GET_VRING_BASE:
90         case VHOST_USER_SET_VRING_BASE:
91         case VHOST_USER_SET_VRING_ADDR:
92         case VHOST_USER_SET_VRING_NUM:
93         case VHOST_USER_SET_VRING_KICK:
94         case VHOST_USER_SET_VRING_CALL:
95         case VHOST_USER_SET_MEM_TABLE:
96                 break;
97         case VHOST_USER_GET_CONFIG: {
98                 int rc = 0;
99
100                 rc = vhost_blk_get_config(ctrlr->bdev,
101                                           msg->payload.cfg.region,
102                                           msg->payload.cfg.size);
103                 if (rc != 0)
104                         msg->size = 0;
105
106                 return RTE_VHOST_MSG_RESULT_REPLY;
107         }
108         case VHOST_USER_SET_CONFIG:
109         default:
110                 break;
111         }
112
113         return RTE_VHOST_MSG_RESULT_NOT_HANDLED;
114 }
115
116 static enum rte_vhost_msg_result
117 extern_vhost_post_msg_handler(int vid, void *_msg)
118 {
119         char path[PATH_MAX];
120         struct vhost_blk_ctrlr *ctrlr;
121         struct vhost_user_msg *msg = _msg;
122         int ret;
123
124         ret = rte_vhost_get_ifname(vid, path, PATH_MAX);
125         if (ret) {
126                 fprintf(stderr, "Cannot get socket name\n");
127                 return -1;
128         }
129
130         ctrlr = vhost_blk_ctrlr_find(path);
131         if (!ctrlr) {
132                 fprintf(stderr, "Controller is not ready\n");
133                 return -1;
134         }
135
136         switch (msg->request) {
137         case VHOST_USER_SET_FEATURES:
138         case VHOST_USER_SET_VRING_KICK:
139         default:
140                 break;
141         }
142
143         return RTE_VHOST_MSG_RESULT_NOT_HANDLED;
144 }
145
146 struct rte_vhost_user_extern_ops g_extern_vhost_ops = {
147         .pre_msg_handle = extern_vhost_pre_msg_handler,
148         .post_msg_handle = extern_vhost_post_msg_handler,
149 };
150
151 void
152 vhost_session_install_rte_compat_hooks(uint32_t vid)
153 {
154         int rc;
155
156         rc = rte_vhost_extern_callback_register(vid, &g_extern_vhost_ops, NULL);
157         if (rc != 0)
158                 fprintf(stderr,
159                         "rte_vhost_extern_callback_register() failed for vid = %d\n",
160                         vid);
161 }
162
163 void
164 vhost_dev_install_rte_compat_hooks(const char *path)
165 {
166         uint64_t protocol_features = 0;
167
168         rte_vhost_driver_get_protocol_features(path, &protocol_features);
169         protocol_features |= (1ULL << VHOST_USER_PROTOCOL_F_CONFIG);
170         protocol_features |= (1ULL << VHOST_USER_PROTOCOL_F_INFLIGHT_SHMFD);
171         rte_vhost_driver_set_protocol_features(path, protocol_features);
172 }
173
174 #endif