9p: rework client code to use new protocol support functions

Now that the new protocol functions are in place, this patch switches
the client code to using the new support code.

Signed-off-by: Eric Van Hensbergen <ericvh@gmail.com>

1 files changed, 28 insertions, 34 deletions

diff --git a/net/9p/trans_fd.c b/net/9p/trans_fd.c
index e147ec539585..e8ebe2cb7e8b 100644
--- a/net/9p/trans_fd.c
+++ b/net/9p/trans_fd.c
@@ -181,7 +181,7 @@ static void p9_mux_poll_stop(struct p9_conn *m)
  *
  */
 
-void p9_conn_cancel(struct p9_conn *m, int err)
+static void p9_conn_cancel(struct p9_conn *m, int err)
 {
         struct p9_req_t *req, *rtmp;
         unsigned long flags;
@@ -287,7 +287,7 @@ static void p9_read_work(struct work_struct *work)
         if (m->err < 0)
                 return;
 
-        P9_DPRINTK(P9_DEBUG_MUX, "start mux %p pos %d\n", m, m->rpos);
+        P9_DPRINTK(P9_DEBUG_TRANS, "start mux %p pos %d\n", m, m->rpos);
 
         if (!m->rbuf) {
                 m->rbuf = m->tmp_buf;
@@ -296,11 +296,11 @@ static void p9_read_work(struct work_struct *work)
         }
 
         clear_bit(Rpending, &m->wsched);
-        P9_DPRINTK(P9_DEBUG_MUX, "read mux %p pos %d size: %d = %d\n", m,
+        P9_DPRINTK(P9_DEBUG_TRANS, "read mux %p pos %d size: %d = %d\n", m,
                                         m->rpos, m->rsize, m->rsize-m->rpos);
         err = p9_fd_read(m->client, m->rbuf + m->rpos,
                                                 m->rsize - m->rpos);
-        P9_DPRINTK(P9_DEBUG_MUX, "mux %p got %d bytes\n", m, err);
+        P9_DPRINTK(P9_DEBUG_TRANS, "mux %p got %d bytes\n", m, err);
         if (err == -EAGAIN) {
                 clear_bit(Rworksched, &m->wsched);
                 return;
@@ -313,7 +313,7 @@ static void p9_read_work(struct work_struct *work)
 
         if ((!m->req) && (m->rpos == m->rsize)) { /* header read in */
                 u16 tag;
-                P9_DPRINTK(P9_DEBUG_MUX, "got new header\n");
+                P9_DPRINTK(P9_DEBUG_TRANS, "got new header\n");
 
                 n = le32_to_cpu(*(__le32 *) m->rbuf); /* read packet size */
                 if (n >= m->client->msize) {
@@ -324,8 +324,8 @@ static void p9_read_work(struct work_struct *work)
                 }
 
                 tag = le16_to_cpu(*(__le16 *) (m->rbuf+5)); /* read tag */
-                P9_DPRINTK(P9_DEBUG_MUX, "mux %p pkt: size: %d bytes tag: %d\n",
-                                                                 m, n, tag);
+                P9_DPRINTK(P9_DEBUG_TRANS,
+                        "mux %p pkt: size: %d bytes tag: %d\n", m, n, tag);
 
                 m->req = p9_tag_lookup(m->client, tag);
                 if (!m->req) {
@@ -351,7 +351,7 @@ static void p9_read_work(struct work_struct *work)
 
         /* not an else because some packets (like clunk) have no payload */
         if ((m->req) && (m->rpos == m->rsize)) { /* packet is read in */
-                P9_DPRINTK(P9_DEBUG_MUX, "got new packet\n");
+                P9_DPRINTK(P9_DEBUG_TRANS, "got new packet\n");
 
                 list_del(&m->req->req_list);
                 p9_client_cb(m->client, m->req);
@@ -369,7 +369,7 @@ static void p9_read_work(struct work_struct *work)
                         n = p9_fd_poll(m->client, NULL);
 
                 if (n & POLLIN) {
-                        P9_DPRINTK(P9_DEBUG_MUX, "schedule read work %p\n", m);
+                        P9_DPRINTK(P9_DEBUG_TRANS, "sched read work %p\n", m);
                         queue_work(p9_mux_wq, &m->rq);
                 } else
                         clear_bit(Rworksched, &m->wsched);
@@ -453,11 +453,11 @@ static void p9_write_work(struct work_struct *work)
                 spin_unlock(&m->client->lock);
         }
 
-        P9_DPRINTK(P9_DEBUG_MUX, "mux %p pos %d size %d\n", m, m->wpos,
+        P9_DPRINTK(P9_DEBUG_TRANS, "mux %p pos %d size %d\n", m, m->wpos,
                                                                 m->wsize);
         clear_bit(Wpending, &m->wsched);
         err = p9_fd_write(m->client, m->wbuf + m->wpos, m->wsize - m->wpos);
-        P9_DPRINTK(P9_DEBUG_MUX, "mux %p sent %d bytes\n", m, err);
+        P9_DPRINTK(P9_DEBUG_TRANS, "mux %p sent %d bytes\n", m, err);
         if (err == -EAGAIN) {
                 clear_bit(Wworksched, &m->wsched);
                 return;
@@ -481,7 +481,7 @@ static void p9_write_work(struct work_struct *work)
                         n = p9_fd_poll(m->client, NULL);
 
                 if (n & POLLOUT) {
-                        P9_DPRINTK(P9_DEBUG_MUX, "schedule write work %p\n", m);
+                        P9_DPRINTK(P9_DEBUG_TRANS, "sched write work %p\n", m);
                         queue_work(p9_mux_wq, &m->wq);
                 } else
                         clear_bit(Wworksched, &m->wsched);
@@ -558,7 +558,8 @@ static struct p9_conn *p9_conn_create(struct p9_client *client)
         int n;
         struct p9_conn *m;
 
-        P9_DPRINTK(P9_DEBUG_MUX, "client %p msize %d\n", client, client->msize);
+        P9_DPRINTK(P9_DEBUG_TRANS, "client %p msize %d\n", client,
+                                                                client->msize);
         m = kzalloc(sizeof(struct p9_conn), GFP_KERNEL);
         if (!m)
                 return ERR_PTR(-ENOMEM);
@@ -575,12 +576,12 @@ static struct p9_conn *p9_conn_create(struct p9_client *client)
 
         n = p9_fd_poll(client, &m->pt);
         if (n & POLLIN) {
-                P9_DPRINTK(P9_DEBUG_MUX, "mux %p can read\n", m);
+                P9_DPRINTK(P9_DEBUG_TRANS, "mux %p can read\n", m);
                 set_bit(Rpending, &m->wsched);
         }
 
         if (n & POLLOUT) {
-                P9_DPRINTK(P9_DEBUG_MUX, "mux %p can write\n", m);
+                P9_DPRINTK(P9_DEBUG_TRANS, "mux %p can write\n", m);
                 set_bit(Wpending, &m->wsched);
         }
 
@@ -602,7 +603,7 @@ static void p9_poll_mux(struct p9_conn *m)
 
         n = p9_fd_poll(m->client, NULL);
         if (n < 0 || n & (POLLERR | POLLHUP | POLLNVAL)) {
-                P9_DPRINTK(P9_DEBUG_MUX, "error mux %p err %d\n", m, n);
+                P9_DPRINTK(P9_DEBUG_TRANS, "error mux %p err %d\n", m, n);
                 if (n >= 0)
                         n = -ECONNRESET;
                 p9_conn_cancel(m, n);
@@ -610,19 +611,19 @@ static void p9_poll_mux(struct p9_conn *m)
 
         if (n & POLLIN) {
                 set_bit(Rpending, &m->wsched);
-                P9_DPRINTK(P9_DEBUG_MUX, "mux %p can read\n", m);
+                P9_DPRINTK(P9_DEBUG_TRANS, "mux %p can read\n", m);
                 if (!test_and_set_bit(Rworksched, &m->wsched)) {
-                        P9_DPRINTK(P9_DEBUG_MUX, "schedule read work %p\n", m);
+                        P9_DPRINTK(P9_DEBUG_TRANS, "sched read work %p\n", m);
                         queue_work(p9_mux_wq, &m->rq);
                 }
         }
 
         if (n & POLLOUT) {
                 set_bit(Wpending, &m->wsched);
-                P9_DPRINTK(P9_DEBUG_MUX, "mux %p can write\n", m);
+                P9_DPRINTK(P9_DEBUG_TRANS, "mux %p can write\n", m);
                 if ((m->wsize || !list_empty(&m->unsent_req_list))
                     && !test_and_set_bit(Wworksched, &m->wsched)) {
-                        P9_DPRINTK(P9_DEBUG_MUX, "schedule write work %p\n", m);
+                        P9_DPRINTK(P9_DEBUG_TRANS, "sched write work %p\n", m);
                         queue_work(p9_mux_wq, &m->wq);
                 }
         }
@@ -645,8 +646,8 @@ static int p9_fd_request(struct p9_client *client, struct p9_req_t *req)
         struct p9_trans_fd *ts = client->trans;
         struct p9_conn *m = ts->conn;
 
-        P9_DPRINTK(P9_DEBUG_MUX, "mux %p task %p tcall %p id %d\n", m, current,
-                req->tc, req->tc->id);
+        P9_DPRINTK(P9_DEBUG_TRANS, "mux %p task %p tcall %p id %d\n", m,
+                                                current, req->tc, req->tc->id);
         if (m->err < 0)
                 return m->err;
 
@@ -672,19 +673,12 @@ static int p9_fd_cancel(struct p9_client *client, struct p9_req_t *req)
         struct p9_trans_fd *ts = client->trans;
         struct p9_conn *m = ts->conn;
 
-        P9_DPRINTK(P9_DEBUG_MUX, "mux %p req %p\n", m, req);
+        P9_DPRINTK(P9_DEBUG_TRANS, "mux %p req %p\n", m, req);
 
         spin_lock(&client->lock);
         list_del(&req->req_list);
         spin_unlock(&client->lock);
 
-        /* if a response was received for a request, do nothing */
-        if (req->rc || req->t_err) {
-                P9_DPRINTK(P9_DEBUG_MUX,
-                        "mux %p req %p response already received\n", m, req);
-                return 0;
-        }
-
         if (req->status == REQ_STATUS_UNSENT) {
                 req->status = REQ_STATUS_FLSHD;
                 return 0;
@@ -809,7 +803,7 @@ static int p9_socket_open(struct p9_client *client, struct socket *csocket)
 
 static void p9_conn_destroy(struct p9_conn *m)
 {
-        P9_DPRINTK(P9_DEBUG_MUX, "mux %p prev %p next %p\n", m,
+        P9_DPRINTK(P9_DEBUG_TRANS, "mux %p prev %p next %p\n", m,
                 m->mux_list.prev, m->mux_list.next);
 
         p9_mux_poll_stop(m);
@@ -1060,7 +1054,7 @@ static int p9_poll_proc(void *a)
 {
         unsigned long flags;
 
-        P9_DPRINTK(P9_DEBUG_MUX, "start %p\n", current);
+        P9_DPRINTK(P9_DEBUG_TRANS, "start %p\n", current);
  repeat:
         spin_lock_irqsave(&p9_poll_lock, flags);
         while (!list_empty(&p9_poll_pending_list)) {
@@ -1078,7 +1072,7 @@ static int p9_poll_proc(void *a)
 
         set_current_state(TASK_INTERRUPTIBLE);
         if (list_empty(&p9_poll_pending_list)) {
-                P9_DPRINTK(P9_DEBUG_MUX, "sleeping...\n");
+                P9_DPRINTK(P9_DEBUG_TRANS, "sleeping...\n");
                 schedule();
         }
         __set_current_state(TASK_RUNNING);
@@ -1086,7 +1080,7 @@ static int p9_poll_proc(void *a)
         if (!kthread_should_stop())
                 goto repeat;
 
-        P9_DPRINTK(P9_DEBUG_MUX, "finish\n");
+        P9_DPRINTK(P9_DEBUG_TRANS, "finish\n");
         return 0;
 }