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 usbip_dbg_vhci_rx("now giveback urb %u\n", pdu->base.seqnum); 94 95 spin_lock_irqsave(&vhci->lock, flags); 96 usb_hcd_unlink_urb_from_ep(vhci_hcd_to_hcd(vhci_hcd), urb); 97 spin_unlock_irqrestore(&vhci->lock, flags); 98 99 usb_hcd_giveback_urb(vhci_hcd_to_hcd(vhci_hcd), urb, urb->status); 100 101 usbip_dbg_vhci_rx("Leave\n"); 102 } 103 104 static struct vhci_unlink *dequeue_pending_unlink(struct vhci_device *vdev, 105 struct usbip_header *pdu) 106 { 107 struct vhci_unlink *unlink, *tmp; 108 unsigned long flags; 109 110 spin_lock_irqsave(&vdev->priv_lock, flags); 111 112 list_for_each_entry_safe(unlink, tmp, &vdev->unlink_rx, list) { 113 pr_info("unlink->seqnum %lu\n", unlink->seqnum); 114 if (unlink->seqnum == pdu->base.seqnum) { 115 usbip_dbg_vhci_rx("found pending unlink, %lu\n", 116 unlink->seqnum); 117 list_del(&unlink->list); 118 119 spin_unlock_irqrestore(&vdev->priv_lock, flags); 120 return unlink; 121 } 122 } 123 124 spin_unlock_irqrestore(&vdev->priv_lock, flags); 125 126 return NULL; 127 } 128 129 static void vhci_recv_ret_unlink(struct vhci_device *vdev, 130 struct usbip_header *pdu) 131 { 132 struct vhci_hcd *vhci_hcd = vdev_to_vhci_hcd(vdev); 133 struct vhci *vhci = vhci_hcd->vhci; 134 struct vhci_unlink *unlink; 135 struct urb *urb; 136 unsigned long flags; 137 138 usbip_dump_header(pdu); 139 140 unlink = dequeue_pending_unlink(vdev, pdu); 141 if (!unlink) { 142 pr_info("cannot find the pending unlink %u\n", 143 pdu->base.seqnum); 144 return; 145 } 146 147 spin_lock_irqsave(&vdev->priv_lock, flags); 148 urb = pickup_urb_and_free_priv(vdev, unlink->unlink_seqnum); 149 spin_unlock_irqrestore(&vdev->priv_lock, flags); 150 151 if (!urb) { 152 /* 153 * I get the result of a unlink request. But, it seems that I 154 * already received the result of its submit result and gave 155 * back the URB. 156 */ 157 pr_info("the urb (seqnum %d) was already given back\n", 158 pdu->base.seqnum); 159 } else { 160 usbip_dbg_vhci_rx("now giveback urb %d\n", pdu->base.seqnum); 161 162 /* If unlink is successful, status is -ECONNRESET */ 163 urb->status = pdu->u.ret_unlink.status; 164 pr_info("urb->status %d\n", urb->status); 165 166 spin_lock_irqsave(&vhci->lock, flags); 167 usb_hcd_unlink_urb_from_ep(vhci_hcd_to_hcd(vhci_hcd), urb); 168 spin_unlock_irqrestore(&vhci->lock, flags); 169 170 usb_hcd_giveback_urb(vhci_hcd_to_hcd(vhci_hcd), urb, urb->status); 171 } 172 173 kfree(unlink); 174 } 175 176 static int vhci_priv_tx_empty(struct vhci_device *vdev) 177 { 178 int empty = 0; 179 unsigned long flags; 180 181 spin_lock_irqsave(&vdev->priv_lock, flags); 182 empty = list_empty(&vdev->priv_rx); 183 spin_unlock_irqrestore(&vdev->priv_lock, flags); 184 185 return empty; 186 } 187 188 /* recv a pdu */ 189 static void vhci_rx_pdu(struct usbip_device *ud) 190 { 191 int ret; 192 struct usbip_header pdu; 193 struct vhci_device *vdev = container_of(ud, struct vhci_device, ud); 194 195 usbip_dbg_vhci_rx("Enter\n"); 196 197 memset(&pdu, 0, sizeof(pdu)); 198 199 /* receive a pdu header */ 200 ret = usbip_recv(ud->tcp_socket, &pdu, sizeof(pdu)); 201 if (ret < 0) { 202 if (ret == -ECONNRESET) 203 pr_info("connection reset by peer\n"); 204 else if (ret == -EAGAIN) { 205 /* ignore if connection was idle */ 206 if (vhci_priv_tx_empty(vdev)) 207 return; 208 pr_info("connection timed out with pending urbs\n"); 209 } else if (ret != -ERESTARTSYS) 210 pr_info("xmit failed %d\n", ret); 211 212 usbip_event_add(ud, VDEV_EVENT_ERROR_TCP); 213 return; 214 } 215 if (ret == 0) { 216 pr_info("connection closed"); 217 usbip_event_add(ud, VDEV_EVENT_DOWN); 218 return; 219 } 220 if (ret != sizeof(pdu)) { 221 pr_err("received pdu size is %d, should be %d\n", ret, 222 (unsigned int)sizeof(pdu)); 223 usbip_event_add(ud, VDEV_EVENT_ERROR_TCP); 224 return; 225 } 226 227 usbip_header_correct_endian(&pdu, 0); 228 229 if (usbip_dbg_flag_vhci_rx) 230 usbip_dump_header(&pdu); 231 232 switch (pdu.base.command) { 233 case USBIP_RET_SUBMIT: 234 vhci_recv_ret_submit(vdev, &pdu); 235 break; 236 case USBIP_RET_UNLINK: 237 vhci_recv_ret_unlink(vdev, &pdu); 238 break; 239 default: 240 /* NOT REACHED */ 241 pr_err("unknown pdu %u\n", pdu.base.command); 242 usbip_dump_header(&pdu); 243 usbip_event_add(ud, VDEV_EVENT_ERROR_TCP); 244 break; 245 } 246 } 247 248 int vhci_rx_loop(void *data) 249 { 250 struct usbip_device *ud = data; 251 252 while (!kthread_should_stop()) { 253 if (usbip_event_happened(ud)) 254 break; 255 256 vhci_rx_pdu(ud); 257 } 258 259 return 0; 260 } 261