[MAC80211]: improve radiotap injection

[safe/jmp/linux-2.6] / net / sunrpc / xprt.c

diff --git a/net/sunrpc/xprt.c b/net/sunrpc/xprt.c
index e7c71a1..c8c2edc 100644 (file)
--- a/net/sunrpc/xprt.c
+++ b/net/sunrpc/xprt.c
@@ -108,7 +108,7 @@ int xprt_reserve_xprt(struct rpc_task *task)
        return 1;
 
 out_sleep:
-       dprintk("RPC: %4d failed to lock transport %p\n",
+       dprintk("RPC: %5u failed to lock transport %p\n",
                        task->tk_pid, xprt);
        task->tk_timeout = 0;
        task->tk_status = -EAGAIN;
@@ -127,7 +127,7 @@ static void xprt_clear_locked(struct rpc_xprt *xprt)
                clear_bit(XPRT_LOCKED, &xprt->state);
                smp_mb__after_clear_bit();
        } else
-               schedule_work(&xprt->task_cleanup);
+               queue_work(rpciod_workqueue, &xprt->task_cleanup);
 }
 
 /*
@@ -158,7 +158,7 @@ int xprt_reserve_xprt_cong(struct rpc_task *task)
        }
        xprt_clear_locked(xprt);
 out_sleep:
-       dprintk("RPC: %4d failed to lock transport %p\n", task->tk_pid, xprt);
+       dprintk("RPC: %5u failed to lock transport %p\n", task->tk_pid, xprt);
        task->tk_timeout = 0;
        task->tk_status = -EAGAIN;
        if (req && req->rq_ntrans)
@@ -281,7 +281,7 @@ __xprt_get_cong(struct rpc_xprt *xprt, struct rpc_task *task)
 
        if (req->rq_cong)
                return 1;
-       dprintk("RPC: %4d xprt_cwnd_limited cong = %ld cwnd = %ld\n",
+       dprintk("RPC: %5u xprt_cwnd_limited cong = %lu cwnd = %lu\n",
                        task->tk_pid, xprt->cong, xprt->cwnd);
        if (RPCXPRT_CONGESTED(xprt))
                return 0;
@@ -340,7 +340,7 @@ void xprt_adjust_cwnd(struct rpc_task *task, int result)
                if (cwnd < RPC_CWNDSCALE)
                        cwnd = RPC_CWNDSCALE;
        }
-       dprintk("RPC:      cong %ld, cwnd was %ld, now %ld\n",
+       dprintk("RPC:       cong %ld, cwnd was %ld, now %ld\n",
                        xprt->cong, xprt->cwnd, cwnd);
        xprt->cwnd = cwnd;
        __xprt_put_cong(xprt, req);
@@ -387,8 +387,8 @@ void xprt_write_space(struct rpc_xprt *xprt)
 
        spin_lock_bh(&xprt->transport_lock);
        if (xprt->snd_task) {
-               dprintk("RPC:      write space: waking waiting task on xprt %p\n",
-                               xprt);
+               dprintk("RPC:       write space: waking waiting task on "
+                               "xprt %p\n", xprt);
                rpc_wake_up_task(xprt->snd_task);
        }
        spin_unlock_bh(&xprt->transport_lock);
@@ -494,7 +494,7 @@ static void xprt_autoclose(struct work_struct *work)
  */
 void xprt_disconnect(struct rpc_xprt *xprt)
 {
-       dprintk("RPC:      disconnected transport %p\n", xprt);
+       dprintk("RPC:       disconnected transport %p\n", xprt);
        spin_lock_bh(&xprt->transport_lock);
        xprt_clear_connected(xprt);
        xprt_wake_pending_tasks(xprt, -ENOTCONN);
@@ -515,7 +515,7 @@ xprt_init_autodisconnect(unsigned long data)
        if (xprt_connecting(xprt))
                xprt_release_write(xprt, NULL);
        else
-               schedule_work(&xprt->task_cleanup);
+               queue_work(rpciod_workqueue, &xprt->task_cleanup);
        return;
 out_abort:
        spin_unlock(&xprt->transport_lock);
@@ -530,7 +530,7 @@ void xprt_connect(struct rpc_task *task)
 {
        struct rpc_xprt *xprt = task->tk_xprt;
 
-       dprintk("RPC: %4d xprt_connect xprt %p %s connected\n", task->tk_pid,
+       dprintk("RPC: %5u xprt_connect xprt %p %s connected\n", task->tk_pid,
                        xprt, (xprt_connected(xprt) ? "is" : "is not"));
 
        if (!xprt_bound(xprt)) {
@@ -560,7 +560,7 @@ static void xprt_connect_status(struct rpc_task *task)
        if (task->tk_status >= 0) {
                xprt->stat.connect_count++;
                xprt->stat.connect_time += (long)jiffies - xprt->stat.connect_start;
-               dprintk("RPC: %4d xprt_connect_status: connection established\n",
+               dprintk("RPC: %5u xprt_connect_status: connection established\n",
                                task->tk_pid);
                return;
        }
@@ -568,20 +568,22 @@ static void xprt_connect_status(struct rpc_task *task)
        switch (task->tk_status) {
        case -ECONNREFUSED:
        case -ECONNRESET:
-               dprintk("RPC: %4d xprt_connect_status: server %s refused connection\n",
-                               task->tk_pid, task->tk_client->cl_server);
+               dprintk("RPC: %5u xprt_connect_status: server %s refused "
+                               "connection\n", task->tk_pid,
+                               task->tk_client->cl_server);
                break;
        case -ENOTCONN:
-               dprintk("RPC: %4d xprt_connect_status: connection broken\n",
+               dprintk("RPC: %5u xprt_connect_status: connection broken\n",
                                task->tk_pid);
                break;
        case -ETIMEDOUT:
-               dprintk("RPC: %4d xprt_connect_status: connect attempt timed out\n",
-                               task->tk_pid);
+               dprintk("RPC: %5u xprt_connect_status: connect attempt timed "
+                               "out\n", task->tk_pid);
                break;
        default:
-               dprintk("RPC: %4d xprt_connect_status: error %d connecting to server %s\n",
-                               task->tk_pid, -task->tk_status, task->tk_client->cl_server);
+               dprintk("RPC: %5u xprt_connect_status: error %d connecting to "
+                               "server %s\n", task->tk_pid, -task->tk_status,
+                               task->tk_client->cl_server);
                xprt_release_write(xprt, task);
                task->tk_status = -EIO;
        }
@@ -602,6 +604,9 @@ struct rpc_rqst *xprt_lookup_rqst(struct rpc_xprt *xprt, __be32 xid)
                if (entry->rq_xid == xid)
                        return entry;
        }
+
+       dprintk("RPC:       xprt_lookup_rqst did not find xid %08x\n",
+                       ntohl(xid));
        xprt->stat.bad_xids++;
        return NULL;
 }
@@ -654,7 +659,7 @@ static void xprt_timer(struct rpc_task *task)
        struct rpc_rqst *req = task->tk_rqstp;
        struct rpc_xprt *xprt = req->rq_xprt;
 
-       dprintk("RPC: %4d xprt_timer\n", task->tk_pid);
+       dprintk("RPC: %5u xprt_timer\n", task->tk_pid);
 
        spin_lock(&xprt->transport_lock);
        if (!req->rq_received) {
@@ -678,7 +683,7 @@ int xprt_prepare_transmit(struct rpc_task *task)
        struct rpc_xprt *xprt = req->rq_xprt;
        int err = 0;
 
-       dprintk("RPC: %4d xprt_prepare_transmit\n", task->tk_pid);
+       dprintk("RPC: %5u xprt_prepare_transmit\n", task->tk_pid);
 
        spin_lock_bh(&xprt->transport_lock);
        if (req->rq_received && !req->rq_bytes_sent) {
@@ -716,7 +721,7 @@ void xprt_transmit(struct rpc_task *task)
        struct rpc_xprt *xprt = req->rq_xprt;
        int status;
 
-       dprintk("RPC: %4d xprt_transmit(%u)\n", task->tk_pid, req->rq_slen);
+       dprintk("RPC: %5u xprt_transmit(%u)\n", task->tk_pid, req->rq_slen);
 
        if (!req->rq_received) {
                if (list_empty(&req->rq_list)) {
@@ -736,7 +741,7 @@ void xprt_transmit(struct rpc_task *task)
 
        status = xprt->ops->send_request(task);
        if (status == 0) {
-               dprintk("RPC: %4d xmit complete\n", task->tk_pid);
+               dprintk("RPC: %5u xmit complete\n", task->tk_pid);
                spin_lock_bh(&xprt->transport_lock);
 
                xprt->ops->set_retrans_timeout(task);
@@ -777,7 +782,7 @@ static inline void do_xprt_reserve(struct rpc_task *task)
                xprt_request_init(task, xprt);
                return;
        }
-       dprintk("RPC:      waiting for request slot\n");
+       dprintk("RPC:       waiting for request slot\n");
        task->tk_status = -EAGAIN;
        task->tk_timeout = 0;
        rpc_sleep_on(&xprt->backlog, task, NULL, NULL);
@@ -818,11 +823,10 @@ static void xprt_request_init(struct rpc_task *task, struct rpc_xprt *xprt)
        req->rq_task    = task;
        req->rq_xprt    = xprt;
        req->rq_buffer  = NULL;
-       req->rq_bufsize = 0;
        req->rq_xid     = xprt_alloc_xid(xprt);
        req->rq_release_snd_buf = NULL;
        xprt_reset_majortimeo(req);
-       dprintk("RPC: %4d reserved req %p xid %08x\n", task->tk_pid,
+       dprintk("RPC: %5u reserved req %p xid %08x\n", task->tk_pid,
                        req, ntohl(req->rq_xid));
 }
 
@@ -850,13 +854,13 @@ void xprt_release(struct rpc_task *task)
                mod_timer(&xprt->timer,
                                xprt->last_used + xprt->idle_timeout);
        spin_unlock_bh(&xprt->transport_lock);
-       xprt->ops->buf_free(task);
+       xprt->ops->buf_free(req->rq_buffer);
        task->tk_rqstp = NULL;
        if (req->rq_release_snd_buf)
                req->rq_release_snd_buf(req);
        memset(req, 0, sizeof(*req));   /* mark unused */
 
-       dprintk("RPC: %4d release request %p\n", task->tk_pid, req);
+       dprintk("RPC: %5u release request %p\n", task->tk_pid, req);
 
        spin_lock(&xprt->reserve_lock);
        list_add(&req->rq_list, &xprt->free);
@@ -882,31 +886,28 @@ void xprt_set_timeout(struct rpc_timeout *to, unsigned int retr, unsigned long i
 
 /**
  * xprt_create_transport - create an RPC transport
- * @proto: requested transport protocol
- * @ap: remote peer address
- * @size: length of address
- * @to: timeout parameters
+ * @args: rpc transport creation arguments
  *
  */
-struct rpc_xprt *xprt_create_transport(int proto, struct sockaddr *ap, size_t size, struct rpc_timeout *to)
+struct rpc_xprt *xprt_create_transport(struct rpc_xprtsock_create *args)
 {
        struct rpc_xprt *xprt;
        struct rpc_rqst *req;
 
-       switch (proto) {
+       switch (args->proto) {
        case IPPROTO_UDP:
-               xprt = xs_setup_udp(ap, size, to);
+               xprt = xs_setup_udp(args);
                break;
        case IPPROTO_TCP:
-               xprt = xs_setup_tcp(ap, size, to);
+               xprt = xs_setup_tcp(args);
                break;
        default:
                printk(KERN_ERR "RPC: unrecognized transport protocol: %d\n",
-                               proto);
+                               args->proto);
                return ERR_PTR(-EIO);
        }
        if (IS_ERR(xprt)) {
-               dprintk("RPC:      xprt_create_transport: failed, %ld\n",
+               dprintk("RPC:       xprt_create_transport: failed, %ld\n",
                                -PTR_ERR(xprt));
                return xprt;
        }
@@ -923,6 +924,7 @@ struct rpc_xprt *xprt_create_transport(int proto, struct sockaddr *ap, size_t si
        xprt->timer.data = (unsigned long) xprt;
        xprt->last_used = jiffies;
        xprt->cwnd = RPC_INITCWND;
+       xprt->bind_index = 0;
 
        rpc_init_wait_queue(&xprt->binding, "xprt_binding");
        rpc_init_wait_queue(&xprt->pending, "xprt_pending");
@@ -936,7 +938,7 @@ struct rpc_xprt *xprt_create_transport(int proto, struct sockaddr *ap, size_t si
 
        xprt_init_xid(xprt);
 
-       dprintk("RPC:      created transport %p with %u slots\n", xprt,
+       dprintk("RPC:       created transport %p with %u slots\n", xprt,
                        xprt->max_reqs);
 
        return xprt;
@@ -951,7 +953,7 @@ static void xprt_destroy(struct kref *kref)
 {
        struct rpc_xprt *xprt = container_of(kref, struct rpc_xprt, kref);
 
-       dprintk("RPC:      destroying transport %p\n", xprt);
+       dprintk("RPC:       destroying transport %p\n", xprt);
        xprt->shutdown = 1;
        del_timer_sync(&xprt->timer);