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 /* get URB from transmitted urb queue. caller must hold vdev->priv_lock */ 13 struct urb *pickup_urb_and_free_priv(struct vhci_device *vdev, __u32 seqnum) 14 { 15 struct vhci_priv *priv, *tmp; 16 struct urb *urb = NULL; 17 int status; 18 19 list_for_each_entry_safe(priv, tmp, &vdev->priv_rx, list) { 20 if (priv->seqnum != seqnum) 21 continue; 22 23 urb = priv->urb; 24 status = urb->status; 25 26 usbip_dbg_vhci_rx("find urb seqnum %u\n", seqnum); 27 28 switch (status) { 29 case -ENOENT: 30 /* fall through */ 31 case -ECONNRESET: 32 dev_dbg(&urb->dev->dev, 33 "urb seq# %u was unlinked %ssynchronously\n", 34 seqnum, status == -ENOENT ? "" : "a"); 35 break; 36 case -EINPROGRESS: 37 /* no info output */ 38 break; 39 default: 40 dev_dbg(&urb->dev->dev, 41 "urb seq# %u may be in a error, status %d\n", 42 seqnum, status); 43 } 44 45 list_del(&priv->list); 46 kfree(priv); 47 urb->hcpriv = NULL; 48 49 break; 50 } 51 52 return urb; 53 } 54 55 static void vhci_recv_ret_submit(struct vhci_device *vdev, 56 struct usbip_header *pdu) 57 { 58 struct vhci_hcd *vhci_hcd = vdev_to_vhci_hcd(vdev); 59 struct vhci *vhci = vhci_hcd->vhci; 60 struct usbip_device *ud = &vdev->ud; 61 struct urb *urb; 62 unsigned long flags; 63 64 spin_lock_irqsave(&vdev->priv_lock, flags); 65 urb = pickup_urb_and_free_priv(vdev, pdu->base.seqnum); 66 spin_unlock_irqrestore(&vdev->priv_lock, flags); 67 68 if (!urb) { 69 pr_err("cannot find a urb of seqnum %u max seqnum %d\n", 70 pdu->base.seqnum, 71 atomic_read(&vhci_hcd->seqnum)); 72 usbip_event_add(ud, VDEV_EVENT_ERROR_TCP); 73 return; 74 } 75 76 /* unpack the pdu to a urb */ 77 usbip_pack_pdu(pdu, urb, USBIP_RET_SUBMIT, 0); 78 79 /* recv transfer buffer */ 80 if (usbip_recv_xbuff(ud, urb) < 0) 81 return; 82 83 /* recv iso_packet_descriptor */ 84 if (usbip_recv_iso(ud, urb) < 0) 85 return; 86 87 /* restore the padding in iso packets */ 88 usbip_pad_iso(ud, urb); 89 90 if (usbip_dbg_flag_vhci_rx) 91 usbip_dump_urb(urb); 92 93 if (urb->num_sgs) 94 urb->transfer_flags &= ~URB_DMA_MAP_SG; 95 96 usbip_dbg_vhci_rx("now giveback urb %u\n", pdu->base.seqnum); 97 98 spin_lock_irqsave(&vhci->lock, flags); 99 usb_hcd_unlink_urb_from_ep(vhci_hcd_to_hcd(vhci_hcd), urb); 100 spin_unlock_irqrestore(&vhci->lock, flags); 101 102 usb_hcd_giveback_urb(vhci_hcd_to_hcd(vhci_hcd), urb, urb->status); 103 104 usbip_dbg_vhci_rx("Leave\n"); 105 } 106 107 static struct vhci_unlink *dequeue_pending_unlink(struct vhci_device *vdev, 108 struct usbip_header *pdu) 109 { 110 struct vhci_unlink *unlink, *tmp; 111 unsigned long flags; 112 113 spin_lock_irqsave(&vdev->priv_lock, flags); 114 115 list_for_each_entry_safe(unlink, tmp, &vdev->unlink_rx, list) { 116 pr_info("unlink->seqnum %lu\n", unlink->seqnum); 117 if (unlink->seqnum == pdu->base.seqnum) { 118 usbip_dbg_vhci_rx("found pending unlink, %lu\n", 119 unlink->seqnum); 120 list_del(&unlink->list); 121 122 spin_unlock_irqrestore(&vdev->priv_lock, flags); 123 return unlink; 124 } 125 } 126 127 spin_unlock_irqrestore(&vdev->priv_lock, flags); 128 129 return NULL; 130 } 131 132 static void vhci_recv_ret_unlink(struct vhci_device *vdev, 133 struct usbip_header *pdu) 134 { 135 struct vhci_hcd *vhci_hcd = vdev_to_vhci_hcd(vdev); 136 struct vhci *vhci = vhci_hcd->vhci; 137 struct vhci_unlink *unlink; 138 struct urb *urb; 139 unsigned long flags; 140 141 usbip_dump_header(pdu); 142 143 unlink = dequeue_pending_unlink(vdev, pdu); 144 if (!unlink) { 145 pr_info("cannot find the pending unlink %u\n", 146 pdu->base.seqnum); 147 return; 148 } 149 150 spin_lock_irqsave(&vdev->priv_lock, flags); 151 urb = pickup_urb_and_free_priv(vdev, unlink->unlink_seqnum); 152 spin_unlock_irqrestore(&vdev->priv_lock, flags); 153 154 if (!urb) { 155 /* 156 * I get the result of a unlink request. But, it seems that I 157 * already received the result of its submit result and gave 158 * back the URB. 159 */ 160 pr_info("the urb (seqnum %d) was already given back\n", 161 pdu->base.seqnum); 162 } else { 163 usbip_dbg_vhci_rx("now giveback urb %d\n", pdu->base.seqnum); 164 165 /* If unlink is successful, status is -ECONNRESET */ 166 urb->status = pdu->u.ret_unlink.status; 167 pr_info("urb->status %d\n", urb->status); 168 169 spin_lock_irqsave(&vhci->lock, flags); 170 usb_hcd_unlink_urb_from_ep(vhci_hcd_to_hcd(vhci_hcd), urb); 171 spin_unlock_irqrestore(&vhci->lock, flags); 172 173 usb_hcd_giveback_urb(vhci_hcd_to_hcd(vhci_hcd), urb, urb->status); 174 } 175 176 kfree(unlink); 177 } 178 179 static int vhci_priv_tx_empty(struct vhci_device *vdev) 180 { 181 int empty = 0; 182 unsigned long flags; 183 184 spin_lock_irqsave(&vdev->priv_lock, flags); 185 empty = list_empty(&vdev->priv_rx); 186 spin_unlock_irqrestore(&vdev->priv_lock, flags); 187 188 return empty; 189 } 190 191 /* recv a pdu */ 192 static void vhci_rx_pdu(struct usbip_device *ud) 193 { 194 int ret; 195 struct usbip_header pdu; 196 struct vhci_device *vdev = container_of(ud, struct vhci_device, ud); 197 198 usbip_dbg_vhci_rx("Enter\n"); 199 200 memset(&pdu, 0, sizeof(pdu)); 201 202 /* receive a pdu header */ 203 ret = usbip_recv(ud->tcp_socket, &pdu, sizeof(pdu)); 204 if (ret < 0) { 205 if (ret == -ECONNRESET) 206 pr_info("connection reset by peer\n"); 207 else if (ret == -EAGAIN) { 208 /* ignore if connection was idle */ 209 if (vhci_priv_tx_empty(vdev)) 210 return; 211 pr_info("connection timed out with pending urbs\n"); 212 } else if (ret != -ERESTARTSYS) 213 pr_info("xmit failed %d\n", ret); 214 215 usbip_event_add(ud, VDEV_EVENT_ERROR_TCP); 216 return; 217 } 218 if (ret == 0) { 219 pr_info("connection closed"); 220 usbip_event_add(ud, VDEV_EVENT_DOWN); 221 return; 222 } 223 if (ret != sizeof(pdu)) { 224 pr_err("received pdu size is %d, should be %d\n", ret, 225 (unsigned int)sizeof(pdu)); 226 usbip_event_add(ud, VDEV_EVENT_ERROR_TCP); 227 return; 228 } 229 230 usbip_header_correct_endian(&pdu, 0); 231 232 if (usbip_dbg_flag_vhci_rx) 233 usbip_dump_header(&pdu); 234 235 switch (pdu.base.command) { 236 case USBIP_RET_SUBMIT: 237 vhci_recv_ret_submit(vdev, &pdu); 238 break; 239 case USBIP_RET_UNLINK: 240 vhci_recv_ret_unlink(vdev, &pdu); 241 break; 242 default: 243 /* NOT REACHED */ 244 pr_err("unknown pdu %u\n", pdu.base.command); 245 usbip_dump_header(&pdu); 246 usbip_event_add(ud, VDEV_EVENT_ERROR_TCP); 247 break; 248 } 249 } 250 251 int vhci_rx_loop(void *data) 252 { 253 struct usbip_device *ud = data; 254 255 while (!kthread_should_stop()) { 256 if (usbip_event_happened(ud)) 257 break; 258 259 vhci_rx_pdu(ud); 260 } 261 262 return 0; 263 } 264