[PATCH] v9fs: print 9p messages
[linux-2.6.git] / fs / 9p / mux.c
index f21cf50..d16f4f4 100644 (file)
@@ -31,6 +31,7 @@
 #include <linux/poll.h>
 #include <linux/kthread.h>
 #include <linux/idr.h>
+#include <linux/mutex.h>
 
 #include "debug.h"
 #include "v9fs.h"
@@ -69,7 +70,7 @@ 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;
@@ -102,8 +103,6 @@ struct v9fs_mux_rpc {
        wait_queue_head_t wqueue;
 };
 
-extern int v9fs_errstr2errno(char *str, int len);
-
 static int v9fs_poll_proc(void *);
 static void v9fs_read_work(void *);
 static void v9fs_write_work(void *);
@@ -112,14 +111,14 @@ static void v9fs_pollwait(struct file *filp, wait_queue_head_t * wait_address,
 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;
 
@@ -127,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)
@@ -140,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;
 
@@ -156,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) {
@@ -171,13 +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,
+                               pproc = 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);
+
+                               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;
                        }
                }
@@ -207,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)
@@ -224,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++) {
@@ -241,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);
 }
 
 /**
@@ -268,8 +280,8 @@ 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);
@@ -283,7 +295,10 @@ struct v9fs_mux_data *v9fs_mux_init(struct v9fs_transport *trans, int msize,
        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) {
@@ -369,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;
 
@@ -457,10 +472,13 @@ static void v9fs_write_work(void *a)
                }
 
                spin_lock(&m->lock);
-               req =
-                   list_entry(m->unsent_req_list.next, struct v9fs_req,
+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;
@@ -511,7 +529,7 @@ static void process_request(struct v9fs_mux_data *m, struct v9fs_req *req)
        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;
 
@@ -537,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);
 
@@ -614,6 +635,14 @@ static void v9fs_read_work(void *a)
                        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) {
@@ -719,6 +748,13 @@ static struct v9fs_req *v9fs_send_request(struct v9fs_mux_data *m,
 
        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;
@@ -741,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;
@@ -798,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;
        }
@@ -880,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
@@ -903,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
@@ -942,7 +980,7 @@ static u16 v9fs_mux_get_tag(struct v9fs_mux_data *m)
 {
        int tag;
 
-       tag = v9fs_get_idpool(&m->tidpool);
+       tag = v9fs_get_idpool(&m->tagpool);
        if (tag < 0)
                return V9FS_NOTAG;
        else
@@ -951,6 +989,6 @@ static u16 v9fs_mux_get_tag(struct v9fs_mux_data *m)
 
 static void v9fs_mux_put_tag(struct v9fs_mux_data *m, u16 tag)
 {
-       if (tag != V9FS_NOTAG && v9fs_check_idpool(tag, &m->tidpool))
-               v9fs_put_idpool(tag, &m->tidpool);
+       if (tag != V9FS_NOTAG && v9fs_check_idpool(tag, &m->tagpool))
+               v9fs_put_idpool(tag, &m->tagpool);
 }