[PATCH] v9fs: print 9p messages
[linux-2.6.git] / fs / 9p / mux.c
index 62b6ad0..d16f4f4 100644 (file)
 #include <linux/poll.h>
 #include <linux/kthread.h>
 #include <linux/idr.h>
+#include <linux/mutex.h>
 
 #include "debug.h"
 #include "v9fs.h"
 #include "9p.h"
-#include "transport.h"
 #include "conv.h"
+#include "transport.h"
 #include "mux.h"
 
 #define ERREQFLUSH     1
@@ -69,11 +70,12 @@ struct v9fs_mux_data {
        int msize;
        unsigned char *extended;
        struct v9fs_transport *trans;
-       struct v9fs_idpool tidpool;
+       struct v9fs_idpool tagpool;
        int err;
        wait_queue_head_t equeue;
        struct list_head req_list;
        struct list_head unsent_req_list;
+       struct v9fs_fcall *rcall;
        int rpos;
        char *rbuf;
        int wpos;
@@ -106,15 +108,17 @@ static void v9fs_read_work(void *);
 static void v9fs_write_work(void *);
 static void v9fs_pollwait(struct file *filp, wait_queue_head_t * wait_address,
                          poll_table * p);
+static u16 v9fs_mux_get_tag(struct v9fs_mux_data *);
+static void v9fs_mux_put_tag(struct v9fs_mux_data *, u16);
 
-static DECLARE_MUTEX(v9fs_mux_task_lock);
+static DEFINE_MUTEX(v9fs_mux_task_lock);
 static struct workqueue_struct *v9fs_mux_wq;
 
 static int v9fs_mux_num;
 static int v9fs_mux_poll_task_num;
 static struct v9fs_mux_poll_task v9fs_mux_poll_tasks[100];
 
-void v9fs_mux_global_init(void)
+int v9fs_mux_global_init(void)
 {
        int i;
 
@@ -122,6 +126,10 @@ void v9fs_mux_global_init(void)
                v9fs_mux_poll_tasks[i].task = NULL;
 
        v9fs_mux_wq = create_workqueue("v9fs");
+       if (!v9fs_mux_wq)
+               return -ENOMEM;
+
+       return 0;
 }
 
 void v9fs_mux_global_exit(void)
@@ -135,7 +143,7 @@ void v9fs_mux_global_exit(void)
  *
  * The current implementation returns sqrt of the number of mounts.
  */
-inline int v9fs_mux_calc_poll_procs(int muxnum)
+static int v9fs_mux_calc_poll_procs(int muxnum)
 {
        int n;
 
@@ -151,14 +159,15 @@ inline int v9fs_mux_calc_poll_procs(int muxnum)
        return n;
 }
 
-static void v9fs_mux_poll_start(struct v9fs_mux_data *m)
+static int v9fs_mux_poll_start(struct v9fs_mux_data *m)
 {
        int i, n;
        struct v9fs_mux_poll_task *vpt, *vptlast;
+       struct task_struct *pproc;
 
        dprintk(DEBUG_MUX, "mux %p muxnum %d procnum %d\n", m, v9fs_mux_num,
                v9fs_mux_poll_task_num);
-       up(&v9fs_mux_task_lock);
+       mutex_lock(&v9fs_mux_task_lock);
 
        n = v9fs_mux_calc_poll_procs(v9fs_mux_num + 1);
        if (n > v9fs_mux_poll_task_num) {
@@ -166,12 +175,16 @@ static void v9fs_mux_poll_start(struct v9fs_mux_data *m)
                        if (v9fs_mux_poll_tasks[i].task == NULL) {
                                vpt = &v9fs_mux_poll_tasks[i];
                                dprintk(DEBUG_MUX, "create proc %p\n", vpt);
-                               vpt->task = kthread_create(v9fs_poll_proc,
-                                       vpt, "v9fs-poll");
-                               INIT_LIST_HEAD(&vpt->mux_list);
-                               vpt->muxnum = 0;
-                               v9fs_mux_poll_task_num++;
-                               wake_up_process(vpt->task);
+                               pproc = kthread_create(v9fs_poll_proc, vpt,
+                                                  "v9fs-poll");
+
+                               if (!IS_ERR(pproc)) {
+                                       vpt->task = pproc;
+                                       INIT_LIST_HEAD(&vpt->mux_list);
+                                       vpt->muxnum = 0;
+                                       v9fs_mux_poll_task_num++;
+                                       wake_up_process(vpt->task);
+                               }
                                break;
                        }
                }
@@ -201,16 +214,21 @@ static void v9fs_mux_poll_start(struct v9fs_mux_data *m)
        }
 
        if (i >= ARRAY_SIZE(v9fs_mux_poll_tasks)) {
+               if (vptlast == NULL)
+                       return -ENOMEM;
+
                dprintk(DEBUG_MUX, "put in proc %d\n", i);
                list_add(&m->mux_list, &vptlast->mux_list);
                vptlast->muxnum++;
-               m->poll_task = vpt;
+               m->poll_task = vptlast;
                memset(&m->poll_waddr, 0, sizeof(m->poll_waddr));
                init_poll_funcptr(&m->pt, v9fs_pollwait);
        }
 
        v9fs_mux_num++;
-       down(&v9fs_mux_task_lock);
+       mutex_unlock(&v9fs_mux_task_lock);
+
+       return 0;
 }
 
 static void v9fs_mux_poll_stop(struct v9fs_mux_data *m)
@@ -218,7 +236,7 @@ static void v9fs_mux_poll_stop(struct v9fs_mux_data *m)
        int i;
        struct v9fs_mux_poll_task *vpt;
 
-       up(&v9fs_mux_task_lock);
+       mutex_lock(&v9fs_mux_task_lock);
        vpt = m->poll_task;
        list_del(&m->mux_list);
        for(i = 0; i < ARRAY_SIZE(m->poll_waddr); i++) {
@@ -235,7 +253,7 @@ static void v9fs_mux_poll_stop(struct v9fs_mux_data *m)
                v9fs_mux_poll_task_num--;
        }
        v9fs_mux_num--;
-       down(&v9fs_mux_task_lock);
+       mutex_unlock(&v9fs_mux_task_lock);
 }
 
 /**
@@ -253,7 +271,7 @@ struct v9fs_mux_data *v9fs_mux_init(struct v9fs_transport *trans, int msize,
        struct v9fs_mux_data *m, *mtmp;
 
        dprintk(DEBUG_MUX, "transport %p msize %d\n", trans, msize);
-       m = kmalloc(sizeof(struct v9fs_mux_data) + 2 * msize, GFP_KERNEL);
+       m = kmalloc(sizeof(struct v9fs_mux_data), GFP_KERNEL);
        if (!m)
                return ERR_PTR(-ENOMEM);
 
@@ -262,21 +280,25 @@ struct v9fs_mux_data *v9fs_mux_init(struct v9fs_transport *trans, int msize,
        m->msize = msize;
        m->extended = extended;
        m->trans = trans;
-       idr_init(&m->tidpool.pool);
-       init_MUTEX(&m->tidpool.lock);
+       idr_init(&m->tagpool.pool);
+       init_MUTEX(&m->tagpool.lock);
        m->err = 0;
        init_waitqueue_head(&m->equeue);
        INIT_LIST_HEAD(&m->req_list);
        INIT_LIST_HEAD(&m->unsent_req_list);
+       m->rcall = NULL;
        m->rpos = 0;
-       m->rbuf = (char *)m + sizeof(struct v9fs_mux_data);
+       m->rbuf = NULL;
        m->wpos = m->wsize = 0;
-       m->wbuf = m->rbuf + msize;
+       m->wbuf = NULL;
        INIT_WORK(&m->rq, v9fs_read_work, m);
        INIT_WORK(&m->wq, v9fs_write_work, m);
        m->wsched = 0;
        memset(&m->poll_waddr, 0, sizeof(m->poll_waddr));
-       v9fs_mux_poll_start(m);
+       m->poll_task = NULL;
+       n = v9fs_mux_poll_start(m);
+       if (n)
+               return ERR_PTR(n);
 
        n = trans->poll(trans, &m->pt);
        if (n & POLLIN) {
@@ -362,7 +384,7 @@ v9fs_pollwait(struct file *filp, wait_queue_head_t * wait_address,
 /**
  * v9fs_poll_mux - polls a mux and schedules read or write works if necessary
  */
-static inline void v9fs_poll_mux(struct v9fs_mux_data *m)
+static void v9fs_poll_mux(struct v9fs_mux_data *m)
 {
        int n;
 
@@ -427,29 +449,6 @@ static int v9fs_poll_proc(void *a)
        return 0;
 }
 
-static inline int v9fs_write_req(struct v9fs_mux_data *m, struct v9fs_req *req)
-{
-       int n;
-
-       list_move_tail(&req->req_list, &m->req_list);
-       n = v9fs_serialize_fcall(req->tcall, m->wbuf, m->msize, *m->extended);
-       if (n < 0) {
-               req->err = n;
-               list_del(&req->req_list);
-               if (req->cb) {
-                       spin_unlock(&m->lock);
-                       (*req->cb) (req->cba, req->tcall, req->rcall, req->err);
-                       req->cb = NULL;
-                       spin_lock(&m->lock);
-               } else
-                       kfree(req->rcall);
-
-               kfree(req);
-       }
-
-       return n;
-}
-
 /**
  * v9fs_write_work - called when a transport can send some data
  */
@@ -457,7 +456,7 @@ static void v9fs_write_work(void *a)
 {
        int n, err;
        struct v9fs_mux_data *m;
-       struct v9fs_req *req, *rtmp;
+       struct v9fs_req *req;
 
        m = a;
 
@@ -472,17 +471,18 @@ static void v9fs_write_work(void *a)
                        return;
                }
 
-               err = 0;
                spin_lock(&m->lock);
-               list_for_each_entry_safe(req, rtmp, &m->unsent_req_list,
-                                        req_list) {
-                       err = v9fs_write_req(m, req);
-                       if (err > 0)
-                               break;
-               }
-
-               m->wsize = err;
+again:
+               req = list_entry(m->unsent_req_list.next, struct v9fs_req,
+                              req_list);
+               list_move_tail(&req->req_list, &m->req_list);
+               if (req->err == ERREQFLUSH)
+                       goto again;
+
+               m->wbuf = req->tcall->sdata;
+               m->wsize = req->tcall->size;
                m->wpos = 0;
+               dump_data(m->wbuf, m->wsize);
                spin_unlock(&m->lock);
        }
 
@@ -526,24 +526,23 @@ static void v9fs_write_work(void *a)
 static void process_request(struct v9fs_mux_data *m, struct v9fs_req *req)
 {
        int ecode, tag;
-       char *ename;
+       struct v9fs_str *ename;
 
        tag = req->tag;
-       if (req->rcall->id == RERROR && !req->err) {
+       if (!req->err && req->rcall->id == RERROR) {
                ecode = req->rcall->params.rerror.errno;
-               ename = req->rcall->params.rerror.error;
+               ename = &req->rcall->params.rerror.error;
 
-               dprintk(DEBUG_MUX, "Rerror %s\n", ename);
+               dprintk(DEBUG_MUX, "Rerror %.*s\n", ename->len, ename->str);
 
                if (*m->extended)
                        req->err = -ecode;
 
                if (!req->err) {
-                       req->err = v9fs_errstr2errno(ename);
+                       req->err = v9fs_errstr2errno(ename->str, ename->len);
 
                        if (!req->err) {        /* string match failed */
-                               dprintk(DEBUG_ERROR, "unknown error: %s\n",
-                                       ename);
+                               PRINT_FCALL_ERROR("unknown error", req->rcall);
                        }
 
                        if (!req->err)
@@ -556,7 +555,10 @@ static void process_request(struct v9fs_mux_data *m, struct v9fs_req *req)
                        req->err = -EIO;
        }
 
-       if (req->cb && req->err != ERREQFLUSH) {
+       if (req->err == ERREQFLUSH)
+               return;
+
+       if (req->cb) {
                dprintk(DEBUG_MUX, "calling callback tcall %p rcall %p\n",
                        req->tcall, req->rcall);
 
@@ -565,8 +567,7 @@ static void process_request(struct v9fs_mux_data *m, struct v9fs_req *req)
        } else
                kfree(req->rcall);
 
-       if (tag != V9FS_NOTAG)
-               v9fs_put_idpool(tag, &m->tidpool);
+       v9fs_mux_put_tag(m, tag);
 
        wake_up(&m->equeue);
        kfree(req);
@@ -577,10 +578,11 @@ static void process_request(struct v9fs_mux_data *m, struct v9fs_req *req)
  */
 static void v9fs_read_work(void *a)
 {
-       int n, err, rcallen;
+       int n, err;
        struct v9fs_mux_data *m;
        struct v9fs_req *req, *rptr, *rreq;
        struct v9fs_fcall *rcall;
+       char *rbuf;
 
        m = a;
 
@@ -589,6 +591,19 @@ static void v9fs_read_work(void *a)
 
        rcall = NULL;
        dprintk(DEBUG_MUX, "start mux %p pos %d\n", m, m->rpos);
+
+       if (!m->rcall) {
+               m->rcall =
+                   kmalloc(sizeof(struct v9fs_fcall) + m->msize, GFP_KERNEL);
+               if (!m->rcall) {
+                       err = -ENOMEM;
+                       goto error;
+               }
+
+               m->rbuf = (char *)m->rcall + sizeof(struct v9fs_fcall);
+               m->rpos = 0;
+       }
+
        clear_bit(Rpending, &m->wsched);
        err = m->trans->read(m->trans, m->rbuf + m->rpos, m->msize - m->rpos);
        dprintk(DEBUG_MUX, "mux %p got %d bytes\n", m, err);
@@ -613,21 +628,40 @@ static void v9fs_read_work(void *a)
                if (m->rpos < n)
                        break;
 
-               rcallen = n + V9FS_FCALLHDRSZ;
-               rcall = kmalloc(rcallen, GFP_KERNEL);
-               if (!rcall) {
-                       err = -ENOMEM;
-                       goto error;
-               }
-
                dump_data(m->rbuf, n);
-               err = v9fs_deserialize_fcall(m->rbuf, n, rcall, rcallen,
-                                            *m->extended);
+               err =
+                   v9fs_deserialize_fcall(m->rbuf, n, m->rcall, *m->extended);
                if (err < 0) {
-                       kfree(rcall);
                        goto error;
                }
 
+               if ((v9fs_debug_level&DEBUG_FCALL) == DEBUG_FCALL) {
+                       char buf[150];
+
+                       v9fs_printfcall(buf, sizeof(buf), m->rcall,
+                               *m->extended);
+                       printk(KERN_NOTICE ">>> %p %s\n", m, buf);
+               }
+
+               rcall = m->rcall;
+               rbuf = m->rbuf;
+               if (m->rpos > n) {
+                       m->rcall = kmalloc(sizeof(struct v9fs_fcall) + m->msize,
+                                          GFP_KERNEL);
+                       if (!m->rcall) {
+                               err = -ENOMEM;
+                               goto error;
+                       }
+
+                       m->rbuf = (char *)m->rcall + sizeof(struct v9fs_fcall);
+                       memmove(m->rbuf, rbuf + n, m->rpos - n);
+                       m->rpos -= n;
+               } else {
+                       m->rcall = NULL;
+                       m->rbuf = NULL;
+                       m->rpos = 0;
+               }
+
                dprintk(DEBUG_MUX, "mux %p fcall id %d tag %d\n", m, rcall->id,
                        rcall->tag);
 
@@ -642,6 +676,7 @@ static void v9fs_read_work(void *a)
                                process_request(m, req);
                                break;
                        }
+
                }
 
                if (!req) {
@@ -652,10 +687,6 @@ static void v9fs_read_work(void *a)
                                        m, rcall->id, rcall->tag);
                        kfree(rcall);
                }
-
-               if (m->rpos > n)
-                       memmove(m->rbuf, m->rbuf + n, m->rpos - n);
-               m->rpos -= n;
        }
 
        if (!list_empty(&m->req_list)) {
@@ -710,12 +741,20 @@ static struct v9fs_req *v9fs_send_request(struct v9fs_mux_data *m,
        if (tc->id == TVERSION)
                n = V9FS_NOTAG;
        else
-               n = v9fs_get_idpool(&m->tidpool);
+               n = v9fs_mux_get_tag(m);
 
        if (n < 0)
                return ERR_PTR(-ENOMEM);
 
-       tc->tag = n;
+       v9fs_set_tag(tc, n);
+
+       if ((v9fs_debug_level&DEBUG_FCALL) == DEBUG_FCALL) {
+               char buf[150];
+
+               v9fs_printfcall(buf, sizeof(buf), tc, *m->extended);
+               printk(KERN_NOTICE "<<< %p %s\n", m, buf);
+       }
+
        req->tag = n;
        req->tcall = tc;
        req->rcall = NULL;
@@ -738,9 +777,8 @@ static struct v9fs_req *v9fs_send_request(struct v9fs_mux_data *m,
        return req;
 }
 
-static inline void
-v9fs_mux_flush_cb(void *a, struct v9fs_fcall *tc, struct v9fs_fcall *rc,
-                 int err)
+static void v9fs_mux_flush_cb(void *a, struct v9fs_fcall *tc,
+                             struct v9fs_fcall *rc, int err)
 {
        v9fs_mux_req_callback cb;
        int tag;
@@ -773,9 +811,7 @@ v9fs_mux_flush_cb(void *a, struct v9fs_fcall *tc, struct v9fs_fcall *rc,
        if (!cb)
                spin_unlock(&m->lock);
 
-       if (v9fs_check_idpool(tag, &m->tidpool))
-               v9fs_put_idpool(tag, &m->tidpool);
-
+       v9fs_mux_put_tag(m, tag);
        kfree(tc);
        kfree(rc);
 }
@@ -787,10 +823,7 @@ v9fs_mux_flush_request(struct v9fs_mux_data *m, struct v9fs_req *req)
 
        dprintk(DEBUG_MUX, "mux %p req %p tag %d\n", m, req, req->tag);
 
-       fc = kmalloc(sizeof(struct v9fs_fcall), GFP_KERNEL);
-       fc->id = TFLUSH;
-       fc->params.tflush.oldtag = req->tag;
-
+       fc = v9fs_create_tflush(req->tag);
        v9fs_send_request(m, fc, v9fs_mux_flush_cb, m);
 }
 
@@ -800,6 +833,7 @@ v9fs_mux_rpc_cb(void *a, struct v9fs_fcall *tc, struct v9fs_fcall *rc, int err)
        struct v9fs_mux_rpc *r;
 
        if (err == ERREQFLUSH) {
+               kfree(rc);
                dprintk(DEBUG_MUX, "err req flush\n");
                return;
        }
@@ -882,6 +916,7 @@ v9fs_mux_rpc(struct v9fs_mux_data *m, struct v9fs_fcall *tc,
        return err;
 }
 
+#if 0
 /**
  * v9fs_mux_rpcnb - sends 9P request without waiting for response.
  * @m: mux data
@@ -905,6 +940,7 @@ int v9fs_mux_rpcnb(struct v9fs_mux_data *m, struct v9fs_fcall *tc,
        dprintk(DEBUG_MUX, "mux %p tc %p tag %d\n", m, tc, req->tag);
        return 0;
 }
+#endif  /*  0  */
 
 /**
  * v9fs_mux_cancel - cancel all pending requests with error
@@ -939,3 +975,20 @@ void v9fs_mux_cancel(struct v9fs_mux_data *m, int err)
 
        wake_up(&m->equeue);
 }
+
+static u16 v9fs_mux_get_tag(struct v9fs_mux_data *m)
+{
+       int tag;
+
+       tag = v9fs_get_idpool(&m->tagpool);
+       if (tag < 0)
+               return V9FS_NOTAG;
+       else
+               return (u16) tag;
+}
+
+static void v9fs_mux_put_tag(struct v9fs_mux_data *m, u16 tag)
+{
+       if (tag != V9FS_NOTAG && v9fs_check_idpool(tag, &m->tagpool))
+               v9fs_put_idpool(tag, &m->tagpool);
+}