/* * The stalled endpoint is specified in the wIndex value. The endpoint * of the urb is the target of this clear_halt request (i.e., control * endpoint).
*/
target_endp = le16_to_cpu(req->wIndex) & 0x000f;
/* the stalled endpoint direction is IN or OUT?. USB_DIR_IN is 0x80. */
target_dir = le16_to_cpu(req->wIndex) & 0x0080;
elseif (is_reset_device_cmd(urb))
err = tweak_reset_device_cmd(urb); else {
usbip_dbg_stub_rx("no need to tweak\n"); return 0;
}
return !err;
}
/* * stub_recv_unlink() unlinks the URB by a call to usb_unlink_urb(). * By unlinking the urb asynchronously, stub_rx can continuously * process coming urbs. Even if the urb is unlinked, its completion * handler will be called and stub_tx will send a return pdu. * * See also comments about unlinking strategy in vhci_hcd.c.
*/ staticint stub_recv_cmd_unlink(struct stub_device *sdev, struct usbip_header *pdu)
{ int ret, i; unsignedlong flags; struct stub_priv *priv;
spin_lock_irqsave(&sdev->priv_lock, flags);
list_for_each_entry(priv, &sdev->priv_init, list) { if (priv->seqnum != pdu->u.cmd_unlink.seqnum) continue;
/* * This matched urb is not completed yet (i.e., be in * flight in usb hcd hardware/driver). Now we are * cancelling it. The unlinking flag means that we are * now not going to return the normal result pdu of a * submission request, but going to return a result pdu * of the unlink request.
*/
priv->unlinking = 1;
/* * In the case that unlinking flag is on, prev->seqnum * is changed from the seqnum of the cancelling urb to * the seqnum of the unlink request. This will be used * to make the result pdu of the unlink request.
*/
priv->seqnum = pdu->base.seqnum;
spin_unlock_irqrestore(&sdev->priv_lock, flags);
/* * usb_unlink_urb() is now out of spinlocking to avoid * spinlock recursion since stub_complete() is * sometimes called in this context but not in the * interrupt context. If stub_complete() is executed * before we call usb_unlink_urb(), usb_unlink_urb() * will return an error value. In this case, stub_tx * will return the result pdu of this unlink request * though submission is completed and actual unlinking * is not executed. OK?
*/ /* In the above case, urb->status is not -ECONNRESET, * so a driver in a client host will know the failure * of the unlink request ?
*/ for (i = priv->completed_urbs; i < priv->num_urbs; i++) {
ret = usb_unlink_urb(priv->urbs[i]); if (ret != -EINPROGRESS)
dev_err(&priv->urbs[i]->dev->dev, "failed to unlink %d/%d urb of seqnum %lu, ret %d\n",
i + 1, priv->num_urbs,
priv->seqnum, ret);
} return 0;
}
usbip_dbg_stub_rx("seqnum %u is not pending\n",
pdu->u.cmd_unlink.seqnum);
/* * The urb of the unlink target is not found in priv_init queue. It was * already completed and its results is/was going to be sent by a * CMD_RET pdu. In this case, usb_unlink_urb() is not needed. We only * return the completeness of this unlink request to vhci_hcd.
*/
stub_enqueue_ret_unlink(sdev, pdu->base.seqnum, 0);
/* enforce simple/standard policy */
allowed = (URB_NO_TRANSFER_DMA_MAP | URB_NO_INTERRUPT |
URB_DIR_MASK | URB_FREE_BUFFER); switch (xfertype) { case USB_ENDPOINT_XFER_BULK: if (is_out)
allowed |= URB_ZERO_PACKET;
fallthrough; default: /* all non-iso endpoints */ if (!is_out)
allowed |= URB_SHORT_NOT_OK; break; case USB_ENDPOINT_XFER_ISOC:
allowed |= URB_ISO_ASAP; break;
}
urb->transfer_flags &= allowed;
}
staticint stub_recv_xbuff(struct usbip_device *ud, struct stub_priv *priv)
{ int ret; int i;
for (i = 0; i < priv->num_urbs; i++) {
ret = usbip_recv_xbuff(ud, priv->urbs[i]); if (ret < 0) break;
}
return ret;
}
staticvoid stub_recv_cmd_submit(struct stub_device *sdev, struct usbip_header *pdu)
{ struct stub_priv *priv; struct usbip_device *ud = &sdev->ud; struct usb_device *udev = sdev->udev; struct scatterlist *sgl = NULL, *sg; void *buffer = NULL; unsignedlonglong buf_len; int nents; int num_urbs = 1; int pipe = get_pipe(sdev, pdu); int use_sg = pdu->u.cmd_submit.transfer_flags & USBIP_URB_DMA_MAP_SG; int support_sg = 1; int np = 0; int ret, i; int is_tweaked;
if (pipe == -1) return;
/* * Smatch reported the error case where use_sg is true and buf_len is 0. * In this case, It adds SDEV_EVENT_ERROR_MALLOC and stub_priv will be * released by stub event handler and connection will be shut down.
*/
priv = stub_priv_alloc(sdev, pdu); if (!priv) return;
if (use_sg && !buf_len) {
dev_err(&udev->dev, "sg buffer with zero length\n"); goto err_malloc;
}
/* allocate urb transfer buffer, if needed */ if (buf_len) { if (use_sg) {
sgl = sgl_alloc(buf_len, GFP_KERNEL, &nents); if (!sgl) goto err_malloc;
/* Check if the server's HCD supports SG */ if (!udev->bus->sg_tablesize) { /* * If the server's HCD doesn't support SG, break * a single SG request into several URBs and map * each SG list entry to corresponding URB * buffer. The previously allocated SG list is * stored in priv->sgl (If the server's HCD * support SG, SG list is stored only in * urb->sg) and it is used as an indicator that * the server split single SG request into * several URBs. Later, priv->sgl is used by * stub_complete() and stub_send_ret_submit() to * reassemble the divied URBs.
*/
support_sg = 0;
num_urbs = nents;
priv->completed_urbs = 0;
pdu->u.cmd_submit.transfer_flags &=
~USBIP_URB_DMA_MAP_SG;
}
} else {
buffer = kzalloc(buf_len, GFP_KERNEL); if (!buffer) goto err_malloc;
}
}
usbip_pack_pdu(pdu, priv->urbs[0], USBIP_CMD_SUBMIT, 0);
} else {
for_each_sg(sgl, sg, nents, i) {
priv->urbs[i] = usb_alloc_urb(0, GFP_KERNEL); /* The URBs which is previously allocated will be freed * in stub_device_cleanup_urbs() if error occurs.
*/ if (!priv->urbs[i]) goto err_urb;
for (i = 0; i < num_urbs; i++) { /* set other members from the base header of pdu */
priv->urbs[i]->context = (void *) priv;
priv->urbs[i]->dev = udev;
priv->urbs[i]->pipe = pipe;
priv->urbs[i]->complete = stub_complete;
/* * all URBs belong to a single PDU, so a global is_tweaked flag is * enough
*/
is_tweaked = tweak_special_requests(priv->urbs[i]);
masking_bogus_flags(priv->urbs[i]);
}
if (stub_recv_xbuff(ud, priv) < 0) return;
if (usbip_recv_iso(ud, priv->urbs[0]) < 0) return;
/* urb is now ready to submit */ for (i = 0; i < priv->num_urbs; i++) { if (!is_tweaked) {
ret = usb_submit_urb(priv->urbs[i], GFP_KERNEL);
/* * Pessimistic. * This connection will be discarded.
*/
usbip_event_add(ud, SDEV_EVENT_ERROR_SUBMIT); break;
}
} else { /* * An identical URB was already submitted in * tweak_special_requests(). Skip submitting this URB to not * duplicate the request.
*/
priv->urbs[i]->status = 0;
stub_complete(priv->urbs[i]);
}
}
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.
