1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Copyright (C) 2003-2008 Takahiro Hirofuchi 4 */ 5 6 #include <linux/kthread.h> 7 #include <linux/slab.h> 8 9 #include "usbip_common.h" 10 #include "vhci.h" 11 12 static void setup_cmd_submit_pdu(struct usbip_header *pdup, struct urb *urb) 13 { 14 struct vhci_priv *priv = ((struct vhci_priv *)urb->hcpriv); 15 struct vhci_device *vdev = priv->vdev; 16 17 usbip_dbg_vhci_tx("URB, local devnum %u, remote devid %u\n", 18 usb_pipedevice(urb->pipe), vdev->devid); 19 20 pdup->base.command = USBIP_CMD_SUBMIT; 21 pdup->base.seqnum = priv->seqnum; 22 pdup->base.devid = vdev->devid; 23 pdup->base.direction = usb_pipein(urb->pipe) ? 24 USBIP_DIR_IN : USBIP_DIR_OUT; 25 pdup->base.ep = usb_pipeendpoint(urb->pipe); 26 27 usbip_pack_pdu(pdup, urb, USBIP_CMD_SUBMIT, 1); 28 29 if (urb->setup_packet) 30 memcpy(pdup->u.cmd_submit.setup, urb->setup_packet, 8); 31 } 32 33 static struct vhci_priv *dequeue_from_priv_tx(struct vhci_device *vdev) 34 { 35 struct vhci_priv *priv, *tmp; 36 unsigned long flags; 37 38 spin_lock_irqsave(&vdev->priv_lock, flags); 39 40 list_for_each_entry_safe(priv, tmp, &vdev->priv_tx, list) { 41 list_move_tail(&priv->list, &vdev->priv_rx); 42 spin_unlock_irqrestore(&vdev->priv_lock, flags); 43 return priv; 44 } 45 46 spin_unlock_irqrestore(&vdev->priv_lock, flags); 47 48 return NULL; 49 } 50 51 static int vhci_send_cmd_submit(struct vhci_device *vdev) 52 { 53 struct vhci_priv *priv = NULL; 54 55 struct msghdr msg; 56 struct kvec iov[3]; 57 size_t txsize; 58 59 size_t total_size = 0; 60 61 while ((priv = dequeue_from_priv_tx(vdev)) != NULL) { 62 int ret; 63 struct urb *urb = priv->urb; 64 struct usbip_header pdu_header; 65 struct usbip_iso_packet_descriptor *iso_buffer = NULL; 66 67 txsize = 0; 68 memset(&pdu_header, 0, sizeof(pdu_header)); 69 memset(&msg, 0, sizeof(msg)); 70 memset(&iov, 0, sizeof(iov)); 71 72 usbip_dbg_vhci_tx("setup txdata urb seqnum %lu\n", 73 priv->seqnum); 74 75 /* 1. setup usbip_header */ 76 setup_cmd_submit_pdu(&pdu_header, urb); 77 usbip_header_correct_endian(&pdu_header, 1); 78 79 iov[0].iov_base = &pdu_header; 80 iov[0].iov_len = sizeof(pdu_header); 81 txsize += sizeof(pdu_header); 82 83 /* 2. setup transfer buffer */ 84 if (!usb_pipein(urb->pipe) && urb->transfer_buffer_length > 0) { 85 iov[1].iov_base = urb->transfer_buffer; 86 iov[1].iov_len = urb->transfer_buffer_length; 87 txsize += urb->transfer_buffer_length; 88 } 89 90 /* 3. setup iso_packet_descriptor */ 91 if (usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS) { 92 ssize_t len = 0; 93 94 iso_buffer = usbip_alloc_iso_desc_pdu(urb, &len); 95 if (!iso_buffer) { 96 usbip_event_add(&vdev->ud, 97 SDEV_EVENT_ERROR_MALLOC); 98 return -1; 99 } 100 101 iov[2].iov_base = iso_buffer; 102 iov[2].iov_len = len; 103 txsize += len; 104 } 105 106 ret = kernel_sendmsg(vdev->ud.tcp_socket, &msg, iov, 3, txsize); 107 if (ret != txsize) { 108 pr_err("sendmsg failed!, ret=%d for %zd\n", ret, 109 txsize); 110 kfree(iso_buffer); 111 usbip_event_add(&vdev->ud, VDEV_EVENT_ERROR_TCP); 112 return -1; 113 } 114 115 kfree(iso_buffer); 116 usbip_dbg_vhci_tx("send txdata\n"); 117 118 total_size += txsize; 119 } 120 121 return total_size; 122 } 123 124 static struct vhci_unlink *dequeue_from_unlink_tx(struct vhci_device *vdev) 125 { 126 struct vhci_unlink *unlink, *tmp; 127 unsigned long flags; 128 129 spin_lock_irqsave(&vdev->priv_lock, flags); 130 131 list_for_each_entry_safe(unlink, tmp, &vdev->unlink_tx, list) { 132 list_move_tail(&unlink->list, &vdev->unlink_rx); 133 spin_unlock_irqrestore(&vdev->priv_lock, flags); 134 return unlink; 135 } 136 137 spin_unlock_irqrestore(&vdev->priv_lock, flags); 138 139 return NULL; 140 } 141 142 static int vhci_send_cmd_unlink(struct vhci_device *vdev) 143 { 144 struct vhci_unlink *unlink = NULL; 145 146 struct msghdr msg; 147 struct kvec iov[3]; 148 size_t txsize; 149 150 size_t total_size = 0; 151 152 while ((unlink = dequeue_from_unlink_tx(vdev)) != NULL) { 153 int ret; 154 struct usbip_header pdu_header; 155 156 txsize = 0; 157 memset(&pdu_header, 0, sizeof(pdu_header)); 158 memset(&msg, 0, sizeof(msg)); 159 memset(&iov, 0, sizeof(iov)); 160 161 usbip_dbg_vhci_tx("setup cmd unlink, %lu\n", unlink->seqnum); 162 163 /* 1. setup usbip_header */ 164 pdu_header.base.command = USBIP_CMD_UNLINK; 165 pdu_header.base.seqnum = unlink->seqnum; 166 pdu_header.base.devid = vdev->devid; 167 pdu_header.base.ep = 0; 168 pdu_header.u.cmd_unlink.seqnum = unlink->unlink_seqnum; 169 170 usbip_header_correct_endian(&pdu_header, 1); 171 172 iov[0].iov_base = &pdu_header; 173 iov[0].iov_len = sizeof(pdu_header); 174 txsize += sizeof(pdu_header); 175 176 ret = kernel_sendmsg(vdev->ud.tcp_socket, &msg, iov, 1, txsize); 177 if (ret != txsize) { 178 pr_err("sendmsg failed!, ret=%d for %zd\n", ret, 179 txsize); 180 usbip_event_add(&vdev->ud, VDEV_EVENT_ERROR_TCP); 181 return -1; 182 } 183 184 usbip_dbg_vhci_tx("send txdata\n"); 185 186 total_size += txsize; 187 } 188 189 return total_size; 190 } 191 192 int vhci_tx_loop(void *data) 193 { 194 struct usbip_device *ud = data; 195 struct vhci_device *vdev = container_of(ud, struct vhci_device, ud); 196 197 while (!kthread_should_stop()) { 198 if (vhci_send_cmd_submit(vdev) < 0) 199 break; 200 201 if (vhci_send_cmd_unlink(vdev) < 0) 202 break; 203 204 wait_event_interruptible(vdev->waitq_tx, 205 (!list_empty(&vdev->priv_tx) || 206 !list_empty(&vdev->unlink_tx) || 207 kthread_should_stop())); 208 209 usbip_dbg_vhci_tx("pending urbs ?, now wake up\n"); 210 } 211 212 return 0; 213 } 214