{
        if (list_empty(&task->u.tk_wait.timer_list))
                return;
-       dprintk("RPC: %5u disabling timer\n", task->tk_pid);
        task->tk_timeout = 0;
        list_del(&task->u.tk_wait.timer_list);
        if (list_empty(&queue->timer_list.list))
 __rpc_add_timer(struct rpc_wait_queue *queue, struct rpc_task *task,
                unsigned long timeout)
 {
-       dprintk("RPC: %5u setting alarm for %u ms\n",
-               task->tk_pid, jiffies_to_msecs(timeout - jiffies));
-
        task->tk_timeout = timeout;
        if (list_empty(&queue->timer_list.list) || time_before(timeout, queue->timer_list.expires))
                rpc_set_queue_timer(queue, timeout);
        /* barrier matches the read in rpc_wake_up_task_queue_locked() */
        smp_wmb();
        rpc_set_queued(task);
-
-       dprintk("RPC: %5u added to queue %p \"%s\"\n",
-                       task->tk_pid, queue, rpc_qname(queue));
 }
 
 /*
        else
                list_del(&task->u.tk_wait.list);
        queue->qlen--;
-       dprintk("RPC: %5u removed from queue %p \"%s\"\n",
-                       task->tk_pid, queue, rpc_qname(queue));
 }
 
 static void __rpc_init_priority_wait_queue(struct rpc_wait_queue *queue, const char *qname, unsigned char nr_queues)
                struct rpc_task *task,
                unsigned char queue_priority)
 {
-       dprintk("RPC: %5u sleep_on(queue \"%s\" time %lu)\n",
-                       task->tk_pid, rpc_qname(q), jiffies);
-
        trace_rpc_task_sleep(task, q);
 
        __rpc_add_wait_queue(q, task, queue_priority);
-
 }
 
 static void __rpc_sleep_on_priority(struct rpc_wait_queue *q,
                struct rpc_wait_queue *queue,
                struct rpc_task *task)
 {
-       dprintk("RPC: %5u __rpc_wake_up_task (now %lu)\n",
-                       task->tk_pid, jiffies);
-
        /* Has the task been executed yet? If not, we cannot wake it up! */
        if (!RPC_IS_ACTIVATED(task)) {
                printk(KERN_ERR "RPC: Inactive task (%p) being woken up!\n", task);
        __rpc_remove_wait_queue(queue, task);
 
        rpc_make_runnable(wq, task);
-
-       dprintk("RPC:       __rpc_wake_up_task done\n");
 }
 
 /*
 {
        struct rpc_task *task = NULL;
 
-       dprintk("RPC:       wake_up_first(%p \"%s\")\n",
-                       queue, rpc_qname(queue));
        spin_lock(&queue->lock);
        task = __rpc_find_next_queued(queue);
        if (task != NULL)
        list_for_each_entry_safe(task, n, &queue->timer_list.list, u.tk_wait.timer_list) {
                timeo = task->tk_timeout;
                if (time_after_eq(now, timeo)) {
-                       dprintk("RPC: %5u timeout\n", task->tk_pid);
+                       trace_rpc_task_timeout(task, task->tk_action);
                        task->tk_status = -ETIMEDOUT;
                        rpc_wake_up_task_queue_locked(queue, task);
                        continue;