korg/linux
0
0
Fork 0
mirror of https://mirrors.bfsu.edu.cn/git/linux.git synced 2024-11-14 15:54:15 +08:00
Code Issues Packages Projects Releases Wiki Activity

staging/usbip: convert to kthread

Browse Source 
usbip has its own infrastructure for managing kernel
threads, similar to kthread. By changing it to use
the standard functions, we can simplify the code
and get rid of one of the last BKL users at the
same time.

Includes changes suggested by Max Vozeler.

Signed-off-by: Arnd Bergmann <arnd@arndb.de>
Cc: Greg Kroah-Hartman <gregkh@suse.de>
Cc: Takahiro Hirofuchi <hirofuchi@users.sourceforge.net>
Cc: Max Vozeler <max@vozeler.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
This commit is contained in:
Arnd Bergmann 2011-03-02 00:13:05 +01:00 committed by Greg Kroah-Hartman
parent 8c81161615
commit 9720b4bc76
13 changed files with 64 additions and 203 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
drivers/staging/usbip/Kconfig
View File

@ -1,6 +1,6 @@
config USB_IP_COMMON
tristate "USB IP support (EXPERIMENTAL)"
depends on USB && NET && EXPERIMENTAL && BKL
depends on USB && NET && EXPERIMENTAL
default N
---help---
This enables pushing USB packets over IP to allow remote

4
drivers/staging/usbip/stub.h
View File

@ -95,13 +95,13 @@ extern struct kmem_cache *stub_priv_cache;
/* stub_tx.c */
void stub_complete(struct urb *);
void stub_tx_loop(struct usbip_task *);
int stub_tx_loop(void *data);
/* stub_dev.c */
extern struct usb_driver stub_driver;
/* stub_rx.c */
void stub_rx_loop(struct usbip_task *);
int stub_rx_loop(void *data);
void stub_enqueue_ret_unlink(struct stub_device *, __u32, __u32);
/* stub_main.c */

12
drivers/staging/usbip/stub_dev.c
View File

@ -18,6 +18,7 @@
*/
#include <linux/slab.h>
#include <linux/kthread.h>
#include "usbip_common.h"
#include "stub.h"
@ -138,7 +139,8 @@ static ssize_t store_sockfd(struct device *dev, struct device_attribute *attr,
spin_unlock(&sdev->ud.lock);
usbip_start_threads(&sdev->ud);
sdev->ud.tcp_rx = kthread_run(stub_rx_loop, &sdev->ud, "stub_rx");
sdev->ud.tcp_tx = kthread_run(stub_tx_loop, &sdev->ud, "stub_tx");
spin_lock(&sdev->ud.lock);
sdev->ud.status = SDEV_ST_USED;
@ -218,7 +220,8 @@ static void stub_shutdown_connection(struct usbip_device *ud)
}
/* 1. stop threads */
usbip_stop_threads(ud);
kthread_stop(ud->tcp_rx);
kthread_stop(ud->tcp_tx);
/* 2. close the socket */
/*
@ -336,9 +339,6 @@ static struct stub_device *stub_device_alloc(struct usb_device *udev,
*/
sdev->devid = (busnum << 16) | devnum;
usbip_task_init(&sdev->ud.tcp_rx, "stub_rx", stub_rx_loop);
usbip_task_init(&sdev->ud.tcp_tx, "stub_tx", stub_tx_loop);
sdev->ud.side = USBIP_STUB;
sdev->ud.status = SDEV_ST_AVAILABLE;
/* sdev->ud.lock = SPIN_LOCK_UNLOCKED; */
@ -543,7 +543,7 @@ static void stub_disconnect(struct usb_interface *interface)
stub_remove_files(&interface->dev);
/*If usb reset called from event handler*/
if (busid_priv->sdev->ud.eh.thread == current) {
if (busid_priv->sdev->ud.eh == current) {
busid_priv->interf_count--;
return;
}

13
drivers/staging/usbip/stub_rx.c
View File

@ -18,6 +18,7 @@
*/
#include <linux/slab.h>
#include <linux/kthread.h>
#include "usbip_common.h"
#include "stub.h"
@ -616,19 +617,15 @@ static void stub_rx_pdu(struct usbip_device *ud)
}
void stub_rx_loop(struct usbip_task *ut)
int stub_rx_loop(void *data)
{
struct usbip_device *ud = container_of(ut, struct usbip_device, tcp_rx);
while (1) {
if (signal_pending(current)) {
usbip_dbg_stub_rx("signal caught!\n");
break;
}
struct usbip_device *ud = data;
while (!kthread_should_stop()) {
if (usbip_event_happened(ud))
break;
stub_rx_pdu(ud);
}
return 0;
}

17
drivers/staging/usbip/stub_tx.c
View File

@ -18,6 +18,7 @@
*/
#include <linux/slab.h>
#include <linux/kthread.h>
#include "usbip_common.h"
#include "stub.h"
@ -333,17 +334,12 @@ static int stub_send_ret_unlink(struct stub_device *sdev)
/*-------------------------------------------------------------------------*/
void stub_tx_loop(struct usbip_task *ut)
int stub_tx_loop(void *data)
{
struct usbip_device *ud = container_of(ut, struct usbip_device, tcp_tx);
struct usbip_device *ud = data;
struct stub_device *sdev = container_of(ud, struct stub_device, ud);
while (1) {
if (signal_pending(current)) {
usbip_dbg_stub_tx("signal catched\n");
break;
}
while (!kthread_should_stop()) {
if (usbip_event_happened(ud))
break;
@ -369,6 +365,9 @@ void stub_tx_loop(struct usbip_task *ut)
wait_event_interruptible(sdev->tx_waitq,
(!list_empty(&sdev->priv_tx) ||
!list_empty(&sdev->unlink_tx)));
!list_empty(&sdev->unlink_tx) ||
kthread_should_stop()));
}
return 0;
}

105
drivers/staging/usbip/usbip_common.c
View File

@ -18,7 +18,6 @@
*/
#include <linux/kernel.h>
#include <linux/smp_lock.h>
#include <linux/file.h>
#include <linux/tcp.h>
#include <linux/in.h>
@ -349,110 +348,6 @@ void usbip_dump_header(struct usbip_header *pdu)
}
EXPORT_SYMBOL_GPL(usbip_dump_header);
/*-------------------------------------------------------------------------*/
/* thread routines */
int usbip_thread(void *param)
{
struct usbip_task *ut = param;
if (!ut)
return -EINVAL;
lock_kernel();
daemonize(ut->name);
allow_signal(SIGKILL);
ut->thread = current;
unlock_kernel();
/* srv.rb must wait for rx_thread starting */
complete(&ut->thread_done);
/* start of while loop */
ut->loop_ops(ut);
/* end of loop */
ut->thread = NULL;
complete_and_exit(&ut->thread_done, 0);
}
static void stop_rx_thread(struct usbip_device *ud)
{
if (ud->tcp_rx.thread != NULL) {
send_sig(SIGKILL, ud->tcp_rx.thread, 1);
wait_for_completion(&ud->tcp_rx.thread_done);
usbip_udbg("rx_thread for ud %p has finished\n", ud);
}
}
static void stop_tx_thread(struct usbip_device *ud)
{
if (ud->tcp_tx.thread != NULL) {
send_sig(SIGKILL, ud->tcp_tx.thread, 1);
wait_for_completion(&ud->tcp_tx.thread_done);
usbip_udbg("tx_thread for ud %p has finished\n", ud);
}
}
int usbip_start_threads(struct usbip_device *ud)
{
/*
* threads are invoked per one device (per one connection).
*/
struct task_struct *th;
int err = 0;
th = kthread_run(usbip_thread, (void *)&ud->tcp_rx, "usbip");
if (IS_ERR(th)) {
printk(KERN_WARNING
"Unable to start control thread\n");
err = PTR_ERR(th);
goto ust_exit;
}
th = kthread_run(usbip_thread, (void *)&ud->tcp_tx, "usbip");
if (IS_ERR(th)) {
printk(KERN_WARNING
"Unable to start control thread\n");
err = PTR_ERR(th);
goto tx_thread_err;
}
/* confirm threads are starting */
wait_for_completion(&ud->tcp_rx.thread_done);
wait_for_completion(&ud->tcp_tx.thread_done);
return 0;
tx_thread_err:
stop_rx_thread(ud);
ust_exit:
return err;
}
EXPORT_SYMBOL_GPL(usbip_start_threads);
void usbip_stop_threads(struct usbip_device *ud)
{
/* kill threads related to this sdev, if v.c. exists */
stop_rx_thread(ud);
stop_tx_thread(ud);
}
EXPORT_SYMBOL_GPL(usbip_stop_threads);
void usbip_task_init(struct usbip_task *ut, char *name,
void (*loop_ops)(struct usbip_task *))
{
ut->thread = NULL;
init_completion(&ut->thread_done);
ut->name = name;
ut->loop_ops = loop_ops;
}
EXPORT_SYMBOL_GPL(usbip_task_init);
/*-------------------------------------------------------------------------*/
/* socket routines */

20
drivers/staging/usbip/usbip_common.h
View File

@ -307,13 +307,6 @@ void usbip_dump_header(struct usbip_header *pdu);
struct usbip_device;
struct usbip_task {
struct task_struct *thread;
struct completion thread_done;
char *name;
void (*loop_ops)(struct usbip_task *);
};
enum usbip_side {
USBIP_VHCI,
USBIP_STUB,
@ -346,8 +339,8 @@ struct usbip_device {
struct socket *tcp_socket;
struct usbip_task tcp_rx;
struct usbip_task tcp_tx;
struct task_struct *tcp_rx;
struct task_struct *tcp_tx;
/* event handler */
#define USBIP_EH_SHUTDOWN (1 << 0)
@ -367,7 +360,7 @@ struct usbip_device {
#define VDEV_EVENT_ERROR_MALLOC (USBIP_EH_SHUTDOWN | USBIP_EH_UNUSABLE)
unsigned long event;
struct usbip_task eh;
struct task_struct *eh;
wait_queue_head_t eh_waitq;
struct eh_ops {
@ -378,13 +371,6 @@ struct usbip_device {
};
void usbip_task_init(struct usbip_task *ut, char *,
void (*loop_ops)(struct usbip_task *));
int usbip_start_threads(struct usbip_device *ud);
void usbip_stop_threads(struct usbip_device *ud);
int usbip_thread(void *param);
void usbip_pack_pdu(struct usbip_header *pdu, struct urb *urb, int cmd,
int pack);

38
drivers/staging/usbip/usbip_event.c
View File

@ -62,55 +62,43 @@ static int event_handler(struct usbip_device *ud)
return 0;
}
static void event_handler_loop(struct usbip_task *ut)
static int event_handler_loop(void *data)
{
struct usbip_device *ud = container_of(ut, struct usbip_device, eh);
struct usbip_device *ud = data;
while (1) {
if (signal_pending(current)) {
usbip_dbg_eh("signal catched!\n");
break;
}
while (!kthread_should_stop()) {
wait_event_interruptible(ud->eh_waitq,
usbip_event_happened(ud) ||
kthread_should_stop());
usbip_dbg_eh("wakeup\n");
if (event_handler(ud) < 0)
break;
wait_event_interruptible(ud->eh_waitq,
usbip_event_happened(ud));
usbip_dbg_eh("wakeup\n");
}
return 0;
}
int usbip_start_eh(struct usbip_device *ud)
{
struct usbip_task *eh = &ud->eh;
struct task_struct *th;
init_waitqueue_head(&ud->eh_waitq);
ud->event = 0;
usbip_task_init(eh, "usbip_eh", event_handler_loop);
th = kthread_run(usbip_thread, (void *)eh, "usbip");
if (IS_ERR(th)) {
ud->eh = kthread_run(event_handler_loop, ud, "usbip_eh");
if (IS_ERR(ud->eh)) {
printk(KERN_WARNING
"Unable to start control thread\n");
return PTR_ERR(th);
return PTR_ERR(ud->eh);
}
wait_for_completion(&eh->thread_done);
return 0;
}
EXPORT_SYMBOL_GPL(usbip_start_eh);
void usbip_stop_eh(struct usbip_device *ud)
{
struct usbip_task *eh = &ud->eh;
if (eh->thread == current)
if (ud->eh == current)
return; /* do not wait for myself */
wait_for_completion(&eh->thread_done);
kthread_stop(ud->eh);
usbip_dbg_eh("usbip_eh has finished\n");
}
EXPORT_SYMBOL_GPL(usbip_stop_eh);

4
drivers/staging/usbip/vhci.h
View File

@ -113,8 +113,8 @@ extern struct attribute_group dev_attr_group;
/* vhci_hcd.c */
void rh_port_connect(int rhport, enum usb_device_speed speed);
void rh_port_disconnect(int rhport);
void vhci_rx_loop(struct usbip_task *ut);
void vhci_tx_loop(struct usbip_task *ut);
int vhci_rx_loop(void *data);
int vhci_tx_loop(void *data);
struct urb *pickup_urb_and_free_priv(struct vhci_device *vdev,
__u32 seqnum);

10
drivers/staging/usbip/vhci_hcd.c
View File

@ -18,6 +18,7 @@
*/
#include <linux/slab.h>
#include <linux/kthread.h>
#include "usbip_common.h"
#include "vhci.h"
@ -874,7 +875,10 @@ static void vhci_shutdown_connection(struct usbip_device *ud)
kernel_sock_shutdown(ud->tcp_socket, SHUT_RDWR);
}
usbip_stop_threads(&vdev->ud);
/* kill threads related to this sdev, if v.c. exists */
kthread_stop(vdev->ud.tcp_rx);
kthread_stop(vdev->ud.tcp_tx);
usbip_uinfo("stop threads\n");
/* active connection is closed */
@ -945,8 +949,8 @@ static void vhci_device_init(struct vhci_device *vdev)
{
memset(vdev, 0, sizeof(*vdev));
usbip_task_init(&vdev->ud.tcp_rx, "vhci_rx", vhci_rx_loop);
usbip_task_init(&vdev->ud.tcp_tx, "vhci_tx", vhci_tx_loop);
vdev->ud.tcp_rx = kthread_create(vhci_rx_loop, &vdev->ud, "vhci_rx");
vdev->ud.tcp_tx = kthread_create(vhci_tx_loop, &vdev->ud, "vhci_tx");
vdev->ud.side = USBIP_VHCI;
vdev->ud.status = VDEV_ST_NULL;

16
drivers/staging/usbip/vhci_rx.c
View File

@ -18,6 +18,7 @@
*/
#include <linux/slab.h>
#include <linux/kthread.h>
#include "usbip_common.h"
#include "vhci.h"
@ -269,22 +270,17 @@ static void vhci_rx_pdu(struct usbip_device *ud)
/*-------------------------------------------------------------------------*/
void vhci_rx_loop(struct usbip_task *ut)
int vhci_rx_loop(void *data)
{
struct usbip_device *ud = container_of(ut, struct usbip_device, tcp_rx);
while (1) {
if (signal_pending(current)) {
usbip_dbg_vhci_rx("signal catched!\n");
break;
}
struct usbip_device *ud = data;
while (!kthread_should_stop()) {
if (usbip_event_happened(ud))
break;
vhci_rx_pdu(ud);
}
}
return 0;
}

9
drivers/staging/usbip/vhci_sysfs.c
View File

@ -220,16 +220,13 @@ static ssize_t store_attach(struct device *dev, struct device_attribute *attr,
vdev->ud.tcp_socket = socket;
vdev->ud.status = VDEV_ST_NOTASSIGNED;
wake_up_process(vdev->ud.tcp_rx);
wake_up_process(vdev->ud.tcp_tx);
spin_unlock(&vdev->ud.lock);
spin_unlock(&the_controller->lock);
/* end the lock */
/*
* this function will sleep, so should be out of the lock. but, it's ok
* because we already marked vdev as being used. really?
*/
usbip_start_threads(&vdev->ud);
rh_port_connect(rhport, speed);
return count;

17
drivers/staging/usbip/vhci_tx.c
View File

@ -18,6 +18,7 @@
*/
#include <linux/slab.h>
#include <linux/kthread.h>
#include "usbip_common.h"
#include "vhci.h"
@ -215,17 +216,12 @@ static int vhci_send_cmd_unlink(struct vhci_device *vdev)
/*-------------------------------------------------------------------------*/
void vhci_tx_loop(struct usbip_task *ut)
int vhci_tx_loop(void *data)
{
struct usbip_device *ud = container_of(ut, struct usbip_device, tcp_tx);
struct usbip_device *ud = data;
struct vhci_device *vdev = container_of(ud, struct vhci_device, ud);
while (1) {
if (signal_pending(current)) {
usbip_uinfo("vhci_tx signal catched\n");
break;
}
while (!kthread_should_stop()) {
if (vhci_send_cmd_submit(vdev) < 0)
break;
@ -234,8 +230,11 @@ void vhci_tx_loop(struct usbip_task *ut)
wait_event_interruptible(vdev->waitq_tx,
(!list_empty(&vdev->priv_tx) ||
!list_empty(&vdev->unlink_tx)));
!list_empty(&vdev->unlink_tx) ||
kthread_should_stop()));
usbip_dbg_vhci_tx("pending urbs ?, now wake up\n");
}
return 0;
}