vhost: Create accessors for virtqueues private_data

+15 -13

drivers/vhost/net.c

··· 424 424 struct vhost_net_virtqueue *nvq = 425 425 container_of(vq, struct vhost_net_virtqueue, vq); 426 426 struct vhost_poll *poll = n->poll + (nvq - n->vqs); 427 - if (!vq->private_data) 427 + if (!vhost_vq_get_backend(vq)) 428 428 return; 429 429 vhost_poll_stop(poll); 430 430 } ··· 437 437 struct vhost_poll *poll = n->poll + (nvq - n->vqs); 438 438 struct socket *sock; 439 439 440 - sock = vq->private_data; 440 + sock = vhost_vq_get_backend(vq); 441 441 if (!sock) 442 442 return 0; 443 443 ··· 524 524 return; 525 525 526 526 vhost_disable_notify(&net->dev, vq); 527 - sock = rvq->private_data; 527 + sock = vhost_vq_get_backend(rvq); 528 528 529 529 busyloop_timeout = poll_rx ? rvq->busyloop_timeout: 530 530 tvq->busyloop_timeout; ··· 570 570 571 571 if (r == tvq->num && tvq->busyloop_timeout) { 572 572 /* Flush batched packets first */ 573 - if (!vhost_sock_zcopy(tvq->private_data)) 574 - vhost_tx_batch(net, tnvq, tvq->private_data, msghdr); 573 + if (!vhost_sock_zcopy(vhost_vq_get_backend(tvq))) 574 + vhost_tx_batch(net, tnvq, 575 + vhost_vq_get_backend(tvq), 576 + msghdr); 575 577 576 578 vhost_net_busy_poll(net, rvq, tvq, busyloop_intr, false); 577 579 ··· 687 685 struct vhost_virtqueue *vq = &nvq->vq; 688 686 struct vhost_net *net = container_of(vq->dev, struct vhost_net, 689 687 dev); 690 - struct socket *sock = vq->private_data; 688 + struct socket *sock = vhost_vq_get_backend(vq); 691 689 struct page_frag *alloc_frag = &net->page_frag; 692 690 struct virtio_net_hdr *gso; 693 691 struct xdp_buff *xdp = &nvq->xdp[nvq->batched_xdp]; ··· 954 952 struct socket *sock; 955 953 956 954 mutex_lock_nested(&vq->mutex, VHOST_NET_VQ_TX); 957 - sock = vq->private_data; 955 + sock = vhost_vq_get_backend(vq); 958 956 if (!sock) 959 957 goto out; 960 958 ··· 1123 1121 int recv_pkts = 0; 1124 1122 1125 1123 mutex_lock_nested(&vq->mutex, VHOST_NET_VQ_RX); 1126 - sock = vq->private_data; 1124 + sock = vhost_vq_get_backend(vq); 1127 1125 if (!sock) 1128 1126 goto out; 1129 1127 ··· 1347 1345 container_of(vq, struct vhost_net_virtqueue, vq); 1348 1346 1349 1347 mutex_lock(&vq->mutex); 1350 - sock = vq->private_data; 1348 + sock = vhost_vq_get_backend(vq); 1351 1349 vhost_net_disable_vq(n, vq); 1352 - vq->private_data = NULL; 1350 + vhost_vq_set_backend(vq, NULL); 1353 1351 vhost_net_buf_unproduce(nvq); 1354 1352 nvq->rx_ring = NULL; 1355 1353 mutex_unlock(&vq->mutex); ··· 1523 1521 } 1524 1522 1525 1523 /* start polling new socket */ 1526 - oldsock = vq->private_data; 1524 + oldsock = vhost_vq_get_backend(vq); 1527 1525 if (sock != oldsock) { 1528 1526 ubufs = vhost_net_ubuf_alloc(vq, 1529 1527 sock && vhost_sock_zcopy(sock)); ··· 1533 1531 } 1534 1532 1535 1533 vhost_net_disable_vq(n, vq); 1536 - vq->private_data = sock; 1534 + vhost_vq_set_backend(vq, sock); 1537 1535 vhost_net_buf_unproduce(nvq); 1538 1536 r = vhost_vq_init_access(vq); 1539 1537 if (r) ··· 1570 1568 return 0; 1571 1569 1572 1570 err_used: 1573 - vq->private_data = oldsock; 1571 + vhost_vq_set_backend(vq, oldsock); 1574 1572 vhost_net_enable_vq(n, vq); 1575 1573 if (ubufs) 1576 1574 vhost_net_ubuf_put_wait_and_free(ubufs);

+7 -7

drivers/vhost/scsi.c

··· 452 452 unsigned out, in; 453 453 int head, ret; 454 454 455 - if (!vq->private_data) { 455 + if (!vhost_vq_get_backend(vq)) { 456 456 vs->vs_events_missed = true; 457 457 return; 458 458 } ··· 892 892 } else { 893 893 struct vhost_scsi_tpg **vs_tpg, *tpg; 894 894 895 - vs_tpg = vq->private_data; /* validated at handler entry */ 895 + vs_tpg = vhost_vq_get_backend(vq); /* validated at handler entry */ 896 896 897 897 tpg = READ_ONCE(vs_tpg[*vc->target]); 898 898 if (unlikely(!tpg)) { ··· 929 929 * We can handle the vq only after the endpoint is setup by calling the 930 930 * VHOST_SCSI_SET_ENDPOINT ioctl. 931 931 */ 932 - vs_tpg = vq->private_data; 932 + vs_tpg = vhost_vq_get_backend(vq); 933 933 if (!vs_tpg) 934 934 goto out; 935 935 ··· 1184 1184 * We can handle the vq only after the endpoint is setup by calling the 1185 1185 * VHOST_SCSI_SET_ENDPOINT ioctl. 1186 1186 */ 1187 - if (!vq->private_data) 1187 + if (!vhost_vq_get_backend(vq)) 1188 1188 goto out; 1189 1189 1190 1190 memset(&vc, 0, sizeof(vc)); ··· 1322 1322 struct vhost_scsi *vs = container_of(vq->dev, struct vhost_scsi, dev); 1323 1323 1324 1324 mutex_lock(&vq->mutex); 1325 - if (!vq->private_data) 1325 + if (!vhost_vq_get_backend(vq)) 1326 1326 goto out; 1327 1327 1328 1328 if (vs->vs_events_missed) ··· 1460 1460 for (i = 0; i < VHOST_SCSI_MAX_VQ; i++) { 1461 1461 vq = &vs->vqs[i].vq; 1462 1462 mutex_lock(&vq->mutex); 1463 - vq->private_data = vs_tpg; 1463 + vhost_vq_set_backend(vq, vs_tpg); 1464 1464 vhost_vq_init_access(vq); 1465 1465 mutex_unlock(&vq->mutex); 1466 1466 } ··· 1547 1547 for (i = 0; i < VHOST_SCSI_MAX_VQ; i++) { 1548 1548 vq = &vs->vqs[i].vq; 1549 1549 mutex_lock(&vq->mutex); 1550 - vq->private_data = NULL; 1550 + vhost_vq_set_backend(vq, NULL); 1551 1551 mutex_unlock(&vq->mutex); 1552 1552 } 1553 1553 }

+5 -5

drivers/vhost/test.c

··· 49 49 void *private; 50 50 51 51 mutex_lock(&vq->mutex); 52 - private = vq->private_data; 52 + private = vhost_vq_get_backend(vq); 53 53 if (!private) { 54 54 mutex_unlock(&vq->mutex); 55 55 return; ··· 133 133 void *private; 134 134 135 135 mutex_lock(&vq->mutex); 136 - private = vq->private_data; 137 - vq->private_data = NULL; 136 + private = vhost_vq_get_backend(vq); 137 + vhost_vq_set_backend(vq, NULL); 138 138 mutex_unlock(&vq->mutex); 139 139 return private; 140 140 } ··· 198 198 priv = test ? n : NULL; 199 199 200 200 /* start polling new socket */ 201 - oldpriv = vq->private_data; 202 - vq->private_data = priv; 201 + oldpriv = vhost_vq_get_backend(vq); 202 + vhost_vq_set_backend(vq, priv); 203 203 204 204 r = vhost_vq_init_access(&n->vqs[index]); 205 205

+27

drivers/vhost/vhost.h

··· 231 231 (1ULL << VIRTIO_F_VERSION_1) 232 232 }; 233 233 234 + /** 235 + * vhost_vq_set_backend - Set backend. 236 + * 237 + * @vq Virtqueue. 238 + * @private_data The private data. 239 + * 240 + * Context: Need to call with vq->mutex acquired. 241 + */ 242 + static inline void vhost_vq_set_backend(struct vhost_virtqueue *vq, 243 + void *private_data) 244 + { 245 + vq->private_data = private_data; 246 + } 247 + 248 + /** 249 + * vhost_vq_get_backend - Get backend. 250 + * 251 + * @vq Virtqueue. 252 + * 253 + * Context: Need to call with vq->mutex acquired. 254 + * Return: Private data previously set with vhost_vq_set_backend. 255 + */ 256 + static inline void *vhost_vq_get_backend(struct vhost_virtqueue *vq) 257 + { 258 + return vq->private_data; 259 + } 260 + 234 261 static inline bool vhost_has_feature(struct vhost_virtqueue *vq, int bit) 235 262 { 236 263 return vq->acked_features & (1ULL << bit);

+7 -7

drivers/vhost/vsock.c

··· 91 91 92 92 mutex_lock(&vq->mutex); 93 93 94 - if (!vq->private_data) 94 + if (!vhost_vq_get_backend(vq)) 95 95 goto out; 96 96 97 97 /* Avoid further vmexits, we're already processing the virtqueue */ ··· 440 440 441 441 mutex_lock(&vq->mutex); 442 442 443 - if (!vq->private_data) 443 + if (!vhost_vq_get_backend(vq)) 444 444 goto out; 445 445 446 446 vhost_disable_notify(&vsock->dev, vq); ··· 533 533 goto err_vq; 534 534 } 535 535 536 - if (!vq->private_data) { 537 - vq->private_data = vsock; 536 + if (!vhost_vq_get_backend(vq)) { 537 + vhost_vq_set_backend(vq, vsock); 538 538 ret = vhost_vq_init_access(vq); 539 539 if (ret) 540 540 goto err_vq; ··· 547 547 return 0; 548 548 549 549 err_vq: 550 - vq->private_data = NULL; 550 + vhost_vq_set_backend(vq, NULL); 551 551 mutex_unlock(&vq->mutex); 552 552 553 553 for (i = 0; i < ARRAY_SIZE(vsock->vqs); i++) { 554 554 vq = &vsock->vqs[i]; 555 555 556 556 mutex_lock(&vq->mutex); 557 - vq->private_data = NULL; 557 + vhost_vq_set_backend(vq, NULL); 558 558 mutex_unlock(&vq->mutex); 559 559 } 560 560 err: ··· 577 577 struct vhost_virtqueue *vq = &vsock->vqs[i]; 578 578 579 579 mutex_lock(&vq->mutex); 580 - vq->private_data = NULL; 580 + vhost_vq_set_backend(vq, NULL); 581 581 mutex_unlock(&vq->mutex); 582 582 } 583 583

Configure Feed

Configure Feed