5 files changed, 29 insertions, 24 deletions

diff --git a/net/sunrpc/cache.c b/net/sunrpc/cache.c
index 00cb388ece03..d96fd466a9a4 100644
--- a/net/sunrpc/cache.c
+++ b/net/sunrpc/cache.c
@@ -284,8 +284,8 @@ static struct file_operations cache_file_operations;
 static struct file_operations content_file_operations;
 static struct file_operations cache_flush_operations;
 
-static void do_cache_clean(void *data);
-static DECLARE_WORK(cache_cleaner, do_cache_clean, NULL);
+static void do_cache_clean(struct work_struct *work);
+static DECLARE_DELAYED_WORK(cache_cleaner, do_cache_clean);
 
 void cache_register(struct cache_detail *cd)
 {
@@ -337,7 +337,7 @@ void cache_register(struct cache_detail *cd)
         spin_unlock(&cache_list_lock);
 
         /* start the cleaning process */
-        schedule_work(&cache_cleaner);
+        schedule_delayed_work(&cache_cleaner, 0);
 }
 
 int cache_unregister(struct cache_detail *cd)
@@ -461,7 +461,7 @@ static int cache_clean(void)
 /*
  * We want to regularly clean the cache, so we need to schedule some work ...
  */
-static void do_cache_clean(void *data)
+static void do_cache_clean(struct work_struct *work)
 {
         int delay = 5;
         if (cache_clean() == -1)
diff --git a/net/sunrpc/rpc_pipe.c b/net/sunrpc/rpc_pipe.c
index 9a0b41a97f90..49dba5febbbd 100644
--- a/net/sunrpc/rpc_pipe.c
+++ b/net/sunrpc/rpc_pipe.c
@@ -54,10 +54,11 @@ static void rpc_purge_list(struct rpc_inode *rpci, struct list_head *head,
 }
 
 static void
-rpc_timeout_upcall_queue(void *data)
+rpc_timeout_upcall_queue(struct work_struct *work)
 {
         LIST_HEAD(free_list);
-        struct rpc_inode *rpci = (struct rpc_inode *)data;
+        struct rpc_inode *rpci =
+                container_of(work, struct rpc_inode, queue_timeout.work);
         struct inode *inode = &rpci->vfs_inode;
         void (*destroy_msg)(struct rpc_pipe_msg *);
 
@@ -837,7 +838,8 @@ init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
                 INIT_LIST_HEAD(&rpci->pipe);
                 rpci->pipelen = 0;
                 init_waitqueue_head(&rpci->waitq);
-                INIT_WORK(&rpci->queue_timeout, rpc_timeout_upcall_queue, rpci);
+                INIT_DELAYED_WORK(&rpci->queue_timeout,
+                                    rpc_timeout_upcall_queue);
                 rpci->ops = NULL;
         }
 }
diff --git a/net/sunrpc/sched.c b/net/sunrpc/sched.c
index f9fd66b1d48b..18a33d327012 100644
--- a/net/sunrpc/sched.c
+++ b/net/sunrpc/sched.c
@@ -41,7 +41,7 @@ static mempool_t	*rpc_buffer_mempool __read_mostly;
 
 static void                     __rpc_default_timer(struct rpc_task *task);
 static void                     rpciod_killall(void);
-static void                     rpc_async_schedule(void *);
+static void                     rpc_async_schedule(struct work_struct *);
 
 /*
  * RPC tasks sit here while waiting for conditions to improve.
@@ -323,7 +323,7 @@ static void rpc_make_runnable(struct rpc_task *task)
         if (RPC_IS_ASYNC(task)) {
                 int status;
 
-                INIT_WORK(&task->u.tk_work, rpc_async_schedule, (void *)task);
+                INIT_WORK(&task->u.tk_work, rpc_async_schedule);
                 status = queue_work(task->tk_workqueue, &task->u.tk_work);
                 if (status < 0) {
                         printk(KERN_WARNING "RPC: failed to add task to queue: error: %d!\n", status);
@@ -729,9 +729,9 @@ rpc_execute(struct rpc_task *task)
         return __rpc_execute(task);
 }
 
-static void rpc_async_schedule(void *arg)
+static void rpc_async_schedule(struct work_struct *work)
 {
-        __rpc_execute((struct rpc_task *)arg);
+        __rpc_execute(container_of(work, struct rpc_task, u.tk_work));
 }
 
 /**
diff --git a/net/sunrpc/xprt.c b/net/sunrpc/xprt.c
index f8ca0a93454c..7a3999f0a4a2 100644
--- a/net/sunrpc/xprt.c
+++ b/net/sunrpc/xprt.c
@@ -477,9 +477,10 @@ int xprt_adjust_timeout(struct rpc_rqst *req)
         return status;
 }
 
-static void xprt_autoclose(void *args)
+static void xprt_autoclose(struct work_struct *work)
 {
-        struct rpc_xprt *xprt = (struct rpc_xprt *)args;
+        struct rpc_xprt *xprt =
+                container_of(work, struct rpc_xprt, task_cleanup);
 
         xprt_disconnect(xprt);
         xprt->ops->close(xprt);
@@ -916,7 +917,7 @@ struct rpc_xprt *xprt_create_transport(int proto, struct sockaddr *ap, size_t si
 
         INIT_LIST_HEAD(&xprt->free);
         INIT_LIST_HEAD(&xprt->recv);
-        INIT_WORK(&xprt->task_cleanup, xprt_autoclose, xprt);
+        INIT_WORK(&xprt->task_cleanup, xprt_autoclose);
         init_timer(&xprt->timer);
         xprt->timer.function = xprt_init_autodisconnect;
         xprt->timer.data = (unsigned long) xprt;
diff --git a/net/sunrpc/xprtsock.c b/net/sunrpc/xprtsock.c
index 21438d7dc47b..3bb232eb5d90 100644
--- a/net/sunrpc/xprtsock.c
+++ b/net/sunrpc/xprtsock.c
@@ -235,7 +235,7 @@ struct sock_xprt {
         /*
          * Connection of transports
          */
-        struct work_struct      connect_worker;
+        struct delayed_work     connect_worker;
         unsigned short          port;
 
         /*
@@ -1175,13 +1175,14 @@ static int xs_bindresvport(struct sock_xprt *transport, struct socket *sock)
 
 /**
  * xs_udp_connect_worker - set up a UDP socket
- * @args: RPC transport to connect
+ * @work: RPC transport to connect
  *
  * Invoked by a work queue tasklet.
  */
-static void xs_udp_connect_worker(void *args)
+static void xs_udp_connect_worker(struct work_struct *work)
 {
-        struct sock_xprt *transport = (struct sock_xprt *)args;
+        struct sock_xprt *transport =
+                container_of(work, struct sock_xprt, connect_worker.work);
         struct rpc_xprt *xprt = &transport->xprt;
         struct socket *sock = transport->sock;
         int err, status = -EIO;
@@ -1260,13 +1261,14 @@ static void xs_tcp_reuse_connection(struct rpc_xprt *xprt)
 
 /**
  * xs_tcp_connect_worker - connect a TCP socket to a remote endpoint
- * @args: RPC transport to connect
+ * @work: RPC transport to connect
  *
  * Invoked by a work queue tasklet.
  */
-static void xs_tcp_connect_worker(void *args)
+static void xs_tcp_connect_worker(struct work_struct *work)
 {
-        struct sock_xprt *transport = (struct sock_xprt *)args;
+        struct sock_xprt *transport =
+                container_of(work, struct sock_xprt, connect_worker.work);
         struct rpc_xprt *xprt = &transport->xprt;
         struct socket *sock = transport->sock;
         int err, status = -EIO;
@@ -1380,7 +1382,7 @@ static void xs_connect(struct rpc_task *task)
                         xprt->reestablish_timeout = XS_TCP_MAX_REEST_TO;
         } else {
                 dprintk("RPC:      xs_connect scheduled xprt %p\n", xprt);
-                schedule_work(&transport->connect_worker);
+                schedule_delayed_work(&transport->connect_worker, 0);
 
                 /* flush_scheduled_work can sleep... */
                 if (!RPC_IS_ASYNC(task))
@@ -1525,7 +1527,7 @@ struct rpc_xprt *xs_setup_udp(struct sockaddr *addr, size_t addrlen, struct rpc_
         /* XXX: header size can vary due to auth type, IPv6, etc. */
         xprt->max_payload = (1U << 16) - (MAX_HEADER << 3);
 
-        INIT_WORK(&transport->connect_worker, xs_udp_connect_worker, transport);
+        INIT_DELAYED_WORK(&transport->connect_worker, xs_udp_connect_worker);
         xprt->bind_timeout = XS_BIND_TO;
         xprt->connect_timeout = XS_UDP_CONN_TO;
         xprt->reestablish_timeout = XS_UDP_REEST_TO;
@@ -1569,7 +1571,7 @@ struct rpc_xprt *xs_setup_tcp(struct sockaddr *addr, size_t addrlen, struct rpc_
         xprt->tsh_size = sizeof(rpc_fraghdr) / sizeof(u32);
         xprt->max_payload = RPC_MAX_FRAGMENT_SIZE;
 
-        INIT_WORK(&transport->connect_worker, xs_tcp_connect_worker, transport);
+        INIT_DELAYED_WORK(&transport->connect_worker, xs_tcp_connect_worker);
         xprt->bind_timeout = XS_BIND_TO;
         xprt->connect_timeout = XS_TCP_CONN_TO;
         xprt->reestablish_timeout = XS_TCP_INIT_REEST_TO;