Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/ericvh/v9fs

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/ericvh/v9fs:
  fs/9p: Add hardlink support to .u extension
  9P2010.L handshake: .L protocol negotiation
  9P2010.L handshake: Remove "dotu" variable
  9P2010.L handshake: Add mount option
  9P2010.L handshake: Add VFS flags
  net/9p: Handle mount errors correctly.
  net/9p: Remove MAX_9P_CHAN limit
  net/9p: Add multi channel support.

4 files changed, 165 insertions, 109 deletions

diff --git a/net/9p/client.c b/net/9p/client.c
index 09d4f1e2e4a8..bde9f3d38c57 100644
--- a/net/9p/client.c
+++ b/net/9p/client.c
@@ -46,6 +46,7 @@ enum {
         Opt_msize,
         Opt_trans,
         Opt_legacy,
+        Opt_version,
         Opt_err,
 };
 
@@ -53,9 +54,42 @@ static const match_table_t tokens = {
         {Opt_msize, "msize=%u"},
         {Opt_legacy, "noextend"},
         {Opt_trans, "trans=%s"},
+        {Opt_version, "version=%s"},
         {Opt_err, NULL},
 };
 
+inline int p9_is_proto_dotl(struct p9_client *clnt)
+{
+        return (clnt->proto_version == p9_proto_2010L);
+}
+EXPORT_SYMBOL(p9_is_proto_dotl);
+
+inline int p9_is_proto_dotu(struct p9_client *clnt)
+{
+        return (clnt->proto_version == p9_proto_2000u);
+}
+EXPORT_SYMBOL(p9_is_proto_dotu);
+
+/* Interpret mount option for protocol version */
+static unsigned char get_protocol_version(const substring_t *name)
+{
+        unsigned char version = -EINVAL;
+        if (!strncmp("9p2000", name->from, name->to-name->from)) {
+                version = p9_proto_legacy;
+                P9_DPRINTK(P9_DEBUG_9P, "Protocol version: Legacy\n");
+        } else if (!strncmp("9p2000.u", name->from, name->to-name->from)) {
+                version = p9_proto_2000u;
+                P9_DPRINTK(P9_DEBUG_9P, "Protocol version: 9P2000.u\n");
+        } else if (!strncmp("9p2010.L", name->from, name->to-name->from)) {
+                version = p9_proto_2010L;
+                P9_DPRINTK(P9_DEBUG_9P, "Protocol version: 9P2010.L\n");
+        } else {
+                P9_DPRINTK(P9_DEBUG_ERROR, "Unknown protocol version %s. ",
+                                                        name->from);
+        }
+        return version;
+}
+
 static struct p9_req_t *
 p9_client_rpc(struct p9_client *c, int8_t type, const char *fmt, ...);
 
@@ -75,7 +109,7 @@ static int parse_opts(char *opts, struct p9_client *clnt)
         int option;
         int ret = 0;
 
-        clnt->dotu = 1;
+        clnt->proto_version = p9_proto_2000u;
         clnt->msize = 8192;
 
         if (!opts)
@@ -118,7 +152,13 @@ static int parse_opts(char *opts, struct p9_client *clnt)
                         }
                         break;
                 case Opt_legacy:
-                        clnt->dotu = 0;
+                        clnt->proto_version = p9_proto_legacy;
+                        break;
+                case Opt_version:
+                        ret = get_protocol_version(&args[0]);
+                        if (ret == -EINVAL)
+                                goto free_and_return;
+                        clnt->proto_version = ret;
                         break;
                 default:
                         continue;
@@ -410,14 +450,15 @@ static int p9_check_errors(struct p9_client *c, struct p9_req_t *req)
                 int ecode;
                 char *ename;
 
-                err = p9pdu_readf(req->rc, c->dotu, "s?d", &ename, &ecode);
+                err = p9pdu_readf(req->rc, c->proto_version, "s?d",
+                                                        &ename, &ecode);
                 if (err) {
                         P9_DPRINTK(P9_DEBUG_ERROR, "couldn't parse error%d\n",
                                                                         err);
                         return err;
                 }
 
-                if (c->dotu)
+                if (p9_is_proto_dotu(c))
                         err = -ecode;
 
                 if (!err || !IS_ERR_VALUE(err))
@@ -515,7 +556,7 @@ p9_client_rpc(struct p9_client *c, int8_t type, const char *fmt, ...)
         /* marshall the data */
         p9pdu_prepare(req->tc, tag, type);
         va_start(ap, fmt);
-        err = p9pdu_vwritef(req->tc, c->dotu, fmt, ap);
+        err = p9pdu_vwritef(req->tc, c->proto_version, fmt, ap);
         va_end(ap);
         p9pdu_finalize(req->tc);
 
@@ -627,14 +668,31 @@ int p9_client_version(struct p9_client *c)
         char *version;
         int msize;
 
-        P9_DPRINTK(P9_DEBUG_9P, ">>> TVERSION msize %d extended %d\n",
-                                                        c->msize, c->dotu);
-        req = p9_client_rpc(c, P9_TVERSION, "ds", c->msize,
-                                c->dotu ? "9P2000.u" : "9P2000");
+        P9_DPRINTK(P9_DEBUG_9P, ">>> TVERSION msize %d protocol %d\n",
+                                                c->msize, c->proto_version);
+
+        switch (c->proto_version) {
+        case p9_proto_2010L:
+                req = p9_client_rpc(c, P9_TVERSION, "ds",
+                                        c->msize, "9P2010.L");
+                break;
+        case p9_proto_2000u:
+                req = p9_client_rpc(c, P9_TVERSION, "ds",
+                                        c->msize, "9P2000.u");
+                break;
+        case p9_proto_legacy:
+                req = p9_client_rpc(c, P9_TVERSION, "ds",
+                                        c->msize, "9P2000");
+                break;
+        default:
+                return -EINVAL;
+                break;
+        }
+
         if (IS_ERR(req))
                 return PTR_ERR(req);
 
-        err = p9pdu_readf(req->rc, c->dotu, "ds", &msize, &version);
+        err = p9pdu_readf(req->rc, c->proto_version, "ds", &msize, &version);
         if (err) {
                 P9_DPRINTK(P9_DEBUG_9P, "version error %d\n", err);
                 p9pdu_dump(1, req->rc);
@@ -642,10 +700,12 @@ int p9_client_version(struct p9_client *c)
         }
 
         P9_DPRINTK(P9_DEBUG_9P, "<<< RVERSION msize %d %s\n", msize, version);
-        if (!memcmp(version, "9P2000.u", 8))
-                c->dotu = 1;
-        else if (!memcmp(version, "9P2000", 6))
-                c->dotu = 0;
+        if (!strncmp(version, "9P2010.L", 8))
+                c->proto_version = p9_proto_2010L;
+        else if (!strncmp(version, "9P2000.u", 8))
+                c->proto_version = p9_proto_2000u;
+        else if (!strncmp(version, "9P2000", 6))
+                c->proto_version = p9_proto_legacy;
         else {
                 err = -EREMOTEIO;
                 goto error;
@@ -700,8 +760,8 @@ struct p9_client *p9_client_create(const char *dev_name, char *options)
                 goto put_trans;
         }
 
-        P9_DPRINTK(P9_DEBUG_MUX, "clnt %p trans %p msize %d dotu %d\n",
-                clnt, clnt->trans_mod, clnt->msize, clnt->dotu);
+        P9_DPRINTK(P9_DEBUG_MUX, "clnt %p trans %p msize %d protocol %d\n",
+                clnt, clnt->trans_mod, clnt->msize, clnt->proto_version);
 
         err = clnt->trans_mod->create(clnt, dev_name, options);
         if (err)
@@ -784,7 +844,7 @@ struct p9_fid *p9_client_attach(struct p9_client *clnt, struct p9_fid *afid,
                 goto error;
         }
 
-        err = p9pdu_readf(req->rc, clnt->dotu, "Q", &qid);
+        err = p9pdu_readf(req->rc, clnt->proto_version, "Q", &qid);
         if (err) {
                 p9pdu_dump(1, req->rc);
                 p9_free_req(clnt, req);
@@ -833,7 +893,7 @@ p9_client_auth(struct p9_client *clnt, char *uname, u32 n_uname, char *aname)
                 goto error;
         }
 
-        err = p9pdu_readf(req->rc, clnt->dotu, "Q", &qid);
+        err = p9pdu_readf(req->rc, clnt->proto_version, "Q", &qid);
         if (err) {
                 p9pdu_dump(1, req->rc);
                 p9_free_req(clnt, req);
@@ -891,7 +951,7 @@ struct p9_fid *p9_client_walk(struct p9_fid *oldfid, int nwname, char **wnames,
                 goto error;
         }
 
-        err = p9pdu_readf(req->rc, clnt->dotu, "R", &nwqids, &wqids);
+        err = p9pdu_readf(req->rc, clnt->proto_version, "R", &nwqids, &wqids);
         if (err) {
                 p9pdu_dump(1, req->rc);
                 p9_free_req(clnt, req);
@@ -952,7 +1012,7 @@ int p9_client_open(struct p9_fid *fid, int mode)
                 goto error;
         }
 
-        err = p9pdu_readf(req->rc, clnt->dotu, "Qd", &qid, &iounit);
+        err = p9pdu_readf(req->rc, clnt->proto_version, "Qd", &qid, &iounit);
         if (err) {
                 p9pdu_dump(1, req->rc);
                 goto free_and_error;
@@ -997,7 +1057,7 @@ int p9_client_fcreate(struct p9_fid *fid, char *name, u32 perm, int mode,
                 goto error;
         }
 
-        err = p9pdu_readf(req->rc, clnt->dotu, "Qd", &qid, &iounit);
+        err = p9pdu_readf(req->rc, clnt->proto_version, "Qd", &qid, &iounit);
         if (err) {
                 p9pdu_dump(1, req->rc);
                 goto free_and_error;
@@ -1098,7 +1158,7 @@ p9_client_read(struct p9_fid *fid, char *data, char __user *udata, u64 offset,
                 goto error;
         }
 
-        err = p9pdu_readf(req->rc, clnt->dotu, "D", &count, &dataptr);
+        err = p9pdu_readf(req->rc, clnt->proto_version, "D", &count, &dataptr);
         if (err) {
                 p9pdu_dump(1, req->rc);
                 goto free_and_error;
@@ -1159,7 +1219,7 @@ p9_client_write(struct p9_fid *fid, char *data, const char __user *udata,
                 goto error;
         }
 
-        err = p9pdu_readf(req->rc, clnt->dotu, "d", &count);
+        err = p9pdu_readf(req->rc, clnt->proto_version, "d", &count);
         if (err) {
                 p9pdu_dump(1, req->rc);
                 goto free_and_error;
@@ -1199,7 +1259,7 @@ struct p9_wstat *p9_client_stat(struct p9_fid *fid)
                 goto error;
         }
 
-        err = p9pdu_readf(req->rc, clnt->dotu, "wS", &ignored, ret);
+        err = p9pdu_readf(req->rc, clnt->proto_version, "wS", &ignored, ret);
         if (err) {
                 p9pdu_dump(1, req->rc);
                 p9_free_req(clnt, req);
@@ -1226,7 +1286,7 @@ error:
 }
 EXPORT_SYMBOL(p9_client_stat);
 
-static int p9_client_statsize(struct p9_wstat *wst, int optional)
+static int p9_client_statsize(struct p9_wstat *wst, int proto_version)
 {
         int ret;
 
@@ -1245,7 +1305,7 @@ static int p9_client_statsize(struct p9_wstat *wst, int optional)
         if (wst->muid)
                 ret += strlen(wst->muid);
 
-        if (optional) {
+        if (proto_version == p9_proto_2000u) {
                 ret += 2+4+4+4; /* extension[s] n_uid[4] n_gid[4] n_muid[4] */
                 if (wst->extension)
                         ret += strlen(wst->extension);
@@ -1262,7 +1322,7 @@ int p9_client_wstat(struct p9_fid *fid, struct p9_wstat *wst)
 
         err = 0;
         clnt = fid->clnt;
-        wst->size = p9_client_statsize(wst, clnt->dotu);
+        wst->size = p9_client_statsize(wst, clnt->proto_version);
         P9_DPRINTK(P9_DEBUG_9P, ">>> TWSTAT fid %d\n", fid->fid);
         P9_DPRINTK(P9_DEBUG_9P,
                 "     sz=%x type=%x dev=%x qid=%x.%llx.%x\n"
diff --git a/net/9p/protocol.c b/net/9p/protocol.c
index fc70147c771e..94f5a8f65e9c 100644
--- a/net/9p/protocol.c
+++ b/net/9p/protocol.c
@@ -52,7 +52,7 @@
 #endif
 
 static int
-p9pdu_writef(struct p9_fcall *pdu, int optional, const char *fmt, ...);
+p9pdu_writef(struct p9_fcall *pdu, int proto_version, const char *fmt, ...);
 
 #ifdef CONFIG_NET_9P_DEBUG
 void
@@ -144,7 +144,8 @@ pdu_write_u(struct p9_fcall *pdu, const char __user *udata, size_t size)
 */
 
 static int
-p9pdu_vreadf(struct p9_fcall *pdu, int optional, const char *fmt, va_list ap)
+p9pdu_vreadf(struct p9_fcall *pdu, int proto_version, const char *fmt,
+        va_list ap)
 {
         const char *ptr;
         int errcode = 0;
@@ -194,7 +195,8 @@ p9pdu_vreadf(struct p9_fcall *pdu, int optional, const char *fmt, va_list ap)
                                 int16_t len;
                                 int size;
 
-                                errcode = p9pdu_readf(pdu, optional, "w", &len);
+                                errcode = p9pdu_readf(pdu, proto_version,
+                                                                "w", &len);
                                 if (errcode)
                                         break;
 
@@ -217,7 +219,7 @@ p9pdu_vreadf(struct p9_fcall *pdu, int optional, const char *fmt, va_list ap)
                                 struct p9_qid *qid =
                                     va_arg(ap, struct p9_qid *);
 
-                                errcode = p9pdu_readf(pdu, optional, "bdq",
+                                errcode = p9pdu_readf(pdu, proto_version, "bdq",
                                                       &qid->type, &qid->version,
                                                       &qid->path);
                         }
@@ -230,7 +232,7 @@ p9pdu_vreadf(struct p9_fcall *pdu, int optional, const char *fmt, va_list ap)
                                 stbuf->n_uid = stbuf->n_gid = stbuf->n_muid =
                                                                         -1;
                                 errcode =
-                                    p9pdu_readf(pdu, optional,
+                                    p9pdu_readf(pdu, proto_version,
                                                 "wwdQdddqssss?sddd",
                                                 &stbuf->size, &stbuf->type,
                                                 &stbuf->dev, &stbuf->qid,
@@ -250,7 +252,7 @@ p9pdu_vreadf(struct p9_fcall *pdu, int optional, const char *fmt, va_list ap)
                                 void **data = va_arg(ap, void **);
 
                                 errcode =
-                                    p9pdu_readf(pdu, optional, "d", count);
+                                    p9pdu_readf(pdu, proto_version, "d", count);
                                 if (!errcode) {
                                         *count =
                                             MIN(*count,
@@ -263,8 +265,8 @@ p9pdu_vreadf(struct p9_fcall *pdu, int optional, const char *fmt, va_list ap)
                                 int16_t *nwname = va_arg(ap, int16_t *);
                                 char ***wnames = va_arg(ap, char ***);
 
-                                errcode =
-                                    p9pdu_readf(pdu, optional, "w", nwname);
+                                errcode = p9pdu_readf(pdu, proto_version,
+                                                                "w", nwname);
                                 if (!errcode) {
                                         *wnames =
                                             kmalloc(sizeof(char *) * *nwname,
@@ -278,7 +280,8 @@ p9pdu_vreadf(struct p9_fcall *pdu, int optional, const char *fmt, va_list ap)
 
                                         for (i = 0; i < *nwname; i++) {
                                                 errcode =
-                                                    p9pdu_readf(pdu, optional,
+                                                    p9pdu_readf(pdu,
+                                                                proto_version,
                                                                 "s",
                                                                 &(*wnames)[i]);
                                                 if (errcode)
@@ -306,7 +309,7 @@ p9pdu_vreadf(struct p9_fcall *pdu, int optional, const char *fmt, va_list ap)
                                 *wqids = NULL;
 
                                 errcode =
-                                    p9pdu_readf(pdu, optional, "w", nwqid);
+                                    p9pdu_readf(pdu, proto_version, "w", nwqid);
                                 if (!errcode) {
                                         *wqids =
                                             kmalloc(*nwqid *
@@ -321,7 +324,8 @@ p9pdu_vreadf(struct p9_fcall *pdu, int optional, const char *fmt, va_list ap)
 
                                         for (i = 0; i < *nwqid; i++) {
                                                 errcode =
-                                                    p9pdu_readf(pdu, optional,
+                                                    p9pdu_readf(pdu,
+                                                                proto_version,
                                                                 "Q",
                                                                 &(*wqids)[i]);
                                                 if (errcode)
@@ -336,7 +340,7 @@ p9pdu_vreadf(struct p9_fcall *pdu, int optional, const char *fmt, va_list ap)
                         }
                         break;
                 case '?':
-                        if (!optional)
+                        if (proto_version != p9_proto_2000u)
                                 return 0;
                         break;
                 default:
@@ -352,7 +356,8 @@ p9pdu_vreadf(struct p9_fcall *pdu, int optional, const char *fmt, va_list ap)
 }
 
 int
-p9pdu_vwritef(struct p9_fcall *pdu, int optional, const char *fmt, va_list ap)
+p9pdu_vwritef(struct p9_fcall *pdu, int proto_version, const char *fmt,
+        va_list ap)
 {
         const char *ptr;
         int errcode = 0;
@@ -389,7 +394,8 @@ p9pdu_vwritef(struct p9_fcall *pdu, int optional, const char *fmt, va_list ap)
                                 if (sptr)
                                         len = MIN(strlen(sptr), USHORT_MAX);
 
-                                errcode = p9pdu_writef(pdu, optional, "w", len);
+                                errcode = p9pdu_writef(pdu, proto_version,
+                                                                "w", len);
                                 if (!errcode && pdu_write(pdu, sptr, len))
                                         errcode = -EFAULT;
                         }
@@ -398,7 +404,7 @@ p9pdu_vwritef(struct p9_fcall *pdu, int optional, const char *fmt, va_list ap)
                                 const struct p9_qid *qid =
                                     va_arg(ap, const struct p9_qid *);
                                 errcode =
-                                    p9pdu_writef(pdu, optional, "bdq",
+                                    p9pdu_writef(pdu, proto_version, "bdq",
                                                  qid->type, qid->version,
                                                  qid->path);
                         } break;
@@ -406,7 +412,7 @@ p9pdu_vwritef(struct p9_fcall *pdu, int optional, const char *fmt, va_list ap)
                                 const struct p9_wstat *stbuf =
                                     va_arg(ap, const struct p9_wstat *);
                                 errcode =
-                                    p9pdu_writef(pdu, optional,
+                                    p9pdu_writef(pdu, proto_version,
                                                  "wwdQdddqssss?sddd",
                                                  stbuf->size, stbuf->type,
                                                  stbuf->dev, &stbuf->qid,
@@ -421,8 +427,8 @@ p9pdu_vwritef(struct p9_fcall *pdu, int optional, const char *fmt, va_list ap)
                                 int32_t count = va_arg(ap, int32_t);
                                 const void *data = va_arg(ap, const void *);
 
-                                errcode =
-                                    p9pdu_writef(pdu, optional, "d", count);
+                                errcode = p9pdu_writef(pdu, proto_version, "d",
+                                                                        count);
                                 if (!errcode && pdu_write(pdu, data, count))
                                         errcode = -EFAULT;
                         }
@@ -431,8 +437,8 @@ p9pdu_vwritef(struct p9_fcall *pdu, int optional, const char *fmt, va_list ap)
                                 int32_t count = va_arg(ap, int32_t);
                                 const char __user *udata =
                                                 va_arg(ap, const void __user *);
-                                errcode =
-                                    p9pdu_writef(pdu, optional, "d", count);
+                                errcode = p9pdu_writef(pdu, proto_version, "d",
+                                                                        count);
                                 if (!errcode && pdu_write_u(pdu, udata, count))
                                         errcode = -EFAULT;
                         }
@@ -441,14 +447,15 @@ p9pdu_vwritef(struct p9_fcall *pdu, int optional, const char *fmt, va_list ap)
                                 int16_t nwname = va_arg(ap, int);
                                 const char **wnames = va_arg(ap, const char **);
 
-                                errcode =
-                                    p9pdu_writef(pdu, optional, "w", nwname);
+                                errcode = p9pdu_writef(pdu, proto_version, "w",
+                                                                        nwname);
                                 if (!errcode) {
                                         int i;
 
                                         for (i = 0; i < nwname; i++) {
                                                 errcode =
-                                                    p9pdu_writef(pdu, optional,
+                                                    p9pdu_writef(pdu,
+                                                                proto_version,
                                                                  "s",
                                                                  wnames[i]);
                                                 if (errcode)
@@ -462,14 +469,15 @@ p9pdu_vwritef(struct p9_fcall *pdu, int optional, const char *fmt, va_list ap)
                                 struct p9_qid *wqids =
                                     va_arg(ap, struct p9_qid *);
 
-                                errcode =
-                                    p9pdu_writef(pdu, optional, "w", nwqid);
+                                errcode = p9pdu_writef(pdu, proto_version, "w",
+                                                                        nwqid);
                                 if (!errcode) {
                                         int i;
 
                                         for (i = 0; i < nwqid; i++) {
                                                 errcode =
-                                                    p9pdu_writef(pdu, optional,
+                                                    p9pdu_writef(pdu,
+                                                                proto_version,
                                                                  "Q",
                                                                  &wqids[i]);
                                                 if (errcode)
@@ -479,7 +487,7 @@ p9pdu_vwritef(struct p9_fcall *pdu, int optional, const char *fmt, va_list ap)
                         }
                         break;
                 case '?':
-                        if (!optional)
+                        if (proto_version != p9_proto_2000u)
                                 return 0;
                         break;
                 default:
@@ -494,32 +502,32 @@ p9pdu_vwritef(struct p9_fcall *pdu, int optional, const char *fmt, va_list ap)
         return errcode;
 }
 
-int p9pdu_readf(struct p9_fcall *pdu, int optional, const char *fmt, ...)
+int p9pdu_readf(struct p9_fcall *pdu, int proto_version, const char *fmt, ...)
 {
         va_list ap;
         int ret;
 
         va_start(ap, fmt);
-        ret = p9pdu_vreadf(pdu, optional, fmt, ap);
+        ret = p9pdu_vreadf(pdu, proto_version, fmt, ap);
         va_end(ap);
 
         return ret;
 }
 
 static int
-p9pdu_writef(struct p9_fcall *pdu, int optional, const char *fmt, ...)
+p9pdu_writef(struct p9_fcall *pdu, int proto_version, const char *fmt, ...)
 {
         va_list ap;
         int ret;
 
         va_start(ap, fmt);
-        ret = p9pdu_vwritef(pdu, optional, fmt, ap);
+        ret = p9pdu_vwritef(pdu, proto_version, fmt, ap);
         va_end(ap);
 
         return ret;
 }
 
-int p9stat_read(char *buf, int len, struct p9_wstat *st, int dotu)
+int p9stat_read(char *buf, int len, struct p9_wstat *st, int proto_version)
 {
         struct p9_fcall fake_pdu;
         int ret;
@@ -529,7 +537,7 @@ int p9stat_read(char *buf, int len, struct p9_wstat *st, int dotu)
         fake_pdu.sdata = buf;
         fake_pdu.offset = 0;
 
-        ret = p9pdu_readf(&fake_pdu, dotu, "S", st);
+        ret = p9pdu_readf(&fake_pdu, proto_version, "S", st);
         if (ret) {
                 P9_DPRINTK(P9_DEBUG_9P, "<<< p9stat_read failed: %d\n", ret);
                 p9pdu_dump(1, &fake_pdu);
diff --git a/net/9p/protocol.h b/net/9p/protocol.h
index ccde462e7ac5..2431c0f38d56 100644
--- a/net/9p/protocol.h
+++ b/net/9p/protocol.h
@@ -25,9 +25,9 @@
  *
  */
 
-int
-p9pdu_vwritef(struct p9_fcall *pdu, int optional, const char *fmt, va_list ap);
-int p9pdu_readf(struct p9_fcall *pdu, int optional, const char *fmt, ...);
+int p9pdu_vwritef(struct p9_fcall *pdu, int proto_version, const char *fmt,
+                                                                va_list ap);
+int p9pdu_readf(struct p9_fcall *pdu, int proto_version, const char *fmt, ...);
 int p9pdu_prepare(struct p9_fcall *pdu, int16_t tag, int8_t type);
 int p9pdu_finalize(struct p9_fcall *pdu);
 void p9pdu_dump(int, struct p9_fcall *);
diff --git a/net/9p/trans_virtio.c b/net/9p/trans_virtio.c
index cb50f4ae5eef..0aaed4819379 100644
--- a/net/9p/trans_virtio.c
+++ b/net/9p/trans_virtio.c
@@ -49,8 +49,6 @@
 
 /* a single mutex to manage channel initialization and attachment */
 static DEFINE_MUTEX(virtio_9p_lock);
-/* global which tracks highest initialized channel */
-static int chan_index;
 
 /**
  * struct virtio_chan - per-instance transport information
@@ -68,8 +66,7 @@ static int chan_index;
  *
  */
 
-static struct virtio_chan {
-        bool initialized;
+struct virtio_chan {
         bool inuse;
 
         spinlock_t lock;
@@ -80,7 +77,11 @@ static struct virtio_chan {
 
         /* Scatterlist: can be too big for stack. */
         struct scatterlist sg[VIRTQUEUE_NUM];
-} channels[MAX_9P_CHAN];
+
+        struct list_head chan_list;
+};
+
+static struct list_head virtio_chan_list;
 
 /* How many bytes left in this page. */
 static unsigned int rest_of_page(void *data)
@@ -217,9 +218,7 @@ p9_virtio_request(struct p9_client *client, struct p9_req_t *req)
  * p9_virtio_probe - probe for existence of 9P virtio channels
  * @vdev: virtio device to probe
  *
- * This probes for existing virtio channels.  At present only
- * a single channel is in use, so in the future more work may need
- * to be done here.
+ * This probes for existing virtio channels.
  *
  */
 
@@ -227,16 +226,10 @@ static int p9_virtio_probe(struct virtio_device *vdev)
 {
         int err;
         struct virtio_chan *chan;
-        int index;
 
-        mutex_lock(&virtio_9p_lock);
-        index = chan_index++;
-        chan = &channels[index];
-        mutex_unlock(&virtio_9p_lock);
-
-        if (chan_index > MAX_9P_CHAN) {
-                printk(KERN_ERR "9p: virtio: Maximum channels exceeded\n");
-                BUG();
+        chan = kmalloc(sizeof(struct virtio_chan), GFP_KERNEL);
+        if (!chan) {
+                printk(KERN_ERR "9p: Failed to allocate virtio 9P channel\n");
                 err = -ENOMEM;
                 goto fail;
         }
@@ -255,15 +248,15 @@ static int p9_virtio_probe(struct virtio_device *vdev)
         sg_init_table(chan->sg, VIRTQUEUE_NUM);
 
         chan->inuse = false;
-        chan->initialized = true;
+        mutex_lock(&virtio_9p_lock);
+        list_add_tail(&chan->chan_list, &virtio_chan_list);
+        mutex_unlock(&virtio_9p_lock);
         return 0;
 
 out_free_vq:
         vdev->config->del_vqs(vdev);
+        kfree(chan);
 fail:
-        mutex_lock(&virtio_9p_lock);
-        chan_index--;
-        mutex_unlock(&virtio_9p_lock);
         return err;
 }
 
@@ -280,35 +273,31 @@ fail:
  * We use a simple reference count mechanism to ensure that only a single
  * mount has a channel open at a time.
  *
- * Bugs: doesn't allow identification of a specific channel
- * to allocate, channels are allocated sequentially. This was
- * a pragmatic decision to get things rolling, but ideally some
- * way of identifying the channel to attach to would be nice
- * if we are going to support multiple channels.
- *
  */
 
 static int
 p9_virtio_create(struct p9_client *client, const char *devname, char *args)
 {
-        struct virtio_chan *chan = channels;
-        int index = 0;
+        struct virtio_chan *chan;
+        int ret = -ENOENT;
+        int found = 0;
 
         mutex_lock(&virtio_9p_lock);
-        while (index < MAX_9P_CHAN) {
-                if (chan->initialized && !chan->inuse) {
-                        chan->inuse = true;
-                        break;
-                } else {
-                        index++;
-                        chan = &channels[index];
+        list_for_each_entry(chan, &virtio_chan_list, chan_list) {
+                if (!strcmp(devname, dev_name(&chan->vdev->dev))) {
+                        if (!chan->inuse) {
+                                chan->inuse = true;
+                                found = 1;
+                                break;
+                        }
+                        ret = -EBUSY;
                 }
         }
         mutex_unlock(&virtio_9p_lock);
 
-        if (index >= MAX_9P_CHAN) {
+        if (!found) {
                 printk(KERN_ERR "9p: no channels available\n");
-                return -ENODEV;
+                return ret;
         }
 
         client->trans = (void *)chan;
@@ -329,11 +318,13 @@ static void p9_virtio_remove(struct virtio_device *vdev)
         struct virtio_chan *chan = vdev->priv;
 
         BUG_ON(chan->inuse);
+        vdev->config->del_vqs(vdev);
+
+        mutex_lock(&virtio_9p_lock);
+        list_del(&chan->chan_list);
+        mutex_unlock(&virtio_9p_lock);
+        kfree(chan);
 
-        if (chan->initialized) {
-                vdev->config->del_vqs(vdev);
-                chan->initialized = false;
-        }
 }
 
 static struct virtio_device_id id_table[] = {
@@ -364,10 +355,7 @@ static struct p9_trans_module p9_virtio_trans = {
 /* The standard init function */
 static int __init p9_virtio_init(void)
 {
-        int count;
-
-        for (count = 0; count < MAX_9P_CHAN; count++)
-                channels[count].initialized = false;
+        INIT_LIST_HEAD(&virtio_chan_list);
 
         v9fs_register_trans(&p9_virtio_trans);
         return register_virtio_driver(&p9_virtio_drv);