2 * Copyright (C) 2003-2008 Takahiro Hirofuchi
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.
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.
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,
20 #include <linux/kthread.h>
21 #include <linux/socket.h>
23 #include "usbip_common.h"
26 static void stub_free_priv_and_urb(struct stub_priv
*priv
)
28 struct urb
*urb
= priv
->urb
;
30 kfree(urb
->setup_packet
);
31 kfree(urb
->transfer_buffer
);
32 list_del(&priv
->list
);
33 kmem_cache_free(stub_priv_cache
, priv
);
37 /* be in spin_lock_irqsave(&sdev->priv_lock, flags) */
38 void stub_enqueue_ret_unlink(struct stub_device
*sdev
, __u32 seqnum
,
41 struct stub_unlink
*unlink
;
43 unlink
= kzalloc(sizeof(struct stub_unlink
), GFP_ATOMIC
);
45 usbip_event_add(&sdev
->ud
, VDEV_EVENT_ERROR_MALLOC
);
49 unlink
->seqnum
= seqnum
;
50 unlink
->status
= status
;
52 list_add_tail(&unlink
->list
, &sdev
->unlink_tx
);
56 * stub_complete - completion handler of a usbip urb
57 * @urb: pointer to the urb completed
59 * When a urb has completed, the USB core driver calls this function mostly in
60 * the interrupt context. To return the result of a urb, the completed urb is
61 * linked to the pending list of returning.
64 void stub_complete(struct urb
*urb
)
66 struct stub_priv
*priv
= (struct stub_priv
*) urb
->context
;
67 struct stub_device
*sdev
= priv
->sdev
;
70 usbip_dbg_stub_tx("complete! status %d\n", urb
->status
);
72 switch (urb
->status
) {
77 dev_info(&urb
->dev
->dev
, "stopped by a call to usb_kill_urb() "
78 "because of cleaning up a virtual connection\n");
81 dev_info(&urb
->dev
->dev
, "unlinked by a call to "
82 "usb_unlink_urb()\n");
85 dev_info(&urb
->dev
->dev
, "endpoint %d is stalled\n",
86 usb_pipeendpoint(urb
->pipe
));
89 dev_info(&urb
->dev
->dev
, "device removed?\n");
92 dev_info(&urb
->dev
->dev
, "urb completion with non-zero status "
97 /* link a urb to the queue of tx. */
98 spin_lock_irqsave(&sdev
->priv_lock
, flags
);
99 if (priv
->unlinking
) {
100 stub_enqueue_ret_unlink(sdev
, priv
->seqnum
, urb
->status
);
101 stub_free_priv_and_urb(priv
);
103 list_move_tail(&priv
->list
, &sdev
->priv_tx
);
105 spin_unlock_irqrestore(&sdev
->priv_lock
, flags
);
107 /* wake up tx_thread */
108 wake_up(&sdev
->tx_waitq
);
111 static inline void setup_base_pdu(struct usbip_header_basic
*base
,
112 __u32 command
, __u32 seqnum
)
114 base
->command
= command
;
115 base
->seqnum
= seqnum
;
121 static void setup_ret_submit_pdu(struct usbip_header
*rpdu
, struct urb
*urb
)
123 struct stub_priv
*priv
= (struct stub_priv
*) urb
->context
;
125 setup_base_pdu(&rpdu
->base
, USBIP_RET_SUBMIT
, priv
->seqnum
);
126 usbip_pack_pdu(rpdu
, urb
, USBIP_RET_SUBMIT
, 1);
129 static void setup_ret_unlink_pdu(struct usbip_header
*rpdu
,
130 struct stub_unlink
*unlink
)
132 setup_base_pdu(&rpdu
->base
, USBIP_RET_UNLINK
, unlink
->seqnum
);
133 rpdu
->u
.ret_unlink
.status
= unlink
->status
;
136 static struct stub_priv
*dequeue_from_priv_tx(struct stub_device
*sdev
)
139 struct stub_priv
*priv
, *tmp
;
141 spin_lock_irqsave(&sdev
->priv_lock
, flags
);
143 list_for_each_entry_safe(priv
, tmp
, &sdev
->priv_tx
, list
) {
144 list_move_tail(&priv
->list
, &sdev
->priv_free
);
145 spin_unlock_irqrestore(&sdev
->priv_lock
, flags
);
149 spin_unlock_irqrestore(&sdev
->priv_lock
, flags
);
154 static int stub_send_ret_submit(struct stub_device
*sdev
)
157 struct stub_priv
*priv
, *tmp
;
162 size_t total_size
= 0;
164 while ((priv
= dequeue_from_priv_tx(sdev
)) != NULL
) {
166 struct urb
*urb
= priv
->urb
;
167 struct usbip_header pdu_header
;
168 struct usbip_iso_packet_descriptor
*iso_buffer
= NULL
;
169 struct kvec
*iov
= NULL
;
173 memset(&pdu_header
, 0, sizeof(pdu_header
));
174 memset(&msg
, 0, sizeof(msg
));
176 if (usb_pipetype(urb
->pipe
) == PIPE_ISOCHRONOUS
)
177 iovnum
= 2 + urb
->number_of_packets
;
181 iov
= kzalloc(iovnum
* sizeof(struct kvec
), GFP_KERNEL
);
184 usbip_event_add(&sdev
->ud
, SDEV_EVENT_ERROR_MALLOC
);
190 /* 1. setup usbip_header */
191 setup_ret_submit_pdu(&pdu_header
, urb
);
192 usbip_dbg_stub_tx("setup txdata seqnum: %d urb: %p\n",
193 pdu_header
.base
.seqnum
, urb
);
194 usbip_header_correct_endian(&pdu_header
, 1);
196 iov
[iovnum
].iov_base
= &pdu_header
;
197 iov
[iovnum
].iov_len
= sizeof(pdu_header
);
199 txsize
+= sizeof(pdu_header
);
201 /* 2. setup transfer buffer */
202 if (usb_pipein(urb
->pipe
) &&
203 usb_pipetype(urb
->pipe
) != PIPE_ISOCHRONOUS
&&
204 urb
->actual_length
> 0) {
205 iov
[iovnum
].iov_base
= urb
->transfer_buffer
;
206 iov
[iovnum
].iov_len
= urb
->actual_length
;
208 txsize
+= urb
->actual_length
;
209 } else if (usb_pipein(urb
->pipe
) &&
210 usb_pipetype(urb
->pipe
) == PIPE_ISOCHRONOUS
) {
212 * For isochronous packets: actual length is the sum of
213 * the actual length of the individual, packets, but as
214 * the packet offsets are not changed there will be
215 * padding between the packets. To optimally use the
216 * bandwidth the padding is not transmitted.
220 for (i
= 0; i
< urb
->number_of_packets
; i
++) {
221 iov
[iovnum
].iov_base
= urb
->transfer_buffer
+
222 urb
->iso_frame_desc
[i
].offset
;
223 iov
[iovnum
].iov_len
=
224 urb
->iso_frame_desc
[i
].actual_length
;
226 txsize
+= urb
->iso_frame_desc
[i
].actual_length
;
229 if (txsize
!= sizeof(pdu_header
) + urb
->actual_length
) {
230 dev_err(&sdev
->interface
->dev
,
231 "actual length of urb %d does not "
232 "match iso packet sizes %zu\n",
234 txsize
-sizeof(pdu_header
));
236 usbip_event_add(&sdev
->ud
,
237 SDEV_EVENT_ERROR_TCP
);
242 /* 3. setup iso_packet_descriptor */
243 if (usb_pipetype(urb
->pipe
) == PIPE_ISOCHRONOUS
) {
246 iso_buffer
= usbip_alloc_iso_desc_pdu(urb
, &len
);
248 usbip_event_add(&sdev
->ud
,
249 SDEV_EVENT_ERROR_MALLOC
);
254 iov
[iovnum
].iov_base
= iso_buffer
;
255 iov
[iovnum
].iov_len
= len
;
260 ret
= kernel_sendmsg(sdev
->ud
.tcp_socket
, &msg
,
261 iov
, iovnum
, txsize
);
263 dev_err(&sdev
->interface
->dev
,
264 "sendmsg failed!, retval %d for %zd\n",
268 usbip_event_add(&sdev
->ud
, SDEV_EVENT_ERROR_TCP
);
275 total_size
+= txsize
;
278 spin_lock_irqsave(&sdev
->priv_lock
, flags
);
279 list_for_each_entry_safe(priv
, tmp
, &sdev
->priv_free
, list
) {
280 stub_free_priv_and_urb(priv
);
282 spin_unlock_irqrestore(&sdev
->priv_lock
, flags
);
287 static struct stub_unlink
*dequeue_from_unlink_tx(struct stub_device
*sdev
)
290 struct stub_unlink
*unlink
, *tmp
;
292 spin_lock_irqsave(&sdev
->priv_lock
, flags
);
294 list_for_each_entry_safe(unlink
, tmp
, &sdev
->unlink_tx
, list
) {
295 list_move_tail(&unlink
->list
, &sdev
->unlink_free
);
296 spin_unlock_irqrestore(&sdev
->priv_lock
, flags
);
300 spin_unlock_irqrestore(&sdev
->priv_lock
, flags
);
305 static int stub_send_ret_unlink(struct stub_device
*sdev
)
308 struct stub_unlink
*unlink
, *tmp
;
314 size_t total_size
= 0;
316 while ((unlink
= dequeue_from_unlink_tx(sdev
)) != NULL
) {
318 struct usbip_header pdu_header
;
321 memset(&pdu_header
, 0, sizeof(pdu_header
));
322 memset(&msg
, 0, sizeof(msg
));
323 memset(&iov
, 0, sizeof(iov
));
325 usbip_dbg_stub_tx("setup ret unlink %lu\n", unlink
->seqnum
);
327 /* 1. setup usbip_header */
328 setup_ret_unlink_pdu(&pdu_header
, unlink
);
329 usbip_header_correct_endian(&pdu_header
, 1);
331 iov
[0].iov_base
= &pdu_header
;
332 iov
[0].iov_len
= sizeof(pdu_header
);
333 txsize
+= sizeof(pdu_header
);
335 ret
= kernel_sendmsg(sdev
->ud
.tcp_socket
, &msg
, iov
,
338 dev_err(&sdev
->interface
->dev
,
339 "sendmsg failed!, retval %d for %zd\n",
341 usbip_event_add(&sdev
->ud
, SDEV_EVENT_ERROR_TCP
);
345 usbip_dbg_stub_tx("send txdata\n");
346 total_size
+= txsize
;
349 spin_lock_irqsave(&sdev
->priv_lock
, flags
);
351 list_for_each_entry_safe(unlink
, tmp
, &sdev
->unlink_free
, list
) {
352 list_del(&unlink
->list
);
356 spin_unlock_irqrestore(&sdev
->priv_lock
, flags
);
361 int stub_tx_loop(void *data
)
363 struct usbip_device
*ud
= data
;
364 struct stub_device
*sdev
= container_of(ud
, struct stub_device
, ud
);
366 while (!kthread_should_stop()) {
367 if (usbip_event_happened(ud
))
371 * send_ret_submit comes earlier than send_ret_unlink. stub_rx
372 * looks at only priv_init queue. If the completion of a URB is
373 * earlier than the receive of CMD_UNLINK, priv is moved to
374 * priv_tx queue and stub_rx does not find the target priv. In
375 * this case, vhci_rx receives the result of the submit request
376 * and then receives the result of the unlink request. The
377 * result of the submit is given back to the usbcore as the
378 * completion of the unlink request. The request of the
379 * unlink is ignored. This is ok because a driver who calls
380 * usb_unlink_urb() understands the unlink was too late by
381 * getting the status of the given-backed URB which has the
382 * status of usb_submit_urb().
384 if (stub_send_ret_submit(sdev
) < 0)
387 if (stub_send_ret_unlink(sdev
) < 0)
390 wait_event_interruptible(sdev
->tx_waitq
,
391 (!list_empty(&sdev
->priv_tx
) ||
392 !list_empty(&sdev
->unlink_tx
) ||
393 kthread_should_stop()));