1 /* 2 * Copyright (C) 2003-2008 Takahiro Hirofuchi 3 * 4 * This is free software; you can redistribute it and/or modify 5 * it under the terms of the GNU General Public License as published by 6 * the Free Software Foundation; either version 2 of the License, or 7 * (at your option) any later version. 8 * 9 * This is distributed in the hope that it will be useful, 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 * GNU General Public License for more details. 13 * 14 * You should have received a copy of the GNU General Public License 15 * along with this program; if not, write to the Free Software 16 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 17 * USA. 18 */ 19 20 #include <linux/kthread.h> 21 #include <linux/slab.h> 22 23 #include "usbip_common.h" 24 #include "vhci.h" 25 26 /* get URB from transmitted urb queue. caller must hold vdev->priv_lock */ 27 struct urb *pickup_urb_and_free_priv(struct vhci_device *vdev, __u32 seqnum) 28 { 29 struct vhci_priv *priv, *tmp; 30 struct urb *urb = NULL; 31 int status; 32 33 list_for_each_entry_safe(priv, tmp, &vdev->priv_rx, list) { 34 if (priv->seqnum != seqnum) 35 continue; 36 37 urb = priv->urb; 38 status = urb->status; 39 40 usbip_dbg_vhci_rx("find urb %p vurb %p seqnum %u\n", 41 urb, priv, seqnum); 42 43 switch (status) { 44 case -ENOENT: 45 /* fall through */ 46 case -ECONNRESET: 47 dev_info(&urb->dev->dev, 48 "urb %p was unlinked %ssynchronuously.\n", urb, 49 status == -ENOENT ? "" : "a"); 50 break; 51 case -EINPROGRESS: 52 /* no info output */ 53 break; 54 default: 55 dev_info(&urb->dev->dev, 56 "urb %p may be in a error, status %d\n", urb, 57 status); 58 } 59 60 list_del(&priv->list); 61 kfree(priv); 62 urb->hcpriv = NULL; 63 64 break; 65 } 66 67 return urb; 68 } 69 70 static void vhci_recv_ret_submit(struct vhci_device *vdev, 71 struct usbip_header *pdu) 72 { 73 struct usbip_device *ud = &vdev->ud; 74 struct urb *urb; 75 unsigned long flags; 76 77 spin_lock_irqsave(&vdev->priv_lock, flags); 78 urb = pickup_urb_and_free_priv(vdev, pdu->base.seqnum); 79 spin_unlock_irqrestore(&vdev->priv_lock, flags); 80 81 if (!urb) { 82 pr_err("cannot find a urb of seqnum %u\n", pdu->base.seqnum); 83 pr_info("max seqnum %d\n", 84 atomic_read(&the_controller->seqnum)); 85 usbip_event_add(ud, VDEV_EVENT_ERROR_TCP); 86 return; 87 } 88 89 /* unpack the pdu to a urb */ 90 usbip_pack_pdu(pdu, urb, USBIP_RET_SUBMIT, 0); 91 92 /* recv transfer buffer */ 93 if (usbip_recv_xbuff(ud, urb) < 0) 94 return; 95 96 /* recv iso_packet_descriptor */ 97 if (usbip_recv_iso(ud, urb) < 0) 98 return; 99 100 /* restore the padding in iso packets */ 101 usbip_pad_iso(ud, urb); 102 103 if (usbip_dbg_flag_vhci_rx) 104 usbip_dump_urb(urb); 105 106 usbip_dbg_vhci_rx("now giveback urb %p\n", urb); 107 108 spin_lock_irqsave(&the_controller->lock, flags); 109 usb_hcd_unlink_urb_from_ep(vhci_to_hcd(the_controller), urb); 110 spin_unlock_irqrestore(&the_controller->lock, flags); 111 112 usb_hcd_giveback_urb(vhci_to_hcd(the_controller), urb, urb->status); 113 114 usbip_dbg_vhci_rx("Leave\n"); 115 } 116 117 static struct vhci_unlink *dequeue_pending_unlink(struct vhci_device *vdev, 118 struct usbip_header *pdu) 119 { 120 struct vhci_unlink *unlink, *tmp; 121 unsigned long flags; 122 123 spin_lock_irqsave(&vdev->priv_lock, flags); 124 125 list_for_each_entry_safe(unlink, tmp, &vdev->unlink_rx, list) { 126 pr_info("unlink->seqnum %lu\n", unlink->seqnum); 127 if (unlink->seqnum == pdu->base.seqnum) { 128 usbip_dbg_vhci_rx("found pending unlink, %lu\n", 129 unlink->seqnum); 130 list_del(&unlink->list); 131 132 spin_unlock_irqrestore(&vdev->priv_lock, flags); 133 return unlink; 134 } 135 } 136 137 spin_unlock_irqrestore(&vdev->priv_lock, flags); 138 139 return NULL; 140 } 141 142 static void vhci_recv_ret_unlink(struct vhci_device *vdev, 143 struct usbip_header *pdu) 144 { 145 struct vhci_unlink *unlink; 146 struct urb *urb; 147 unsigned long flags; 148 149 usbip_dump_header(pdu); 150 151 unlink = dequeue_pending_unlink(vdev, pdu); 152 if (!unlink) { 153 pr_info("cannot find the pending unlink %u\n", 154 pdu->base.seqnum); 155 return; 156 } 157 158 spin_lock_irqsave(&vdev->priv_lock, flags); 159 urb = pickup_urb_and_free_priv(vdev, unlink->unlink_seqnum); 160 spin_unlock_irqrestore(&vdev->priv_lock, flags); 161 162 if (!urb) { 163 /* 164 * I get the result of a unlink request. But, it seems that I 165 * already received the result of its submit result and gave 166 * back the URB. 167 */ 168 pr_info("the urb (seqnum %d) was already given back\n", 169 pdu->base.seqnum); 170 } else { 171 usbip_dbg_vhci_rx("now giveback urb %p\n", urb); 172 173 /* If unlink is successful, status is -ECONNRESET */ 174 urb->status = pdu->u.ret_unlink.status; 175 pr_info("urb->status %d\n", urb->status); 176 177 spin_lock_irqsave(&the_controller->lock, flags); 178 usb_hcd_unlink_urb_from_ep(vhci_to_hcd(the_controller), urb); 179 spin_unlock_irqrestore(&the_controller->lock, flags); 180 181 usb_hcd_giveback_urb(vhci_to_hcd(the_controller), urb, 182 urb->status); 183 } 184 185 kfree(unlink); 186 } 187 188 static int vhci_priv_tx_empty(struct vhci_device *vdev) 189 { 190 int empty = 0; 191 unsigned long flags; 192 193 spin_lock_irqsave(&vdev->priv_lock, flags); 194 empty = list_empty(&vdev->priv_rx); 195 spin_unlock_irqrestore(&vdev->priv_lock, flags); 196 197 return empty; 198 } 199 200 /* recv a pdu */ 201 static void vhci_rx_pdu(struct usbip_device *ud) 202 { 203 int ret; 204 struct usbip_header pdu; 205 struct vhci_device *vdev = container_of(ud, struct vhci_device, ud); 206 207 usbip_dbg_vhci_rx("Enter\n"); 208 209 memset(&pdu, 0, sizeof(pdu)); 210 211 /* receive a pdu header */ 212 ret = usbip_recv(ud->tcp_socket, &pdu, sizeof(pdu)); 213 if (ret < 0) { 214 if (ret == -ECONNRESET) 215 pr_info("connection reset by peer\n"); 216 else if (ret == -EAGAIN) { 217 /* ignore if connection was idle */ 218 if (vhci_priv_tx_empty(vdev)) 219 return; 220 pr_info("connection timed out with pending urbs\n"); 221 } else if (ret != -ERESTARTSYS) 222 pr_info("xmit failed %d\n", ret); 223 224 usbip_event_add(ud, VDEV_EVENT_ERROR_TCP); 225 return; 226 } 227 if (ret == 0) { 228 pr_info("connection closed"); 229 usbip_event_add(ud, VDEV_EVENT_DOWN); 230 return; 231 } 232 if (ret != sizeof(pdu)) { 233 pr_err("received pdu size is %d, should be %d\n", ret, 234 (unsigned int)sizeof(pdu)); 235 usbip_event_add(ud, VDEV_EVENT_ERROR_TCP); 236 return; 237 } 238 239 usbip_header_correct_endian(&pdu, 0); 240 241 if (usbip_dbg_flag_vhci_rx) 242 usbip_dump_header(&pdu); 243 244 switch (pdu.base.command) { 245 case USBIP_RET_SUBMIT: 246 vhci_recv_ret_submit(vdev, &pdu); 247 break; 248 case USBIP_RET_UNLINK: 249 vhci_recv_ret_unlink(vdev, &pdu); 250 break; 251 default: 252 /* NOT REACHED */ 253 pr_err("unknown pdu %u\n", pdu.base.command); 254 usbip_dump_header(&pdu); 255 usbip_event_add(ud, VDEV_EVENT_ERROR_TCP); 256 break; 257 } 258 } 259 260 int vhci_rx_loop(void *data) 261 { 262 struct usbip_device *ud = data; 263 264 while (!kthread_should_stop()) { 265 if (usbip_event_happened(ud)) 266 break; 267 268 vhci_rx_pdu(ud); 269 } 270 271 return 0; 272 } 273