62 files changed, 1070 insertions, 868 deletions
diff --git a/fs/9p/9p.h b/fs/9p/9p.h
index 95d72aec1c1a..94e2f92ab2e8 100644
--- a/fs/9p/9p.h
+++ b/fs/9p/9p.h
@@ -8,9 +8,8 @@
 *  Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
 *
 *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
+ *  it under the terms of the GNU General Public License version 2
- *  the Free Software Foundation; either version 2 of the License, or
+ *  as published by the Free Software Foundation.
- *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -235,6 +234,7 @@ struct Tcreate {
        struct v9fs_str name;
        u32 perm;
        u8 mode;
+        struct v9fs_str extension;
 };
 struct Rcreate {
@@ -364,7 +364,7 @@ int v9fs_t_remove(struct v9fs_session_info *v9ses, u32 fid,
                  struct v9fs_fcall **rcall);
 int v9fs_t_create(struct v9fs_session_info *v9ses, u32 fid, char *name,
-                  u32 perm, u8 mode, struct v9fs_fcall **rcall);
+        u32 perm, u8 mode, char *extension, struct v9fs_fcall **rcall);
 int v9fs_t_read(struct v9fs_session_info *v9ses, u32 fid,
                u64 offset, u32 count, struct v9fs_fcall **rcall);
@@ -372,3 +372,4 @@ int v9fs_t_read(struct v9fs_session_info *v9ses, u32 fid,
 int v9fs_t_write(struct v9fs_session_info *v9ses, u32 fid, u64 offset,
                 u32 count, const char __user * data,
                 struct v9fs_fcall **rcall);
+int v9fs_printfcall(char *, int, struct v9fs_fcall *, int);
diff --git a/fs/9p/Makefile b/fs/9p/Makefile
index 2f4ce43f7b6c..87897f84dfb6 100644
--- a/fs/9p/Makefile
+++ b/fs/9p/Makefile
@@ -1,10 +1,9 @@
-obj-$(CONFIG_9P_FS) := 9p2000.o
+obj-$(CONFIG_9P_FS) := 9p.o
-9p2000-objs := \
+9p-objs := \
        trans_fd.o \
-        trans_sock.o \
        mux.o \
-        9p.o \
+        fcall.o \
        conv.o \
        vfs_super.o \
        vfs_inode.o \
@@ -14,5 +13,6 @@ obj-$(CONFIG_9P_FS) := 9p2000.o
        vfs_dentry.o \
        error.o \
        v9fs.o \
-        fid.o
+        fid.o \
+        fcprint.o
diff --git a/fs/9p/conv.c b/fs/9p/conv.c
index bba817142465..a767e05b60bf 100644
--- a/fs/9p/conv.c
+++ b/fs/9p/conv.c
@@ -8,9 +8,8 @@
 *  Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
 *
 *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
+ *  it under the terms of the GNU General Public License version 2
- *  the Free Software Foundation; either version 2 of the License, or
+ *  as published by the Free Software Foundation.
- *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -666,7 +665,8 @@ struct v9fs_fcall *v9fs_create_topen(u32 fid, u8 mode)
        return fc;
 }
-struct v9fs_fcall *v9fs_create_tcreate(u32 fid, char *name, u32 perm, u8 mode)
+struct v9fs_fcall *v9fs_create_tcreate(u32 fid, char *name, u32 perm, u8 mode,
+        char *extension, int extended)
 {
        int size;
        struct v9fs_fcall *fc;
@@ -674,6 +674,9 @@ struct v9fs_fcall *v9fs_create_tcreate(u32 fid, char *name, u32 perm, u8 mode)
        struct cbuf *bufp = &buffer;
        size = 4 + 2 + strlen(name) + 4 + 1;    /* fid[4] name[s] perm[4] mode[1] */
+        if (extended && extension!=NULL)
+                size += 2 + strlen(extension);  /* extension[s] */
        fc = v9fs_create_common(bufp, size, TCREATE);
        if (IS_ERR(fc))
                goto error;
@@ -682,6 +685,8 @@ struct v9fs_fcall *v9fs_create_tcreate(u32 fid, char *name, u32 perm, u8 mode)
        v9fs_put_str(bufp, name, &fc->params.tcreate.name);
        v9fs_put_int32(bufp, perm, &fc->params.tcreate.perm);
        v9fs_put_int8(bufp, mode, &fc->params.tcreate.mode);
+        if (extended)
+                v9fs_put_str(bufp, extension, &fc->params.tcreate.extension);
        if (buf_check_overflow(bufp)) {
                kfree(fc);
diff --git a/fs/9p/conv.h b/fs/9p/conv.h
index f5896628dae4..dd5b6b1b610f 100644
--- a/fs/9p/conv.h
+++ b/fs/9p/conv.h
@@ -8,9 +8,8 @@
 *  Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
 *
 *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
+ *  it under the terms of the GNU General Public License version 2
- *  the Free Software Foundation; either version 2 of the License, or
+ *  as published by the Free Software Foundation.
- *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -39,7 +38,8 @@ struct v9fs_fcall *v9fs_create_tflush(u16 oldtag);
 struct v9fs_fcall *v9fs_create_twalk(u32 fid, u32 newfid, u16 nwname,
        char **wnames);
 struct v9fs_fcall *v9fs_create_topen(u32 fid, u8 mode);
-struct v9fs_fcall *v9fs_create_tcreate(u32 fid, char *name, u32 perm, u8 mode);
+struct v9fs_fcall *v9fs_create_tcreate(u32 fid, char *name, u32 perm, u8 mode,
+        char *extension, int extended);
 struct v9fs_fcall *v9fs_create_tread(u32 fid, u64 offset, u32 count);
 struct v9fs_fcall *v9fs_create_twrite(u32 fid, u64 offset, u32 count,
        const char __user *data);
diff --git a/fs/9p/debug.h b/fs/9p/debug.h
index fe551032788b..4228c0bb3c32 100644
--- a/fs/9p/debug.h
+++ b/fs/9p/debug.h
@@ -5,9 +5,8 @@
 *  Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
 *
 *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
+ *  it under the terms of the GNU General Public License version 2
- *  the Free Software Foundation; either version 2 of the License, or
+ *  as published by the Free Software Foundation.
- *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -30,6 +29,7 @@
 #define DEBUG_MUX               (1<<5)
 #define DEBUG_TRANS             (1<<6)
 #define DEBUG_SLABS             (1<<7)
+#define DEBUG_FCALL             (1<<8)
 #define DEBUG_DUMP_PKT          0
diff --git a/fs/9p/error.c b/fs/9p/error.c
index e4b6f8f38b6f..981fe8ecd780 100644
--- a/fs/9p/error.c
+++ b/fs/9p/error.c
@@ -11,9 +11,8 @@
 *  Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
 *
 *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
+ *  it under the terms of the GNU General Public License version 2
- *  the Free Software Foundation; either version 2 of the License, or
+ *  as published by the Free Software Foundation.
- *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/fs/9p/error.h b/fs/9p/error.h
index a9794e85fe51..5f3ca522b316 100644
--- a/fs/9p/error.h
+++ b/fs/9p/error.h
@@ -12,9 +12,8 @@
 *  Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
 *
 *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
+ *  it under the terms of the GNU General Public License version 2
- *  the Free Software Foundation; either version 2 of the License, or
+ *  as published by the Free Software Foundation.
- *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/fs/9p/9p.c b/fs/9p/fcall.c
index c148e6ba07e5..71742ba150c4 100644
--- a/fs/9p/9p.c
+++ b/fs/9p/fcall.c
@@ -1,5 +1,5 @@
 /*
- *  linux/fs/9p/9p.c
+ *  linux/fs/9p/fcall.c
 *
 *  This file contains functions to perform synchronous 9P calls
 *
@@ -8,9 +8,8 @@
 *  Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
 *
 *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
+ *  it under the terms of the GNU General Public License version 2
- *  the Free Software Foundation; either version 2 of the License, or
+ *  as published by the Free Software Foundation.
- *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -152,10 +151,9 @@ v9fs_t_clunk(struct v9fs_session_info *v9ses, u32 fid)
 /**
 * v9fs_v9fs_t_flush - flush a pending transaction
 * @v9ses: 9P2000 session information
- * @tag: tid to release
+ * @tag: tag to release
 *
 */
 int v9fs_t_flush(struct v9fs_session_info *v9ses, u16 oldtag)
 {
        int ret;
@@ -172,7 +170,7 @@ int v9fs_t_flush(struct v9fs_session_info *v9ses, u16 oldtag)
        return ret;
 }
-#endif  /*  0  */
+#endif
 /**
 * v9fs_t_stat - read a file's meta-data
@@ -334,8 +332,8 @@ v9fs_t_remove(struct v9fs_session_info *v9ses, u32 fid,
 */
 int
-v9fs_t_create(struct v9fs_session_info *v9ses, u32 fid, char *name,
+v9fs_t_create(struct v9fs_session_info *v9ses, u32 fid, char *name, u32 perm,
-              u32 perm, u8 mode, struct v9fs_fcall **rcp)
+        u8 mode, char *extension, struct v9fs_fcall **rcp)
 {
        int ret;
        struct v9fs_fcall *tc;
@@ -343,7 +341,9 @@ v9fs_t_create(struct v9fs_session_info *v9ses, u32 fid, char *name,
        dprintk(DEBUG_9P, "fid %d name '%s' perm %x mode %d\n",
                fid, name, perm, mode);
-        tc = v9fs_create_tcreate(fid, name, perm, mode);
+        tc = v9fs_create_tcreate(fid, name, perm, mode, extension,
+                v9ses->extended);
        if (!IS_ERR(tc)) {
                ret = v9fs_mux_rpc(v9ses->mux, tc, rcp);
                kfree(tc);
diff --git a/fs/9p/fcprint.c b/fs/9p/fcprint.c
new file mode 100644
index 000000000000..583e827baebd
--- /dev/null
+++ b/fs/9p/fcprint.c
@@ -0,0 +1,346 @@
+/*
+ *  linux/fs/9p/fcprint.c
+ *
+ *  Print 9P call.
+ *
+ *  Copyright (C) 2005 by Latchesar Ionkov <lucho@ionkov.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2
+ *  as published by the Free Software Foundation.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to:
+ *  Free Software Foundation
+ *  51 Franklin Street, Fifth Floor
+ *  Boston, MA  02111-1301  USA
+ *
+ */
+#include <linux/config.h>
+#include <linux/module.h>
+#include <linux/errno.h>
+#include <linux/fs.h>
+#include <linux/idr.h>
+#include "debug.h"
+#include "v9fs.h"
+#include "9p.h"
+#include "mux.h"
+static int
+v9fs_printqid(char *buf, int buflen, struct v9fs_qid *q)
+{
+        int n;
+        char b[10];
+        n = 0;
+        if (q->type & V9FS_QTDIR)
+                b[n++] = 'd';
+        if (q->type & V9FS_QTAPPEND)
+                b[n++] = 'a';
+        if (q->type & V9FS_QTAUTH)
+                b[n++] = 'A';
+        if (q->type & V9FS_QTEXCL)
+                b[n++] = 'l';
+        if (q->type & V9FS_QTTMP)
+                b[n++] = 't';
+        if (q->type & V9FS_QTSYMLINK)
+                b[n++] = 'L';
+        b[n] = '\0';
+        return scnprintf(buf, buflen, "(%.16llx %x %s)", (long long int) q->path,
+                q->version, b);
+}
+static int
+v9fs_printperm(char *buf, int buflen, int perm)
+{
+        int n;
+        char b[15];
+        n = 0;
+        if (perm & V9FS_DMDIR)
+                b[n++] = 'd';
+        if (perm & V9FS_DMAPPEND)
+                b[n++] = 'a';
+        if (perm & V9FS_DMAUTH)
+                b[n++] = 'A';
+        if (perm & V9FS_DMEXCL)
+                b[n++] = 'l';
+        if (perm & V9FS_DMTMP)
+                b[n++] = 't';
+        if (perm & V9FS_DMDEVICE)
+                b[n++] = 'D';
+        if (perm & V9FS_DMSOCKET)
+                b[n++] = 'S';
+        if (perm & V9FS_DMNAMEDPIPE)
+                b[n++] = 'P';
+        if (perm & V9FS_DMSYMLINK)
+                b[n++] = 'L';
+        b[n] = '\0';
+        return scnprintf(buf, buflen, "%s%03o", b, perm&077);
+}
+static int
+v9fs_printstat(char *buf, int buflen, struct v9fs_stat *st, int extended)
+{
+        int n;
+        n = scnprintf(buf, buflen, "'%.*s' '%.*s'", st->name.len,
+                st->name.str, st->uid.len, st->uid.str);
+        if (extended)
+                n += scnprintf(buf+n, buflen-n, "(%d)", st->n_uid);
+        n += scnprintf(buf+n, buflen-n, " '%.*s'", st->gid.len, st->gid.str);
+        if (extended)
+                n += scnprintf(buf+n, buflen-n, "(%d)", st->n_gid);
+        n += scnprintf(buf+n, buflen-n, " '%.*s'", st->muid.len, st->muid.str);
+        if (extended)
+                n += scnprintf(buf+n, buflen-n, "(%d)", st->n_muid);
+        n += scnprintf(buf+n, buflen-n, " q ");
+        n += v9fs_printqid(buf+n, buflen-n, &st->qid);
+        n += scnprintf(buf+n, buflen-n, " m ");
+        n += v9fs_printperm(buf+n, buflen-n, st->mode);
+        n += scnprintf(buf+n, buflen-n, " at %d mt %d l %lld",
+                st->atime, st->mtime, (long long int) st->length);
+        if (extended)
+                n += scnprintf(buf+n, buflen-n, " ext '%.*s'",
+                        st->extension.len, st->extension.str);
+        return n;
+}
+static int
+v9fs_dumpdata(char *buf, int buflen, u8 *data, int datalen)
+{
+        int i, n;
+        i = n = 0;
+        while (i < datalen) {
+                n += scnprintf(buf + n, buflen - n, "%02x", data[i]);
+                if (i%4 == 3)
+                        n += scnprintf(buf + n, buflen - n, " ");
+                if (i%32 == 31)
+                        n += scnprintf(buf + n, buflen - n, "\n");
+                i++;
+        }
+        n += scnprintf(buf + n, buflen - n, "\n");
+        return n;
+}
+static int
+v9fs_printdata(char *buf, int buflen, u8 *data, int datalen)
+{
+        return v9fs_dumpdata(buf, buflen, data, datalen<16?datalen:16);
+}
+int
+v9fs_printfcall(char *buf, int buflen, struct v9fs_fcall *fc, int extended)
+{
+        int i, ret, type, tag;
+        if (!fc)
+                return scnprintf(buf, buflen, "<NULL>");
+        type = fc->id;
+        tag = fc->tag;
+        ret = 0;
+        switch (type) {
+        case TVERSION:
+                ret += scnprintf(buf+ret, buflen-ret,
+                        "Tversion tag %u msize %u version '%.*s'", tag,
+                        fc->params.tversion.msize, fc->params.tversion.version.len,
+                        fc->params.tversion.version.str);
+                break;
+        case RVERSION:
+                ret += scnprintf(buf+ret, buflen-ret,
+                        "Rversion tag %u msize %u version '%.*s'", tag,
+                        fc->params.rversion.msize, fc->params.rversion.version.len,
+                        fc->params.rversion.version.str);
+                break;
+        case TAUTH:
+                ret += scnprintf(buf+ret, buflen-ret,
+                        "Tauth tag %u afid %d uname '%.*s' aname '%.*s'", tag,
+                        fc->params.tauth.afid, fc->params.tauth.uname.len,
+                        fc->params.tauth.uname.str, fc->params.tauth.aname.len,
+                        fc->params.tauth.aname.str);
+                break;
+        case RAUTH:
+                ret += scnprintf(buf+ret, buflen-ret, "Rauth tag %u qid ", tag);
+                v9fs_printqid(buf+ret, buflen-ret, &fc->params.rauth.qid);
+                break;
+        case TATTACH:
+                ret += scnprintf(buf+ret, buflen-ret,
+                        "Tattach tag %u fid %d afid %d uname '%.*s' aname '%.*s'",
+                        tag, fc->params.tattach.fid, fc->params.tattach.afid,
+                        fc->params.tattach.uname.len, fc->params.tattach.uname.str,
+                        fc->params.tattach.aname.len, fc->params.tattach.aname.str);
+                break;
+        case RATTACH:
+                ret += scnprintf(buf+ret, buflen-ret, "Rattach tag %u qid ", tag);
+                v9fs_printqid(buf+ret, buflen-ret, &fc->params.rattach.qid);
+                break;
+        case RERROR:
+                ret += scnprintf(buf+ret, buflen-ret, "Rerror tag %u ename '%.*s'",
+                        tag, fc->params.rerror.error.len,
+                        fc->params.rerror.error.str);
+                if (extended)
+                        ret += scnprintf(buf+ret, buflen-ret, " ecode %d\n",
+                                fc->params.rerror.errno);
+                break;
+        case TFLUSH:
+                ret += scnprintf(buf+ret, buflen-ret, "Tflush tag %u oldtag %u",
+                        tag, fc->params.tflush.oldtag);
+                break;
+        case RFLUSH:
+                ret += scnprintf(buf+ret, buflen-ret, "Rflush tag %u", tag);
+                break;
+        case TWALK:
+                ret += scnprintf(buf+ret, buflen-ret,
+                        "Twalk tag %u fid %d newfid %d nwname %d", tag,
+                        fc->params.twalk.fid, fc->params.twalk.newfid,
+                        fc->params.twalk.nwname);
+                for(i = 0; i < fc->params.twalk.nwname; i++)
+                        ret += scnprintf(buf+ret, buflen-ret," '%.*s'",
+                                fc->params.twalk.wnames[i].len,
+                                fc->params.twalk.wnames[i].str);
+                break;
+        case RWALK:
+                ret += scnprintf(buf+ret, buflen-ret, "Rwalk tag %u nwqid %d",
+                        tag, fc->params.rwalk.nwqid);
+                for(i = 0; i < fc->params.rwalk.nwqid; i++)
+                        ret += v9fs_printqid(buf+ret, buflen-ret,
+                                &fc->params.rwalk.wqids[i]);
+                break;
+        case TOPEN:
+                ret += scnprintf(buf+ret, buflen-ret,
+                        "Topen tag %u fid %d mode %d", tag,
+                        fc->params.topen.fid, fc->params.topen.mode);
+                break;
+        case ROPEN:
+                ret += scnprintf(buf+ret, buflen-ret, "Ropen tag %u", tag);
+                ret += v9fs_printqid(buf+ret, buflen-ret, &fc->params.ropen.qid);
+                ret += scnprintf(buf+ret, buflen-ret," iounit %d",
+                        fc->params.ropen.iounit);
+                break;
+        case TCREATE:
+                ret += scnprintf(buf+ret, buflen-ret,
+                        "Tcreate tag %u fid %d name '%.*s' perm ", tag,
+                        fc->params.tcreate.fid, fc->params.tcreate.name.len,
+                        fc->params.tcreate.name.str);
+                ret += v9fs_printperm(buf+ret, buflen-ret, fc->params.tcreate.perm);
+                ret += scnprintf(buf+ret, buflen-ret, " mode %d",
+                        fc->params.tcreate.mode);
+                break;
+        case RCREATE:
+                ret += scnprintf(buf+ret, buflen-ret, "Rcreate tag %u", tag);
+                ret += v9fs_printqid(buf+ret, buflen-ret, &fc->params.rcreate.qid);
+                ret += scnprintf(buf+ret, buflen-ret, " iounit %d",
+                        fc->params.rcreate.iounit);
+                break;
+        case TREAD:
+                ret += scnprintf(buf+ret, buflen-ret,
+                        "Tread tag %u fid %d offset %lld count %u", tag,
+                        fc->params.tread.fid,
+                        (long long int) fc->params.tread.offset,
+                        fc->params.tread.count);
+                break;
+        case RREAD:
+                ret += scnprintf(buf+ret, buflen-ret,
+                        "Rread tag %u count %u data ", tag,
+                        fc->params.rread.count);
+                ret += v9fs_printdata(buf+ret, buflen-ret, fc->params.rread.data,
+                        fc->params.rread.count);
+                break;
+        case TWRITE:
+                ret += scnprintf(buf+ret, buflen-ret,
+                        "Twrite tag %u fid %d offset %lld count %u data ",
+                        tag, fc->params.twrite.fid,
+                        (long long int) fc->params.twrite.offset,
+                        fc->params.twrite.count);
+                ret += v9fs_printdata(buf+ret, buflen-ret, fc->params.twrite.data,
+                        fc->params.twrite.count);
+                break;
+        case RWRITE:
+                ret += scnprintf(buf+ret, buflen-ret, "Rwrite tag %u count %u",
+                        tag, fc->params.rwrite.count);
+                break;
+        case TCLUNK:
+                ret += scnprintf(buf+ret, buflen-ret, "Tclunk tag %u fid %d",
+                        tag, fc->params.tclunk.fid);
+                break;
+        case RCLUNK:
+                ret += scnprintf(buf+ret, buflen-ret, "Rclunk tag %u", tag);
+                break;
+        case TREMOVE:
+                ret += scnprintf(buf+ret, buflen-ret, "Tremove tag %u fid %d",
+                        tag, fc->params.tremove.fid);
+                break;
+        case RREMOVE:
+                ret += scnprintf(buf+ret, buflen-ret, "Rremove tag %u", tag);
+                break;
+        case TSTAT:
+                ret += scnprintf(buf+ret, buflen-ret, "Tstat tag %u fid %d",
+                        tag, fc->params.tstat.fid);
+                break;
+        case RSTAT:
+                ret += scnprintf(buf+ret, buflen-ret, "Rstat tag %u ", tag);
+                ret += v9fs_printstat(buf+ret, buflen-ret, &fc->params.rstat.stat,
+                        extended);
+                break;
+        case TWSTAT:
+                ret += scnprintf(buf+ret, buflen-ret, "Twstat tag %u fid %d ",
+                        tag, fc->params.twstat.fid);
+                ret += v9fs_printstat(buf+ret, buflen-ret, &fc->params.twstat.stat,
+                        extended);
+                break;
+        case RWSTAT:
+                ret += scnprintf(buf+ret, buflen-ret, "Rwstat tag %u", tag);
+                break;
+        default:
+                ret += scnprintf(buf+ret, buflen-ret, "unknown type %d", type);
+                break;
+        }
+        return ret;
+}
diff --git a/fs/9p/fid.c b/fs/9p/fid.c
index c4d13bf904d2..b7608af07ce8 100644
--- a/fs/9p/fid.c
+++ b/fs/9p/fid.c
@@ -4,9 +4,8 @@
 *  Copyright (C) 2005, 2006 by Eric Van Hensbergen <ericvh@gmail.com>
 *
 *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
+ *  it under the terms of the GNU General Public License version 2
- *  the Free Software Foundation; either version 2 of the License, or
+ *  as published by the Free Software Foundation.
- *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/fs/9p/fid.h b/fs/9p/fid.h
index 1fc2dd08d75a..aa974d6875c3 100644
--- a/fs/9p/fid.h
+++ b/fs/9p/fid.h
@@ -4,9 +4,8 @@
 *  Copyright (C) 2005 by Eric Van Hensbergen <ericvh@gmail.com>
 *
 *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
+ *  it under the terms of the GNU General Public License version 2
- *  the Free Software Foundation; either version 2 of the License, or
+ *  as published by the Free Software Foundation.
- *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/fs/9p/mux.c b/fs/9p/mux.c
index e2ae60adda99..3e5b124a7212 100644
--- a/fs/9p/mux.c
+++ b/fs/9p/mux.c
@@ -7,9 +7,8 @@
 *  Copyright (C) 2004-2005 by Latchesar Ionkov <lucho@ionkov.net>
 *
 *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
+ *  it under the terms of the GNU General Public License version 2
- *  the Free Software Foundation; either version 2 of the License, or
+ *  as published by the Free Software Foundation.
- *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -70,7 +69,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;
@@ -280,8 +279,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);
+        idr_init(&m->tagpool.pool);
-        init_MUTEX(&m->tidpool.lock);
+        init_MUTEX(&m->tagpool.lock);
        m->err = 0;
        init_waitqueue_head(&m->equeue);
        INIT_LIST_HEAD(&m->req_list);
@@ -635,6 +634,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) {
@@ -740,6 +747,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;
@@ -965,7 +979,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
@@ -974,6 +988,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))
+        if (tag != V9FS_NOTAG && v9fs_check_idpool(tag, &m->tagpool))
-                v9fs_put_idpool(tag, &m->tidpool);
+                v9fs_put_idpool(tag, &m->tagpool);
 }
diff --git a/fs/9p/mux.h b/fs/9p/mux.h
index 17144fdfa11b..e90bfd32ea42 100644
--- a/fs/9p/mux.h
+++ b/fs/9p/mux.h
@@ -7,9 +7,8 @@
 *  Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
 *
 *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
+ *  it under the terms of the GNU General Public License version 2
- *  the Free Software Foundation; either version 2 of the License, or
+ *  as published by the Free Software Foundation.
- *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/fs/9p/trans_fd.c b/fs/9p/trans_fd.c
index 5b2ce21b10fa..94e0a7fd9fc2 100644
--- a/fs/9p/trans_fd.c
+++ b/fs/9p/trans_fd.c
@@ -1,15 +1,16 @@
 /*
 * linux/fs/9p/trans_fd.c
 *
- * File Descriptor Transport Layer
+ * Fd transport layer.  Includes deprecated socket layer.
 *
- *  Copyright (C) 2005 by Latchesar Ionkov <lucho@ionkov.net>
+ *  Copyright (C) 2006 by Russ Cox <rsc@swtch.com>
- *  Copyright (C) 2005 by Eric Van Hensbergen <ericvh@gmail.com>
+ *  Copyright (C) 2004-2005 by Latchesar Ionkov <lucho@ionkov.net>
+ *  Copyright (C) 2004-2005 by Eric Van Hensbergen <ericvh@gmail.com>
+ *  Copyright (C) 1997-2002 by Ron Minnich <rminnich@sarnoff.com>
 *
 *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
+ *  it under the terms of the GNU General Public License version 2
- *  the Free Software Foundation; either version 2 of the License, or
+ *  as published by the Free Software Foundation.
- *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -25,6 +26,7 @@
 */
 #include <linux/config.h>
+#include <linux/in.h>
 #include <linux/module.h>
 #include <linux/net.h>
 #include <linux/ipv6.h>
@@ -40,89 +42,119 @@
 #include "v9fs.h"
 #include "transport.h"
+#define V9FS_PORT 564
 struct v9fs_trans_fd {
-        struct file *in_file;
+        struct file *rd;
-        struct file *out_file;
+        struct file *wr;
 };
 /**
- * v9fs_fd_recv - receive from a socket
+ * v9fs_fd_read- read from a fd
 * @v9ses: session information
 * @v: buffer to receive data into
 * @len: size of receive buffer
 *
 */
+static int v9fs_fd_read(struct v9fs_transport *trans, void *v, int len)
-static int v9fs_fd_recv(struct v9fs_transport *trans, void *v, int len)
 {
-        struct v9fs_trans_fd *ts = trans ? trans->priv : NULL;
+        int ret;
+        struct v9fs_trans_fd *ts;
-        if (!trans || trans->status != Connected || !ts)
+        if (!trans || trans->status == Disconnected || !(ts = trans->priv))
-                return -EIO;
+                return -EREMOTEIO;
-        return kernel_read(ts->in_file, ts->in_file->f_pos, v, len);
+        if (!(ts->rd->f_flags & O_NONBLOCK))
+                dprintk(DEBUG_ERROR, "blocking read ...\n");
+        ret = kernel_read(ts->rd, ts->rd->f_pos, v, len);
+        if (ret <= 0 && ret != -ERESTARTSYS && ret != -EAGAIN)
+                trans->status = Disconnected;
+        return ret;
 }
 /**
- * v9fs_fd_send - send to a socket
+ * v9fs_fd_write - write to a socket
 * @v9ses: session information
 * @v: buffer to send data from
 * @len: size of send buffer
 *
 */
+static int v9fs_fd_write(struct v9fs_transport *trans, void *v, int len)
-static int v9fs_fd_send(struct v9fs_transport *trans, void *v, int len)
 {
-        struct v9fs_trans_fd *ts = trans ? trans->priv : NULL;
+        int ret;
-        mm_segment_t oldfs = get_fs();
+        mm_segment_t oldfs;
-        int ret = 0;
+        struct v9fs_trans_fd *ts;
-        if (!trans || trans->status != Connected || !ts)
+        if (!trans || trans->status == Disconnected || !(ts = trans->priv))
-                return -EIO;
+                return -EREMOTEIO;
+        if (!(ts->wr->f_flags & O_NONBLOCK))
+                dprintk(DEBUG_ERROR, "blocking write ...\n");
        oldfs = get_fs();
        set_fs(get_ds());
        /* The cast to a user pointer is valid due to the set_fs() */
-        ret = vfs_write(ts->out_file, (void __user *)v, len, &ts->out_file->f_pos);
+        ret = vfs_write(ts->wr, (void __user *)v, len, &ts->wr->f_pos);
        set_fs(oldfs);
+        if (ret <= 0 && ret != -ERESTARTSYS && ret != -EAGAIN)
+                trans->status = Disconnected;
        return ret;
 }
-/**
+static unsigned int
- * v9fs_fd_init - initialize file descriptor transport
+v9fs_fd_poll(struct v9fs_transport *trans, struct poll_table_struct *pt)
- * @v9ses: session information
- * @addr: address of server to mount
- * @data: mount options
- *
- */
-static int
-v9fs_fd_init(struct v9fs_session_info *v9ses, const char *addr, char *data)
 {
-        struct v9fs_trans_fd *ts = NULL;
+        int ret, n;
-        struct v9fs_transport *trans = v9ses->transport;
+        struct v9fs_trans_fd *ts;
+        mm_segment_t oldfs;
-        if((v9ses->wfdno == ~0) || (v9ses->rfdno == ~0)) {
+        if (!trans || trans->status != Connected || !(ts = trans->priv))
-                printk(KERN_ERR "v9fs: Insufficient options for proto=fd\n");
+                return -EREMOTEIO;
-                return -ENOPROTOOPT;
-        }
-        ts = kmalloc(sizeof(struct v9fs_trans_fd), GFP_KERNEL);
+        if (!ts->rd->f_op || !ts->rd->f_op->poll)
+                return -EIO;
-        if (!ts)
+        if (!ts->wr->f_op || !ts->wr->f_op->poll)
-                return -ENOMEM;
+                return -EIO;
-        ts->in_file = fget( v9ses->rfdno );
+        oldfs = get_fs();
-        ts->out_file = fget( v9ses->wfdno );
+        set_fs(get_ds());
-        if (!ts->in_file || !ts->out_file) {
+        ret = ts->rd->f_op->poll(ts->rd, pt);
-                if (ts->in_file)
+        if (ret < 0)
-                        fput(ts->in_file);
+                goto end;
-                if (ts->out_file)
+        if (ts->rd != ts->wr) {
-                        fput(ts->out_file);
+                n = ts->wr->f_op->poll(ts->wr, pt);
+                if (n < 0) {
+                        ret = n;
+                        goto end;
+                }
+                ret = (ret & ~POLLOUT) | (n & ~POLLIN);
+        }
+      end:
+        set_fs(oldfs);
+        return ret;
+}
+static int v9fs_fd_open(struct v9fs_session_info *v9ses, int rfd, int wfd)
+{
+        struct v9fs_transport *trans = v9ses->transport;
+        struct v9fs_trans_fd *ts = kmalloc(sizeof(struct v9fs_trans_fd),
+                                           GFP_KERNEL);
+        if (!ts)
+                return -ENOMEM;
+        ts->rd = fget(rfd);
+        ts->wr = fget(wfd);
+        if (!ts->rd || !ts->wr) {
+                if (ts->rd)
+                        fput(ts->rd);
+                if (ts->wr)
+                        fput(ts->wr);
                kfree(ts);
                return -EIO;
        }
@@ -133,84 +165,145 @@ v9fs_fd_init(struct v9fs_session_info *v9ses, const char *addr, char *data)
        return 0;
 }
+static int v9fs_fd_init(struct v9fs_session_info *v9ses, const char *addr,
-/**
+                        char *data)
- * v9fs_fd_close - shutdown file descriptor
- * @trans: private socket structure
- *
- */
-static void v9fs_fd_close(struct v9fs_transport *trans)
 {
-        struct v9fs_trans_fd *ts;
+        if (v9ses->rfdno == ~0 || v9ses->wfdno == ~0) {
+                printk(KERN_ERR "v9fs: Insufficient options for proto=fd\n");
-        if (!trans)
+                return -ENOPROTOOPT;
-                return;
+        }
-        ts = xchg(&trans->priv, NULL);
-        if (!ts)
+        return v9fs_fd_open(v9ses, v9ses->rfdno, v9ses->wfdno);
-                return;
+}
-        trans->status = Disconnected;
+static int v9fs_socket_open(struct v9fs_session_info *v9ses,
-        if (ts->in_file)
+                            struct socket *csocket)
-                fput(ts->in_file);
+{
+        int fd, ret;
+        csocket->sk->sk_allocation = GFP_NOIO;
+        if ((fd = sock_map_fd(csocket)) < 0) {
+                eprintk(KERN_ERR, "v9fs_socket_open: failed to map fd\n");
+                ret = fd;
+              release_csocket:
+                sock_release(csocket);
+                return ret;
+        }
-        if (ts->out_file)
+        if ((ret = v9fs_fd_open(v9ses, fd, fd)) < 0) {
-                fput(ts->out_file);
+                sockfd_put(csocket);
+                eprintk(KERN_ERR, "v9fs_socket_open: failed to open fd\n");
+                goto release_csocket;
+        }
-        kfree(ts);
+        ((struct v9fs_trans_fd *)v9ses->transport->priv)->rd->f_flags |=
+            O_NONBLOCK;
+        return 0;
 }
-static unsigned int
+static int v9fs_tcp_init(struct v9fs_session_info *v9ses, const char *addr,
-v9fs_fd_poll(struct v9fs_transport *trans, struct poll_table_struct *pt)
+                         char *data)
 {
-        int ret, n;
+        int ret;
-        struct v9fs_trans_fd *ts;
+        struct socket *csocket = NULL;
-        mm_segment_t oldfs;
+        struct sockaddr_in sin_server;
+        sin_server.sin_family = AF_INET;
+        sin_server.sin_addr.s_addr = in_aton(addr);
+        sin_server.sin_port = htons(v9ses->port);
+        sock_create_kern(PF_INET, SOCK_STREAM, IPPROTO_TCP, &csocket);
+        if (!csocket) {
+                eprintk(KERN_ERR, "v9fs_trans_tcp: problem creating socket\n");
+                return -1;
+        }
-        if (!trans)
+        ret = csocket->ops->connect(csocket,
-                return -EIO;
+                                    (struct sockaddr *)&sin_server,
+                                    sizeof(struct sockaddr_in), 0);
+        if (ret < 0) {
+                eprintk(KERN_ERR,
+                        "v9fs_trans_tcp: problem connecting socket to %s\n",
+                        addr);
+                return ret;
+        }
-        ts = trans->priv;
+        return v9fs_socket_open(v9ses, csocket);
-        if (trans->status != Connected || !ts)
+}
-                return -EIO;
-        oldfs = get_fs();
+static int
-        set_fs(get_ds());
+v9fs_unix_init(struct v9fs_session_info *v9ses, const char *addr, char *data)
+{
+        int ret;
+        struct socket *csocket;
+        struct sockaddr_un sun_server;
+        if (strlen(addr) > UNIX_PATH_MAX) {
+                eprintk(KERN_ERR, "v9fs_trans_unix: address too long: %s\n",
+                        addr);
+                return -ENAMETOOLONG;
+        }
-        if (!ts->in_file->f_op || !ts->in_file->f_op->poll) {
+        sun_server.sun_family = PF_UNIX;
-                ret = -EIO;
+        strcpy(sun_server.sun_path, addr);
-                goto end;
+        sock_create_kern(PF_UNIX, SOCK_STREAM, 0, &csocket);
+        ret = csocket->ops->connect(csocket, (struct sockaddr *)&sun_server,
+                        sizeof(struct sockaddr_un) - 1, 0);
+        if (ret < 0) {
+                eprintk(KERN_ERR,
+                        "v9fs_trans_unix: problem connecting socket: %s: %d\n",
+                        addr, ret);
+                return ret;
        }
-        ret = ts->in_file->f_op->poll(ts->in_file, pt);
+        return v9fs_socket_open(v9ses, csocket);
+}
-        if (ts->out_file != ts->in_file) {
+/**
-                if (!ts->out_file->f_op || !ts->out_file->f_op->poll) {
+ * v9fs_sock_close - shutdown socket
-                        ret = -EIO;
+ * @trans: private socket structure
-                        goto end;
+ *
-                }
+ */
+static void v9fs_fd_close(struct v9fs_transport *trans)
+{
+        struct v9fs_trans_fd *ts;
-                n = ts->out_file->f_op->poll(ts->out_file, pt);
+        if (!trans)
+                return;
-                ret &= ~POLLOUT;
+        ts = xchg(&trans->priv, NULL);
-                n &= ~POLLIN;
-                ret |= n;
+        if (!ts)
-        }
+                return;
-end:
+        trans->status = Disconnected;
-        set_fs(oldfs);
+        if (ts->rd)
-        return ret;
+                fput(ts->rd);
+        if (ts->wr)
+                fput(ts->wr);
+        kfree(ts);
 }
 struct v9fs_transport v9fs_trans_fd = {
        .init = v9fs_fd_init,
-        .write = v9fs_fd_send,
+        .write = v9fs_fd_write,
-        .read = v9fs_fd_recv,
+        .read = v9fs_fd_read,
        .close = v9fs_fd_close,
        .poll = v9fs_fd_poll,
 };
+struct v9fs_transport v9fs_trans_tcp = {
+        .init = v9fs_tcp_init,
+        .write = v9fs_fd_write,
+        .read = v9fs_fd_read,
+        .close = v9fs_fd_close,
+        .poll = v9fs_fd_poll,
+};
+struct v9fs_transport v9fs_trans_unix = {
+        .init = v9fs_unix_init,
+        .write = v9fs_fd_write,
+        .read = v9fs_fd_read,
+        .close = v9fs_fd_close,
+        .poll = v9fs_fd_poll,
+};
diff --git a/fs/9p/trans_sock.c b/fs/9p/trans_sock.c
deleted file mode 100644
index 44e830697acb..000000000000
--- a/fs/9p/trans_sock.c
+++ /dev/null
@@ -1,334 +0,0 @@
-/*
- * linux/fs/9p/trans_socket.c
- *
- * Socket Transport Layer
- *
- *  Copyright (C) 2004-2005 by Latchesar Ionkov <lucho@ionkov.net>
- *  Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
- *  Copyright (C) 1997-2002 by Ron Minnich <rminnich@sarnoff.com>
- *  Copyright (C) 1995, 1996 by Olaf Kirch <okir@monad.swb.de>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to:
- *  Free Software Foundation
- *  51 Franklin Street, Fifth Floor
- *  Boston, MA  02111-1301  USA
- *
- */
-#include <linux/config.h>
-#include <linux/in.h>
-#include <linux/module.h>
-#include <linux/net.h>
-#include <linux/ipv6.h>
-#include <linux/errno.h>
-#include <linux/kernel.h>
-#include <linux/un.h>
-#include <asm/uaccess.h>
-#include <linux/inet.h>
-#include <linux/idr.h>
-#include <linux/file.h>
-#include "debug.h"
-#include "v9fs.h"
-#include "transport.h"
-#define V9FS_PORT 564
-struct v9fs_trans_sock {
-        struct socket *s;
-        struct file *filp;
-};
-/**
- * v9fs_sock_recv - receive from a socket
- * @v9ses: session information
- * @v: buffer to receive data into
- * @len: size of receive buffer
- *
- */
-static int v9fs_sock_recv(struct v9fs_transport *trans, void *v, int len)
-{
-        int ret;
-        struct v9fs_trans_sock *ts;
-        if (!trans || trans->status == Disconnected) {
-                dprintk(DEBUG_ERROR, "disconnected ...\n");
-                return -EREMOTEIO;
-        }
-        ts = trans->priv;
-        if (!(ts->filp->f_flags & O_NONBLOCK))
-                dprintk(DEBUG_ERROR, "blocking read ...\n");
-        ret = kernel_read(ts->filp, ts->filp->f_pos, v, len);
-        if (ret <= 0) {
-                if (ret != -ERESTARTSYS && ret != -EAGAIN)
-                        trans->status = Disconnected;
-        }
-        return ret;
-}
-/**
- * v9fs_sock_send - send to a socket
- * @v9ses: session information
- * @v: buffer to send data from
- * @len: size of send buffer
- *
- */
-static int v9fs_sock_send(struct v9fs_transport *trans, void *v, int len)
-{
-        int ret;
-        mm_segment_t oldfs;
-        struct v9fs_trans_sock *ts;
-        if (!trans || trans->status == Disconnected) {
-                dprintk(DEBUG_ERROR, "disconnected ...\n");
-                return -EREMOTEIO;
-        }
-        ts = trans->priv;
-        if (!ts) {
-                dprintk(DEBUG_ERROR, "no transport ...\n");
-                return -EREMOTEIO;
-        }
-        if (!(ts->filp->f_flags & O_NONBLOCK))
-                dprintk(DEBUG_ERROR, "blocking write ...\n");
-        oldfs = get_fs();
-        set_fs(get_ds());
-        ret = vfs_write(ts->filp, (void __user *)v, len, &ts->filp->f_pos);
-        set_fs(oldfs);
-        if (ret < 0) {
-                if (ret != -ERESTARTSYS)
-                        trans->status = Disconnected;
-        }
-        return ret;
-}
-static unsigned int v9fs_sock_poll(struct v9fs_transport *trans,
-        struct poll_table_struct *pt) {
-        int ret;
-        struct v9fs_trans_sock *ts;
-        mm_segment_t oldfs;
-        if (!trans) {
-                dprintk(DEBUG_ERROR, "no transport\n");
-                return -EIO;
-        }
-        ts = trans->priv;
-        if (trans->status != Connected || !ts) {
-                dprintk(DEBUG_ERROR, "transport disconnected: %d\n", trans->status);
-                return -EIO;
-        }
-        oldfs = get_fs();
-        set_fs(get_ds());
-        if (!ts->filp->f_op || !ts->filp->f_op->poll) {
-                dprintk(DEBUG_ERROR, "no poll operation\n");
-                ret = -EIO;
-                goto end;
-        }
-        ret = ts->filp->f_op->poll(ts->filp, pt);
-end:
-        set_fs(oldfs);
-        return ret;
-}
-/**
- * v9fs_tcp_init - initialize TCP socket
- * @v9ses: session information
- * @addr: address of server to mount
- * @data: mount options
- *
- */
-static int
-v9fs_tcp_init(struct v9fs_session_info *v9ses, const char *addr, char *data)
-{
-        struct socket *csocket = NULL;
-        struct sockaddr_in sin_server;
-        int rc = 0;
-        struct v9fs_trans_sock *ts = NULL;
-        struct v9fs_transport *trans = v9ses->transport;
-        int fd;
-        trans->status = Disconnected;
-        ts = kmalloc(sizeof(struct v9fs_trans_sock), GFP_KERNEL);
-        if (!ts)
-                return -ENOMEM;
-        trans->priv = ts;
-        ts->s = NULL;
-        ts->filp = NULL;
-        if (!addr)
-                return -EINVAL;
-        dprintk(DEBUG_TRANS, "Connecting to %s\n", addr);
-        sin_server.sin_family = AF_INET;
-        sin_server.sin_addr.s_addr = in_aton(addr);
-        sin_server.sin_port = htons(v9ses->port);
-        sock_create_kern(PF_INET, SOCK_STREAM, IPPROTO_TCP, &csocket);
-        rc = csocket->ops->connect(csocket,
-                                   (struct sockaddr *)&sin_server,
-                                   sizeof(struct sockaddr_in), 0);
-        if (rc < 0) {
-                eprintk(KERN_ERR,
-                        "v9fs_trans_tcp: problem connecting socket to %s\n",
-                        addr);
-                return rc;
-        }
-        csocket->sk->sk_allocation = GFP_NOIO;
-        fd = sock_map_fd(csocket);
-        if (fd < 0) {
-                sock_release(csocket);
-                kfree(ts);
-                trans->priv = NULL;
-                return fd;
-        }
-        ts->s = csocket;
-        ts->filp = fget(fd);
-        ts->filp->f_flags |= O_NONBLOCK;
-        trans->status = Connected;
-        return 0;
-}
-/**
- * v9fs_unix_init - initialize UNIX domain socket
- * @v9ses: session information
- * @dev_name: path to named pipe
- * @data: mount options
- *
- */
-static int
-v9fs_unix_init(struct v9fs_session_info *v9ses, const char *dev_name,
-               char *data)
-{
-        int rc, fd;
-        struct socket *csocket;
-        struct sockaddr_un sun_server;
-        struct v9fs_transport *trans;
-        struct v9fs_trans_sock *ts;
-        rc = 0;
-        csocket = NULL;
-        trans = v9ses->transport;
-        trans->status = Disconnected;
-        if (strlen(dev_name) > UNIX_PATH_MAX) {
-                eprintk(KERN_ERR, "v9fs_trans_unix: address too long: %s\n",
-                        dev_name);
-                return -ENOMEM;
-        }
-        ts = kmalloc(sizeof(struct v9fs_trans_sock), GFP_KERNEL);
-        if (!ts)
-                return -ENOMEM;
-        trans->priv = ts;
-        ts->s = NULL;
-        ts->filp = NULL;
-        sun_server.sun_family = PF_UNIX;
-        strcpy(sun_server.sun_path, dev_name);
-        sock_create_kern(PF_UNIX, SOCK_STREAM, 0, &csocket);
-        rc = csocket->ops->connect(csocket, (struct sockaddr *)&sun_server,
-                sizeof(struct sockaddr_un) - 1, 0);     /* -1 *is* important */
-        if (rc < 0) {
-                eprintk(KERN_ERR,
-                        "v9fs_trans_unix: problem connecting socket: %s: %d\n",
-                        dev_name, rc);
-                return rc;
-        }
-        csocket->sk->sk_allocation = GFP_NOIO;
-        fd = sock_map_fd(csocket);
-        if (fd < 0) {
-                sock_release(csocket);
-                kfree(ts);
-                trans->priv = NULL;
-                return fd;
-        }
-        ts->s = csocket;
-        ts->filp = fget(fd);
-        ts->filp->f_flags |= O_NONBLOCK;
-        trans->status = Connected;
-        return 0;
-}
-/**
- * v9fs_sock_close - shutdown socket
- * @trans: private socket structure
- *
- */
-static void v9fs_sock_close(struct v9fs_transport *trans)
-{
-        struct v9fs_trans_sock *ts;
-        if (!trans)
-                return;
-        ts = trans->priv;
-        if ((ts) && (ts->filp)) {
-                fput(ts->filp);
-                ts->filp = NULL;
-                ts->s = NULL;
-                trans->status = Disconnected;
-        }
-        kfree(ts);
-        trans->priv = NULL;
-}
-struct v9fs_transport v9fs_trans_tcp = {
-        .init = v9fs_tcp_init,
-        .write = v9fs_sock_send,
-        .read = v9fs_sock_recv,
-        .close = v9fs_sock_close,
-        .poll = v9fs_sock_poll,
-};
-struct v9fs_transport v9fs_trans_unix = {
-        .init = v9fs_unix_init,
-        .write = v9fs_sock_send,
-        .read = v9fs_sock_recv,
-        .close = v9fs_sock_close,
-        .poll = v9fs_sock_poll,
-};
diff --git a/fs/9p/transport.h b/fs/9p/transport.h
index 91fcdb94b361..b38a4b8a41ce 100644
--- a/fs/9p/transport.h
+++ b/fs/9p/transport.h
@@ -7,9 +7,8 @@
 *  Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
 *
 *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
+ *  it under the terms of the GNU General Public License version 2
- *  the Free Software Foundation; either version 2 of the License, or
+ *  as published by the Free Software Foundation.
- *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/fs/9p/v9fs.c b/fs/9p/v9fs.c
index 61352491ba36..d37416eb5791 100644
--- a/fs/9p/v9fs.c
+++ b/fs/9p/v9fs.c
@@ -7,9 +7,8 @@
 *  Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
 *
 *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
+ *  it under the terms of the GNU General Public License version 2
- *  the Free Software Foundation; either version 2 of the License, or
+ *  as published by the Free Software Foundation.
- *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -51,7 +50,7 @@ enum {
        Opt_port, Opt_msize, Opt_uid, Opt_gid, Opt_afid, Opt_debug,
        Opt_rfdno, Opt_wfdno,
        /* String options */
-        Opt_name, Opt_remotename,
+        Opt_uname, Opt_remotename,
        /* Options that take no arguments */
        Opt_legacy, Opt_nodevmap, Opt_unix, Opt_tcp, Opt_fd,
        /* Error token */
@@ -67,7 +66,7 @@ static match_table_t tokens = {
        {Opt_rfdno, "rfdno=%u"},
        {Opt_wfdno, "wfdno=%u"},
        {Opt_debug, "debug=%x"},
-        {Opt_name, "name=%s"},
+        {Opt_uname, "uname=%s"},
        {Opt_remotename, "aname=%s"},
        {Opt_unix, "proto=unix"},
        {Opt_tcp, "proto=tcp"},
@@ -116,7 +115,7 @@ static void v9fs_parse_options(char *options, struct v9fs_session_info *v9ses)
                if (!*p)
                        continue;
                token = match_token(p, tokens, args);
-                if (token < Opt_name) {
+                if (token < Opt_uname) {
                        if ((ret = match_int(&args[0], &option)) < 0) {
                                dprintk(DEBUG_ERROR,
                                        "integer field, but no integer?\n");
@@ -158,7 +157,7 @@ static void v9fs_parse_options(char *options, struct v9fs_session_info *v9ses)
                case Opt_fd:
                        v9ses->proto = PROTO_FD;
                        break;
-                case Opt_name:
+                case Opt_uname:
                        match_strcpy(v9ses->name, &args[0]);
                        break;
                case Opt_remotename:
@@ -289,7 +288,7 @@ v9fs_session_init(struct v9fs_session_info *v9ses,
        /* set global debug level */
        v9fs_debug_level = v9ses->debug;
-        /* id pools that are session-dependent: FIDs and TIDs */
+        /* id pools that are session-dependent: fids and tags */
        idr_init(&v9ses->fidpool.pool);
        init_MUTEX(&v9ses->fidpool.lock);
diff --git a/fs/9p/v9fs.h b/fs/9p/v9fs.h
index f337da7a0eec..c134d104cb28 100644
--- a/fs/9p/v9fs.h
+++ b/fs/9p/v9fs.h
@@ -5,9 +5,8 @@
 *  Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
 *
 *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
+ *  it under the terms of the GNU General Public License version 2
- *  the Free Software Foundation; either version 2 of the License, or
+ *  as published by the Free Software Foundation.
- *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -91,6 +90,3 @@ void v9fs_session_cancel(struct v9fs_session_info *v9ses);
 #define V9FS_DEFUSER    "nobody"
 #define V9FS_DEFANAME   ""
-/* inital pool sizes for fids and tags */
-#define V9FS_START_FIDS 8192
-#define V9FS_START_TIDS 256
diff --git a/fs/9p/v9fs_vfs.h b/fs/9p/v9fs_vfs.h
index a759278acaae..43c9f7de0314 100644
--- a/fs/9p/v9fs_vfs.h
+++ b/fs/9p/v9fs_vfs.h
@@ -5,9 +5,8 @@
 *  Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
 *
 *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
+ *  it under the terms of the GNU General Public License version 2
- *  the Free Software Foundation; either version 2 of the License, or
+ *  as published by the Free Software Foundation.
- *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/fs/9p/vfs_addr.c b/fs/9p/vfs_addr.c
index 8100fb5171b7..efda46fb64d9 100644
--- a/fs/9p/vfs_addr.c
+++ b/fs/9p/vfs_addr.c
@@ -7,9 +7,8 @@
 *  Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
 *
 *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
+ *  it under the terms of the GNU General Public License version 2
- *  the Free Software Foundation; either version 2 of the License, or
+ *  as published by the Free Software Foundation.
- *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/fs/9p/vfs_dentry.c b/fs/9p/vfs_dentry.c
index 12c9cc926b71..062daa6000ab 100644
--- a/fs/9p/vfs_dentry.c
+++ b/fs/9p/vfs_dentry.c
@@ -7,9 +7,8 @@
 *  Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
 *
 *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
+ *  it under the terms of the GNU General Public License version 2
- *  the Free Software Foundation; either version 2 of the License, or
+ *  as published by the Free Software Foundation.
- *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -51,7 +50,7 @@
 *
 */
-int v9fs_dentry_delete(struct dentry *dentry)
+static int v9fs_dentry_delete(struct dentry *dentry)
 {
        dprintk(DEBUG_VFS, " dentry: %s (%p)\n", dentry->d_iname, dentry);
        return 1;
diff --git a/fs/9p/vfs_dir.c b/fs/9p/vfs_dir.c
index cd5eeb032d64..766f11f1215c 100644
--- a/fs/9p/vfs_dir.c
+++ b/fs/9p/vfs_dir.c
@@ -7,9 +7,8 @@
 *  Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
 *
 *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
+ *  it under the terms of the GNU General Public License version 2
- *  the Free Software Foundation; either version 2 of the License, or
+ *  as published by the Free Software Foundation.
- *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/fs/9p/vfs_file.c b/fs/9p/vfs_file.c
index de3a129698da..59e744163407 100644
--- a/fs/9p/vfs_file.c
+++ b/fs/9p/vfs_file.c
@@ -7,9 +7,8 @@
 *  Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
 *
 *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
+ *  it under the terms of the GNU General Public License version 2
- *  the Free Software Foundation; either version 2 of the License, or
+ *  as published by the Free Software Foundation.
- *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -69,29 +68,30 @@ int v9fs_file_open(struct inode *inode, struct file *file)
        fid = v9fs_get_idpool(&v9ses->fidpool);
        if (fid < 0) {
-                        eprintk(KERN_WARNING, "newfid fails!\n");
+                eprintk(KERN_WARNING, "newfid fails!\n");
-                        return -ENOSPC;
+                return -ENOSPC;
-                }
+        }
        err = v9fs_t_walk(v9ses, vfid->fid, fid, NULL, NULL);
        if (err < 0) {
-                        dprintk(DEBUG_ERROR, "rewalk didn't work\n");
+                dprintk(DEBUG_ERROR, "rewalk didn't work\n");
                goto put_fid;
        }
-        vfid = kmalloc(sizeof(struct v9fs_fid), GFP_KERNEL);
+        /* TODO: do special things for O_EXCL, O_NOFOLLOW, O_SYNC */
-        if (vfid == NULL) {
+        /* translate open mode appropriately */
-                dprintk(DEBUG_ERROR, "out of memory\n");
-                goto clunk_fid;
-                }
-                /* TODO: do special things for O_EXCL, O_NOFOLLOW, O_SYNC */
-                /* translate open mode appropriately */
        omode = v9fs_uflags2omode(file->f_flags);
        err = v9fs_t_open(v9ses, fid, omode, &fcall);
        if (err < 0) {
                PRINT_FCALL_ERROR("open failed", fcall);
-                goto destroy_vfid;
+                goto clunk_fid;
+        }
+        vfid = kmalloc(sizeof(struct v9fs_fid), GFP_KERNEL);
+        if (vfid == NULL) {
+                dprintk(DEBUG_ERROR, "out of memory\n");
+                err = -ENOMEM;
+                goto clunk_fid;
        }
        file->private_data = vfid;
@@ -106,15 +106,12 @@ int v9fs_file_open(struct inode *inode, struct file *file)
        return 0;
-destroy_vfid:
-        v9fs_fid_destroy(vfid);
 clunk_fid:
        v9fs_t_clunk(v9ses, fid);
 put_fid:
        v9fs_put_idpool(fid, &v9ses->fidpool);
-                kfree(fcall);
+        kfree(fcall);
        return err;
 }
diff --git a/fs/9p/vfs_inode.c b/fs/9p/vfs_inode.c
index 651a9e14d9a9..133db366d306 100644
--- a/fs/9p/vfs_inode.c
+++ b/fs/9p/vfs_inode.c
@@ -7,9 +7,8 @@
 *  Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
 *
 *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
+ *  it under the terms of the GNU General Public License version 2
- *  the Free Software Foundation; either version 2 of the License, or
+ *  as published by the Free Software Foundation.
- *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -255,8 +254,8 @@ struct inode *v9fs_get_inode(struct super_block *sb, int mode)
 }
 static int
-v9fs_create(struct v9fs_session_info *v9ses, u32 pfid, char *name,
+v9fs_create(struct v9fs_session_info *v9ses, u32 pfid, char *name, u32 perm,
-        u32 perm, u8 mode, u32 *fidp, struct v9fs_qid *qid, u32 *iounit)
+        u8 mode, char *extension, u32 *fidp, struct v9fs_qid *qid, u32 *iounit)
 {
        u32 fid;
        int err;
@@ -271,14 +270,14 @@ v9fs_create(struct v9fs_session_info *v9ses, u32 pfid, char *name,
        err = v9fs_t_walk(v9ses, pfid, fid, NULL, &fcall);
        if (err < 0) {
                PRINT_FCALL_ERROR("clone error", fcall);
-                goto error;
+                goto put_fid;
        }
        kfree(fcall);
-        err = v9fs_t_create(v9ses, fid, name, perm, mode, &fcall);
+        err = v9fs_t_create(v9ses, fid, name, perm, mode, extension, &fcall);
        if (err < 0) {
                PRINT_FCALL_ERROR("create fails", fcall);
-                goto error;
+                goto clunk_fid;
        }
        if (iounit)
@@ -293,7 +292,11 @@ v9fs_create(struct v9fs_session_info *v9ses, u32 pfid, char *name,
        kfree(fcall);
        return 0;
-error:
+clunk_fid:
+        v9fs_t_clunk(v9ses, fid);
+        fid = V9FS_NOFID;
+put_fid:
        if (fid >= 0)
                v9fs_put_idpool(fid, &v9ses->fidpool);
@@ -348,7 +351,7 @@ error:
        return ERR_PTR(err);
 }
-struct inode *
+static struct inode *
 v9fs_inode_from_fid(struct v9fs_session_info *v9ses, u32 fid,
        struct super_block *sb)
 {
@@ -474,7 +477,7 @@ v9fs_vfs_create(struct inode *dir, struct dentry *dentry, int mode,
                flags = O_RDWR;
        err = v9fs_create(v9ses, dfid->fid, (char *) dentry->d_name.name,
-                perm, v9fs_uflags2omode(flags), &fid, &qid, &iounit);
+                perm, v9fs_uflags2omode(flags), NULL, &fid, &qid, &iounit);
        if (err)
                goto error;
@@ -550,7 +553,7 @@ static int v9fs_vfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
        perm = unixmode2p9mode(v9ses, mode | S_IFDIR);
        err = v9fs_create(v9ses, dfid->fid, (char *) dentry->d_name.name,
-                perm, V9FS_OREAD, &fid, NULL, NULL);
+                perm, V9FS_OREAD, NULL, &fid, NULL, NULL);
        if (err) {
                dprintk(DEBUG_ERROR, "create error %d\n", err);
@@ -1008,11 +1011,13 @@ static int v9fs_readlink(struct dentry *dentry, char *buffer, int buflen)
        /* copy extension buffer into buffer */
        if (fcall->params.rstat.stat.extension.len < buflen)
-                buflen = fcall->params.rstat.stat.extension.len;
+                buflen = fcall->params.rstat.stat.extension.len + 1;
-        memcpy(buffer, fcall->params.rstat.stat.extension.str, buflen - 1);
+        memmove(buffer, fcall->params.rstat.stat.extension.str, buflen - 1);
        buffer[buflen-1] = 0;
+        dprintk(DEBUG_ERROR, "%s -> %.*s (%s)\n", dentry->d_name.name, fcall->params.rstat.stat.extension.len,
+                fcall->params.rstat.stat.extension.str, buffer);
        retval = buflen;
      FreeFcall:
@@ -1072,7 +1077,7 @@ static void *v9fs_vfs_follow_link(struct dentry *dentry, struct nameidata *nd)
        if (!link)
                link = ERR_PTR(-ENOMEM);
        else {
-                len = v9fs_readlink(dentry, link, strlen(link));
+                len = v9fs_readlink(dentry, link, PATH_MAX);
                if (len < 0) {
                        __putname(link);
@@ -1109,10 +1114,7 @@ static int v9fs_vfs_mkspecial(struct inode *dir, struct dentry *dentry,
        struct v9fs_session_info *v9ses;
        struct v9fs_fid *dfid, *vfid;
        struct inode *inode;
-        struct v9fs_fcall *fcall;
-        struct v9fs_wstat wstat;
-        fcall = NULL;
        inode = NULL;
        vfid = NULL;
        v9ses = v9fs_inode2v9ses(dir);
@@ -1125,7 +1127,7 @@ static int v9fs_vfs_mkspecial(struct inode *dir, struct dentry *dentry,
        }
        err = v9fs_create(v9ses, dfid->fid, (char *) dentry->d_name.name,
-                perm, V9FS_OREAD, &fid, NULL, NULL);
+                perm, V9FS_OREAD, (char *) extension, &fid, NULL, NULL);
        if (err)
                goto error;
@@ -1148,23 +1150,11 @@ static int v9fs_vfs_mkspecial(struct inode *dir, struct dentry *dentry,
                goto error;
        }
-        /* issue a Twstat */
-        v9fs_blank_wstat(&wstat);
-        wstat.muid = v9ses->name;
-        wstat.extension = (char *) extension;
-        err = v9fs_t_wstat(v9ses, vfid->fid, &wstat, &fcall);
-        if (err < 0) {
-                PRINT_FCALL_ERROR("wstat error", fcall);
-                goto error;
-        }
-        kfree(fcall);
        dentry->d_op = &v9fs_dentry_operations;
        d_instantiate(dentry, inode);
        return 0;
 error:
-        kfree(fcall);
        if (vfid)
                v9fs_fid_destroy(vfid);
@@ -1224,7 +1214,7 @@ v9fs_vfs_link(struct dentry *old_dentry, struct inode *dir,
        }
        name = __getname();
-        sprintf(name, "hardlink(%d)\n", oldfid->fid);
+        sprintf(name, "%d\n", oldfid->fid);
        retval = v9fs_vfs_mkspecial(dir, dentry, V9FS_DMLINK, name);
        __putname(name);
@@ -1253,6 +1243,8 @@ v9fs_vfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t rdev)
                return -EINVAL;
        name = __getname();
+        if (!name)
+                return -ENOMEM;
        /* build extension */
        if (S_ISBLK(mode))
                sprintf(name, "b %u %u", MAJOR(rdev), MINOR(rdev));
diff --git a/fs/9p/vfs_super.c b/fs/9p/vfs_super.c
index d05318fa684e..b0a0ae509c00 100644
--- a/fs/9p/vfs_super.c
+++ b/fs/9p/vfs_super.c
@@ -8,9 +8,8 @@
 *  Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
 *
 *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
+ *  it under the terms of the GNU General Public License version 2
- *  the Free Software Foundation; either version 2 of the License, or
+ *  as published by the Free Software Foundation.
- *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -262,7 +261,7 @@ static struct super_operations v9fs_super_ops = {
 };
 struct file_system_type v9fs_fs_type = {
-        .name = "9P",
+        .name = "9p",
        .get_sb = v9fs_get_sb,
        .kill_sb = v9fs_kill_super,
        .owner = THIS_MODULE,
diff --git a/fs/aio.c b/fs/aio.c
index aec2b1916d1b..e41e932ba489 100644
--- a/fs/aio.c
+++ b/fs/aio.c
@@ -122,10 +122,9 @@ static int aio_setup_ring(struct kioctx *ctx)
        info->nr = 0;
        info->ring_pages = info->internal_pages;
        if (nr_pages > AIO_RING_PAGES) {
-                info->ring_pages = kmalloc(sizeof(struct page *) * nr_pages, GFP_KERNEL);
+                info->ring_pages = kcalloc(nr_pages, sizeof(struct page *), GFP_KERNEL);
                if (!info->ring_pages)
                        return -ENOMEM;
-                memset(info->ring_pages, 0, sizeof(struct page *) * nr_pages);
        }
        info->mmap_size = nr_pages * PAGE_SIZE;
diff --git a/fs/binfmt_elf.c b/fs/binfmt_elf.c
index c2eac2a50bd2..4349113881fb 100644
--- a/fs/binfmt_elf.c
+++ b/fs/binfmt_elf.c
@@ -1334,7 +1334,7 @@ static int fill_psinfo(struct elf_prpsinfo *psinfo, struct task_struct *p,
        i = p->state ? ffz(~p->state) + 1 : 0;
        psinfo->pr_state = i;
-        psinfo->pr_sname = (i < 0 || i > 5) ? '.' : "RSDTZW"[i];
+        psinfo->pr_sname = (i > 5) ? '.' : "RSDTZW"[i];
        psinfo->pr_zomb = psinfo->pr_sname == 'Z';
        psinfo->pr_nice = task_nice(p);
        psinfo->pr_flag = p->flags;
@@ -1465,12 +1465,11 @@ static int elf_core_dump(long signr, struct pt_regs * regs, struct file * file)
                read_lock(&tasklist_lock);
                do_each_thread(g,p)
                        if (current->mm == p->mm && current != p) {
-                                tmp = kmalloc(sizeof(*tmp), GFP_ATOMIC);
+                                tmp = kzalloc(sizeof(*tmp), GFP_ATOMIC);
                                if (!tmp) {
                                        read_unlock(&tasklist_lock);
                                        goto cleanup;
                                }
-                                memset(tmp, 0, sizeof(*tmp));
                                INIT_LIST_HEAD(&tmp->list);
                                tmp->thread = p;
                                list_add(&tmp->list, &thread_list);
diff --git a/fs/binfmt_flat.c b/fs/binfmt_flat.c
index 108d56bbd0d0..69f44dcdb0b4 100644
--- a/fs/binfmt_flat.c
+++ b/fs/binfmt_flat.c
@@ -36,6 +36,7 @@
 #include <linux/personality.h>
 #include <linux/init.h>
 #include <linux/flat.h>
+#include <linux/syscalls.h>
 #include <asm/byteorder.h>
 #include <asm/system.h>
@@ -426,6 +427,8 @@ static int load_flat_file(struct linux_binprm * bprm,
        int i, rev, relocs = 0;
        loff_t fpos;
        unsigned long start_code, end_code;
+        int ret;
+        int exec_fileno;
        hdr = ((struct flat_hdr *) bprm->buf);          /* exec-header */
        inode = bprm->file->f_dentry->d_inode;
@@ -450,7 +453,8 @@ static int load_flat_file(struct linux_binprm * bprm,
                 */
                if (strncmp(hdr->magic, "#!", 2))
                        printk("BINFMT_FLAT: bad header magic\n");
-                return -ENOEXEC;
+                ret = -ENOEXEC;
+                goto err;
        }
        if (flags & FLAT_FLAG_KTRACE)
@@ -458,14 +462,16 @@ static int load_flat_file(struct linux_binprm * bprm,
        if (rev != FLAT_VERSION && rev != OLD_FLAT_VERSION) {
                printk("BINFMT_FLAT: bad flat file version 0x%x (supported 0x%x and 0x%x)\n", rev, FLAT_VERSION, OLD_FLAT_VERSION);
-                return -ENOEXEC;
+                ret = -ENOEXEC;
+                goto err;
        }
        
        /* Don't allow old format executables to use shared libraries */
        if (rev == OLD_FLAT_VERSION && id != 0) {
                printk("BINFMT_FLAT: shared libraries are not available before rev 0x%x\n",
                                (int) FLAT_VERSION);
-                return -ENOEXEC;
+                ret = -ENOEXEC;
+                goto err;
        }
        /*
@@ -478,7 +484,8 @@ static int load_flat_file(struct linux_binprm * bprm,
 #ifndef CONFIG_BINFMT_ZFLAT
        if (flags & (FLAT_FLAG_GZIP|FLAT_FLAG_GZDATA)) {
                printk("Support for ZFLAT executables is not enabled.\n");
-                return -ENOEXEC;
+                ret = -ENOEXEC;
+                goto err;
        }
 #endif
@@ -490,14 +497,27 @@ static int load_flat_file(struct linux_binprm * bprm,
        rlim = current->signal->rlim[RLIMIT_DATA].rlim_cur;
        if (rlim >= RLIM_INFINITY)
                rlim = ~0;
-        if (data_len + bss_len > rlim)
+        if (data_len + bss_len > rlim) {
-                return -ENOMEM;
+                ret = -ENOMEM;
+                goto err;
+        }
+        /* check file descriptor */
+        exec_fileno = get_unused_fd();
+        if (exec_fileno < 0) {
+                ret = -EMFILE;
+                goto err;
+        }
+        get_file(bprm->file);
+        fd_install(exec_fileno, bprm->file);
        /* Flush all traces of the currently running executable */
        if (id == 0) {
                result = flush_old_exec(bprm);
-                if (result)
+                if (result) {
-                        return result;
+                        ret = result;
+                        goto err_close;
+                }
                /* OK, This is the point of no return */
                set_personality(PER_LINUX);
@@ -527,7 +547,8 @@ static int load_flat_file(struct linux_binprm * bprm,
                        if (!textpos)
                                textpos = (unsigned long) -ENOMEM;
                        printk("Unable to mmap process text, errno %d\n", (int)-textpos);
-                        return(textpos);
+                        ret = textpos;
+                        goto err_close;
                }
                down_write(&current->mm->mmap_sem);
@@ -542,7 +563,8 @@ static int load_flat_file(struct linux_binprm * bprm,
                        printk("Unable to allocate RAM for process data, errno %d\n",
                                        (int)-datapos);
                        do_munmap(current->mm, textpos, text_len);
-                        return realdatastart;
+                        ret = realdatastart;
+                        goto err_close;
                }
                datapos = realdatastart + MAX_SHARED_LIBS * sizeof(unsigned long);
@@ -564,7 +586,8 @@ static int load_flat_file(struct linux_binprm * bprm,
                        printk("Unable to read data+bss, errno %d\n", (int)-result);
                        do_munmap(current->mm, textpos, text_len);
                        do_munmap(current->mm, realdatastart, data_len + extra);
-                        return result;
+                        ret = result;
+                        goto err_close;
                }
                reloc = (unsigned long *) (datapos+(ntohl(hdr->reloc_start)-text_len));
@@ -582,7 +605,8 @@ static int load_flat_file(struct linux_binprm * bprm,
                                textpos = (unsigned long) -ENOMEM;
                        printk("Unable to allocate RAM for process text/data, errno %d\n",
                                        (int)-textpos);
-                        return(textpos);
+                        ret = textpos;
+                        goto err_close;
                }
                realdatastart = textpos + ntohl(hdr->data_start);
@@ -627,7 +651,8 @@ static int load_flat_file(struct linux_binprm * bprm,
                        printk("Unable to read code+data+bss, errno %d\n",(int)-result);
                        do_munmap(current->mm, textpos, text_len + data_len + extra +
                                MAX_SHARED_LIBS * sizeof(unsigned long));
-                        return result;
+                        ret = result;
+                        goto err_close;
                }
        }
@@ -690,8 +715,10 @@ static int load_flat_file(struct linux_binprm * bprm,
                        unsigned long addr;
                        if (*rp) {
                                addr = calc_reloc(*rp, libinfo, id, 0);
-                                if (addr == RELOC_FAILED)
+                                if (addr == RELOC_FAILED) {
-                                        return -ENOEXEC;
+                                        ret = -ENOEXEC;
+                                        goto err_close;
+                                }
                                *rp = addr;
                        }
                }
@@ -718,8 +745,10 @@ static int load_flat_file(struct linux_binprm * bprm,
                        relval = ntohl(reloc[i]);
                        addr = flat_get_relocate_addr(relval);
                        rp = (unsigned long *) calc_reloc(addr, libinfo, id, 1);
-                        if (rp == (unsigned long *)RELOC_FAILED)
+                        if (rp == (unsigned long *)RELOC_FAILED) {
-                                return -ENOEXEC;
+                                ret = -ENOEXEC;
+                                goto err_close;
+                        }
                        /* Get the pointer's value.  */
                        addr = flat_get_addr_from_rp(rp, relval, flags);
@@ -731,8 +760,10 @@ static int load_flat_file(struct linux_binprm * bprm,
                                if ((flags & FLAT_FLAG_GOTPIC) == 0)
                                        addr = ntohl(addr);
                                addr = calc_reloc(addr, libinfo, id, 0);
-                                if (addr == RELOC_FAILED)
+                                if (addr == RELOC_FAILED) {
-                                        return -ENOEXEC;
+                                        ret = -ENOEXEC;
+                                        goto err_close;
+                                }
                                /* Write back the relocated pointer.  */
                                flat_put_addr_at_rp(rp, addr, relval);
@@ -752,6 +783,10 @@ static int load_flat_file(struct linux_binprm * bprm,
                        stack_len);
        return 0;
+err_close:
+        sys_close(exec_fileno);
+err:
+        return ret;
 }
diff --git a/fs/bio.c b/fs/bio.c
index 0a8c59cb68f5..73e664c01d30 100644
--- a/fs/bio.c
+++ b/fs/bio.c
@@ -636,12 +636,10 @@ static struct bio *__bio_map_user_iov(request_queue_t *q,
                return ERR_PTR(-ENOMEM);
        ret = -ENOMEM;
-        pages = kmalloc(nr_pages * sizeof(struct page *), GFP_KERNEL);
+        pages = kcalloc(nr_pages, sizeof(struct page *), GFP_KERNEL);
        if (!pages)
                goto out;
-        memset(pages, 0, nr_pages * sizeof(struct page *));
        for (i = 0; i < iov_count; i++) {
                unsigned long uaddr = (unsigned long)iov[i].iov_base;
                unsigned long len = iov[i].iov_len;
@@ -1186,12 +1184,11 @@ void bioset_free(struct bio_set *bs)
 struct bio_set *bioset_create(int bio_pool_size, int bvec_pool_size, int scale)
 {
-        struct bio_set *bs = kmalloc(sizeof(*bs), GFP_KERNEL);
+        struct bio_set *bs = kzalloc(sizeof(*bs), GFP_KERNEL);
        if (!bs)
                return NULL;
-        memset(bs, 0, sizeof(*bs));
        bs->bio_pool = mempool_create(bio_pool_size, mempool_alloc_slab,
                        mempool_free_slab, bio_slab);
diff --git a/fs/buffer.c b/fs/buffer.c
index 6d77ce9f54e5..3b3ab5281920 100644
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -160,12 +160,7 @@ int sync_blockdev(struct block_device *bdev)
 }
 EXPORT_SYMBOL(sync_blockdev);
-/*
+static void __fsync_super(struct super_block *sb)
- * Write out and wait upon all dirty data associated with this
- * superblock.  Filesystem data as well as the underlying block
- * device.  Takes the superblock lock.
- */
-int fsync_super(struct super_block *sb)
 {
        sync_inodes_sb(sb, 0);
        DQUOT_SYNC(sb);
@@ -177,7 +172,16 @@ int fsync_super(struct super_block *sb)
                sb->s_op->sync_fs(sb, 1);
        sync_blockdev(sb->s_bdev);
        sync_inodes_sb(sb, 1);
+}
+/*
+ * Write out and wait upon all dirty data associated with this
+ * superblock.  Filesystem data as well as the underlying block
+ * device.  Takes the superblock lock.
+ */
+int fsync_super(struct super_block *sb)
+{
+        __fsync_super(sb);
        return sync_blockdev(sb->s_bdev);
 }
@@ -216,19 +220,7 @@ struct super_block *freeze_bdev(struct block_device *bdev)
                sb->s_frozen = SB_FREEZE_WRITE;
                smp_wmb();
-                sync_inodes_sb(sb, 0);
+                __fsync_super(sb);
-                DQUOT_SYNC(sb);
-                lock_super(sb);
-                if (sb->s_dirt && sb->s_op->write_super)
-                        sb->s_op->write_super(sb);
-                unlock_super(sb);
-                if (sb->s_op->sync_fs)
-                        sb->s_op->sync_fs(sb, 1);
-                sync_blockdev(sb->s_bdev);
-                sync_inodes_sb(sb, 1);
                sb->s_frozen = SB_FREEZE_TRANS;
                smp_wmb();
diff --git a/fs/char_dev.c b/fs/char_dev.c
index 5c36345c9bf7..8c6eb04d31e2 100644
--- a/fs/char_dev.c
+++ b/fs/char_dev.c
@@ -146,12 +146,10 @@ __register_chrdev_region(unsigned int major, unsigned int baseminor,
        int ret = 0;
        int i;
-        cd = kmalloc(sizeof(struct char_device_struct), GFP_KERNEL);
+        cd = kzalloc(sizeof(struct char_device_struct), GFP_KERNEL);
        if (cd == NULL)
                return ERR_PTR(-ENOMEM);
-        memset(cd, 0, sizeof(struct char_device_struct));
        mutex_lock(&chrdevs_lock);
        /* temporary */
@@ -466,9 +464,8 @@ static struct kobj_type ktype_cdev_dynamic = {
 struct cdev *cdev_alloc(void)
 {
-        struct cdev *p = kmalloc(sizeof(struct cdev), GFP_KERNEL);
+        struct cdev *p = kzalloc(sizeof(struct cdev), GFP_KERNEL);
        if (p) {
-                memset(p, 0, sizeof(struct cdev));
                p->kobj.ktype = &ktype_cdev_dynamic;
                INIT_LIST_HEAD(&p->list);
                kobject_init(&p->kobj);
diff --git a/fs/compat.c b/fs/compat.c
index 2a88477330fc..ef5a0771592d 100644
--- a/fs/compat.c
+++ b/fs/compat.c
@@ -1476,10 +1476,9 @@ int compat_do_execve(char * filename,
        int i;
        retval = -ENOMEM;
-        bprm = kmalloc(sizeof(*bprm), GFP_KERNEL);
+        bprm = kzalloc(sizeof(*bprm), GFP_KERNEL);
        if (!bprm)
                goto out_ret;
-        memset(bprm, 0, sizeof(*bprm));
        file = open_exec(filename);
        retval = PTR_ERR(file);
@@ -2170,9 +2169,12 @@ asmlinkage long compat_sys_nfsservctl(int cmd, struct compat_nfsctl_arg __user *
        default:
                err = -EINVAL;
-                goto done;
+                break;
        }
+        if (err)
+                goto done;
        oldfs = get_fs();
        set_fs(KERNEL_DS);
        /* The __user pointer casts are valid because of the set_fs() */
diff --git a/fs/dcache.c b/fs/dcache.c
index 653f64ce98e2..939584648504 100644
--- a/fs/dcache.c
+++ b/fs/dcache.c
@@ -325,10 +325,13 @@ static struct dentry * __d_find_alias(struct inode *inode, int want_discon)
 struct dentry * d_find_alias(struct inode *inode)
 {
-        struct dentry *de;
+        struct dentry *de = NULL;
-        spin_lock(&dcache_lock);
-        de = __d_find_alias(inode, 0);
+        if (!list_empty(&inode->i_dentry)) {
-        spin_unlock(&dcache_lock);
+                spin_lock(&dcache_lock);
+                de = __d_find_alias(inode, 0);
+                spin_unlock(&dcache_lock);
+        }
        return de;
 }
@@ -486,6 +489,7 @@ repeat:
                        continue;
                }
                prune_one_dentry(dentry);
+                cond_resched_lock(&dcache_lock);
                goto repeat;
        }
        spin_unlock(&dcache_lock);
@@ -799,6 +803,7 @@ void d_instantiate(struct dentry *entry, struct inode * inode)
        if (inode)
                list_add(&entry->d_alias, &inode->i_dentry);
        entry->d_inode = inode;
+        fsnotify_d_instantiate(entry, inode);
        spin_unlock(&dcache_lock);
        security_d_instantiate(entry, inode);
 }
@@ -850,6 +855,7 @@ struct dentry *d_instantiate_unique(struct dentry *entry, struct inode *inode)
        list_add(&entry->d_alias, &inode->i_dentry);
 do_negative:
        entry->d_inode = inode;
+        fsnotify_d_instantiate(entry, inode);
        spin_unlock(&dcache_lock);
        security_d_instantiate(entry, inode);
        return NULL;
@@ -980,6 +986,7 @@ struct dentry *d_splice_alias(struct inode *inode, struct dentry *dentry)
                new = __d_find_alias(inode, 1);
                if (new) {
                        BUG_ON(!(new->d_flags & DCACHE_DISCONNECTED));
+                        fsnotify_d_instantiate(new, inode);
                        spin_unlock(&dcache_lock);
                        security_d_instantiate(new, inode);
                        d_rehash(dentry);
@@ -989,6 +996,7 @@ struct dentry *d_splice_alias(struct inode *inode, struct dentry *dentry)
                        /* d_instantiate takes dcache_lock, so we do it by hand */
                        list_add(&dentry->d_alias, &inode->i_dentry);
                        dentry->d_inode = inode;
+                        fsnotify_d_instantiate(dentry, inode);
                        spin_unlock(&dcache_lock);
                        security_d_instantiate(dentry, inode);
                        d_rehash(dentry);
@@ -1173,6 +1181,9 @@ void d_delete(struct dentry * dentry)
        spin_lock(&dentry->d_lock);
        isdir = S_ISDIR(dentry->d_inode->i_mode);
        if (atomic_read(&dentry->d_count) == 1) {
+                /* remove this and other inotify debug checks after 2.6.18 */
+                dentry->d_flags &= ~DCACHE_INOTIFY_PARENT_WATCHED;
                dentry_iput(dentry);
                fsnotify_nameremove(dentry, isdir);
                return;
@@ -1339,6 +1350,7 @@ already_unhashed:
        list_add(&dentry->d_u.d_child, &dentry->d_parent->d_subdirs);
        spin_unlock(&target->d_lock);
+        fsnotify_d_move(dentry);
        spin_unlock(&dentry->d_lock);
        write_sequnlock(&rename_lock);
        spin_unlock(&dcache_lock);
diff --git a/fs/direct-io.c b/fs/direct-io.c
index 27f3e787faca..235ed8d1f11e 100644
--- a/fs/direct-io.c
+++ b/fs/direct-io.c
@@ -129,6 +129,7 @@ struct dio {
        /* AIO related stuff */
        struct kiocb *iocb;             /* kiocb */
        int is_async;                   /* is IO async ? */
+        int io_error;                   /* IO error in completion path */
        ssize_t result;                 /* IO result */
 };
@@ -250,6 +251,10 @@ static void finished_one_bio(struct dio *dio)
                            ((offset + transferred) > dio->i_size))
                                transferred = dio->i_size - offset;
+                        /* check for error in completion path */
+                        if (dio->io_error)
+                                transferred = dio->io_error;
                        dio_complete(dio, offset, transferred);
                        /* Complete AIO later if falling back to buffered i/o */
@@ -406,7 +411,7 @@ static int dio_bio_complete(struct dio *dio, struct bio *bio)
        int page_no;
        if (!uptodate)
-                dio->result = -EIO;
+                dio->io_error = -EIO;
        if (dio->is_async && dio->rw == READ) {
                bio_check_pages_dirty(bio);     /* transfers ownership */
@@ -971,6 +976,7 @@ direct_io_worker(int rw, struct kiocb *iocb, struct inode *inode,
        dio->next_block_for_io = -1;
        dio->page_errors = 0;
+        dio->io_error = 0;
        dio->result = 0;
        dio->iocb = iocb;
        dio->i_size = i_size_read(inode);
diff --git a/fs/eventpoll.c b/fs/eventpoll.c
index 1c2b16fda13a..a0f682cdd03e 100644
--- a/fs/eventpoll.c
+++ b/fs/eventpoll.c
@@ -599,7 +599,7 @@ sys_epoll_ctl(int epfd, int op, int fd, struct epoll_event __user *event)
        switch (op) {
        case EPOLL_CTL_ADD:
                if (!epi) {
-                        epds.events |= POLLERR | POLLHUP;
+                        epds.events |= POLLERR | POLLHUP | POLLRDHUP;
                        error = ep_insert(ep, &epds, tfile, fd);
                } else
@@ -613,7 +613,7 @@ sys_epoll_ctl(int epfd, int op, int fd, struct epoll_event __user *event)
                break;
        case EPOLL_CTL_MOD:
                if (epi) {
-                        epds.events |= POLLERR | POLLHUP;
+                        epds.events |= POLLERR | POLLHUP | POLLRDHUP;
                        error = ep_modify(ep, epi, &epds);
                } else
                        error = -ENOENT;
diff --git a/fs/exec.c b/fs/exec.c
index 0b515ac53134..995cba3c62b8 100644
--- a/fs/exec.c
+++ b/fs/exec.c
@@ -127,7 +127,7 @@ asmlinkage long sys_uselib(const char __user * library)
        struct nameidata nd;
        int error;
-        error = __user_path_lookup_open(library, LOOKUP_FOLLOW, &nd, FMODE_READ);
+        error = __user_path_lookup_open(library, LOOKUP_FOLLOW, &nd, FMODE_READ|FMODE_EXEC);
        if (error)
                goto out;
@@ -477,7 +477,7 @@ struct file *open_exec(const char *name)
        int err;
        struct file *file;
-        err = path_lookup_open(AT_FDCWD, name, LOOKUP_FOLLOW, &nd, FMODE_READ);
+        err = path_lookup_open(AT_FDCWD, name, LOOKUP_FOLLOW, &nd, FMODE_READ|FMODE_EXEC);
        file = ERR_PTR(err);
        if (!err) {
@@ -1143,10 +1143,9 @@ int do_execve(char * filename,
        int i;
        retval = -ENOMEM;
-        bprm = kmalloc(sizeof(*bprm), GFP_KERNEL);
+        bprm = kzalloc(sizeof(*bprm), GFP_KERNEL);
        if (!bprm)
                goto out_ret;
-        memset(bprm, 0, sizeof(*bprm));
        file = open_exec(filename);
        retval = PTR_ERR(file);
diff --git a/fs/ext2/super.c b/fs/ext2/super.c
index 268b73f5847c..7e30bae174ed 100644
--- a/fs/ext2/super.c
+++ b/fs/ext2/super.c
@@ -211,8 +211,6 @@ static int ext2_show_options(struct seq_file *seq, struct vfsmount *vfs)
        if (sbi->s_mount_opt & EXT2_MOUNT_GRPID)
                seq_puts(seq, ",grpid");
-        else
-                seq_puts(seq, ",nogrpid");
 #if defined(CONFIG_QUOTA)
        if (sbi->s_mount_opt & EXT2_MOUNT_USRQUOTA)
diff --git a/fs/ext3/bitmap.c b/fs/ext3/bitmap.c
index cb16b4c5d5df..ce4f82b9e528 100644
--- a/fs/ext3/bitmap.c
+++ b/fs/ext3/bitmap.c
@@ -7,11 +7,11 @@
 * Universite Pierre et Marie Curie (Paris VI)
 */
-#ifdef EXT3FS_DEBUG
 #include <linux/buffer_head.h>
+#include <linux/jbd.h>
+#include <linux/ext3_fs.h>
-#include "ext3_fs.h"
+#ifdef EXT3FS_DEBUG
 static int nibblemap[] = {4, 3, 3, 2, 3, 2, 2, 1, 3, 2, 2, 1, 2, 1, 1, 0};
diff --git a/fs/fs-writeback.c b/fs/fs-writeback.c
index 785c7213a54f..f3fbe2d030f4 100644
--- a/fs/fs-writeback.c
+++ b/fs/fs-writeback.c
@@ -381,8 +381,8 @@ sync_sb_inodes(struct super_block *sb, struct writeback_control *wbc)
                        list_move(&inode->i_list, &sb->s_dirty);
                }
                spin_unlock(&inode_lock);
-                cond_resched();
                iput(inode);
+                cond_resched();
                spin_lock(&inode_lock);
                if (wbc->nr_to_write <= 0)
                        break;
diff --git a/fs/inode.c b/fs/inode.c
index a51c671c54cf..85da11044adc 100644
--- a/fs/inode.c
+++ b/fs/inode.c
@@ -91,7 +91,7 @@ DEFINE_SPINLOCK(inode_lock);
 * from its final dispose_list, the struct super_block they refer to
 * (for inode->i_sb->s_op) may already have been freed and reused.
 */
-DEFINE_MUTEX(iprune_mutex);
+static DEFINE_MUTEX(iprune_mutex);
 /*
 * Statistics gathering..
diff --git a/fs/inotify.c b/fs/inotify.c
index 0ee39ef591c6..a61e93e17853 100644
--- a/fs/inotify.c
+++ b/fs/inotify.c
@@ -38,7 +38,6 @@
 #include <asm/ioctls.h>
 static atomic_t inotify_cookie;
-static atomic_t inotify_watches;
 static kmem_cache_t *watch_cachep;
 static kmem_cache_t *event_cachep;
@@ -381,6 +380,48 @@ static int find_inode(const char __user *dirname, struct nameidata *nd,
 }
 /*
+ * inotify_inode_watched - returns nonzero if there are watches on this inode
+ * and zero otherwise.  We call this lockless, we do not care if we race.
+ */
+static inline int inotify_inode_watched(struct inode *inode)
+{
+        return !list_empty(&inode->inotify_watches);
+}
+/*
+ * Get child dentry flag into synch with parent inode.
+ * Flag should always be clear for negative dentrys.
+ */
+static void set_dentry_child_flags(struct inode *inode, int watched)
+{
+        struct dentry *alias;
+        spin_lock(&dcache_lock);
+        list_for_each_entry(alias, &inode->i_dentry, d_alias) {
+                struct dentry *child;
+                list_for_each_entry(child, &alias->d_subdirs, d_u.d_child) {
+                        if (!child->d_inode) {
+                                WARN_ON(child->d_flags & DCACHE_INOTIFY_PARENT_WATCHED);
+                                continue;
+                        }
+                        spin_lock(&child->d_lock);
+                        if (watched) {
+                                WARN_ON(child->d_flags &
+                                                DCACHE_INOTIFY_PARENT_WATCHED);
+                                child->d_flags |= DCACHE_INOTIFY_PARENT_WATCHED;
+                        } else {
+                                WARN_ON(!(child->d_flags &
+                                        DCACHE_INOTIFY_PARENT_WATCHED));
+                                child->d_flags&=~DCACHE_INOTIFY_PARENT_WATCHED;
+                        }
+                        spin_unlock(&child->d_lock);
+                }
+        }
+        spin_unlock(&dcache_lock);
+}
+/*
 * create_watch - creates a watch on the given device.
 *
 * Callers must hold dev->mutex.  Calls inotify_dev_get_wd() so may sleep.
@@ -426,7 +467,6 @@ static struct inotify_watch *create_watch(struct inotify_device *dev,
        get_inotify_watch(watch);
        atomic_inc(&dev->user->inotify_watches);
-        atomic_inc(&inotify_watches);
        return watch;
 }
@@ -458,8 +498,10 @@ static void remove_watch_no_event(struct inotify_watch *watch,
        list_del(&watch->i_list);
        list_del(&watch->d_list);
+        if (!inotify_inode_watched(watch->inode))
+                set_dentry_child_flags(watch->inode, 0);
        atomic_dec(&dev->user->inotify_watches);
-        atomic_dec(&inotify_watches);
        idr_remove(&dev->idr, watch->wd);
        put_inotify_watch(watch);
 }
@@ -481,16 +523,39 @@ static void remove_watch(struct inotify_watch *watch,struct inotify_device *dev)
        remove_watch_no_event(watch, dev);
 }
+/* Kernel API */
 /*
- * inotify_inode_watched - returns nonzero if there are watches on this inode
+ * inotify_d_instantiate - instantiate dcache entry for inode
- * and zero otherwise.  We call this lockless, we do not care if we race.
 */
-static inline int inotify_inode_watched(struct inode *inode)
+void inotify_d_instantiate(struct dentry *entry, struct inode *inode)
 {
-        return !list_empty(&inode->inotify_watches);
+        struct dentry *parent;
+        if (!inode)
+                return;
+        WARN_ON(entry->d_flags & DCACHE_INOTIFY_PARENT_WATCHED);
+        spin_lock(&entry->d_lock);
+        parent = entry->d_parent;
+        if (inotify_inode_watched(parent->d_inode))
+                entry->d_flags |= DCACHE_INOTIFY_PARENT_WATCHED;
+        spin_unlock(&entry->d_lock);
 }
-/* Kernel API */
+/*
+ * inotify_d_move - dcache entry has been moved
+ */
+void inotify_d_move(struct dentry *entry)
+{
+        struct dentry *parent;
+        parent = entry->d_parent;
+        if (inotify_inode_watched(parent->d_inode))
+                entry->d_flags |= DCACHE_INOTIFY_PARENT_WATCHED;
+        else
+                entry->d_flags &= ~DCACHE_INOTIFY_PARENT_WATCHED;
+}
 /**
 * inotify_inode_queue_event - queue an event to all watches on this inode
@@ -538,7 +603,7 @@ void inotify_dentry_parent_queue_event(struct dentry *dentry, u32 mask,
        struct dentry *parent;
        struct inode *inode;
-        if (!atomic_read (&inotify_watches))
+        if (!(dentry->d_flags & DCACHE_INOTIFY_PARENT_WATCHED))
                return;
        spin_lock(&dentry->d_lock);
@@ -993,6 +1058,9 @@ asmlinkage long sys_inotify_add_watch(int fd, const char __user *path, u32 mask)
                goto out;
        }
+        if (!inotify_inode_watched(inode))
+                set_dentry_child_flags(inode, 1);
        /* Add the watch to the device's and the inode's list */
        list_add(&watch->d_list, &dev->watches);
        list_add(&watch->i_list, &inode->inotify_watches);
@@ -1065,7 +1133,6 @@ static int __init inotify_setup(void)
        inotify_max_user_watches = 8192;
        atomic_set(&inotify_cookie, 0);
-        atomic_set(&inotify_watches, 0);
        watch_cachep = kmem_cache_create("inotify_watch_cache",
                                         sizeof(struct inotify_watch),
diff --git a/fs/jbd/journal.c b/fs/jbd/journal.c
index 95a628d8cac8..7f96b5cb6781 100644
--- a/fs/jbd/journal.c
+++ b/fs/jbd/journal.c
@@ -33,9 +33,11 @@
 #include <linux/mm.h>
 #include <linux/suspend.h>
 #include <linux/pagemap.h>
+#include <linux/kthread.h>
+#include <linux/proc_fs.h>
 #include <asm/uaccess.h>
 #include <asm/page.h>
-#include <linux/proc_fs.h>
 EXPORT_SYMBOL(journal_start);
 EXPORT_SYMBOL(journal_restart);
@@ -111,18 +113,15 @@ static void commit_timeout(unsigned long __data)
 static int kjournald(void *arg)
 {
-        journal_t *journal = (journal_t *) arg;
+        journal_t *journal = arg;
        transaction_t *transaction;
-        struct timer_list timer;
-        daemonize("kjournald");
+        /*
+         * Set up an interval timer which can be used to trigger a commit wakeup
-        /* Set up an interval timer which can be used to trigger a
+         * after the commit interval expires
-           commit wakeup after the commit interval expires */
+         */
-        init_timer(&timer);
+        setup_timer(&journal->j_commit_timer, commit_timeout,
-        timer.data = (unsigned long) current;
+                        (unsigned long)current);
-        timer.function = commit_timeout;
-        journal->j_commit_timer = &timer;
        /* Record that the journal thread is running */
        journal->j_task = current;
@@ -146,7 +145,7 @@ loop:
        if (journal->j_commit_sequence != journal->j_commit_request) {
                jbd_debug(1, "OK, requests differ\n");
                spin_unlock(&journal->j_state_lock);
-                del_timer_sync(journal->j_commit_timer);
+                del_timer_sync(&journal->j_commit_timer);
                journal_commit_transaction(journal);
                spin_lock(&journal->j_state_lock);
                goto loop;
@@ -203,7 +202,7 @@ loop:
 end_loop:
        spin_unlock(&journal->j_state_lock);
-        del_timer_sync(journal->j_commit_timer);
+        del_timer_sync(&journal->j_commit_timer);
        journal->j_task = NULL;
        wake_up(&journal->j_wait_done_commit);
        jbd_debug(1, "Journal thread exiting.\n");
@@ -212,7 +211,7 @@ end_loop:
 static void journal_start_thread(journal_t *journal)
 {
-        kernel_thread(kjournald, journal, CLONE_VM|CLONE_FS|CLONE_FILES);
+        kthread_run(kjournald, journal, "kjournald");
        wait_event(journal->j_wait_done_commit, journal->j_task != 0);
 }
diff --git a/fs/jbd/transaction.c b/fs/jbd/transaction.c
index 5fc40888f4cf..ada31fa272e3 100644
--- a/fs/jbd/transaction.c
+++ b/fs/jbd/transaction.c
@@ -53,8 +53,8 @@ get_transaction(journal_t *journal, transaction_t *transaction)
        spin_lock_init(&transaction->t_handle_lock);
        /* Set up the commit timer for the new transaction. */
-        journal->j_commit_timer->expires = transaction->t_expires;
+        journal->j_commit_timer.expires = transaction->t_expires;
-        add_timer(journal->j_commit_timer);
+        add_timer(&journal->j_commit_timer);
        J_ASSERT(journal->j_running_transaction == NULL);
        journal->j_running_transaction = transaction;
diff --git a/fs/minix/bitmap.c b/fs/minix/bitmap.c
index dc6a4e4abcdc..4a6abc49418e 100644
--- a/fs/minix/bitmap.c
+++ b/fs/minix/bitmap.c
@@ -56,7 +56,7 @@ void minix_free_block(struct inode * inode, int block)
        unsigned int bit,zone;
        if (block < sbi->s_firstdatazone || block >= sbi->s_nzones) {
-                printk("trying to free block not in datazone\n");
+                printk("Trying to free block not in datazone\n");
                return;
        }
        zone = block - sbi->s_firstdatazone + 1;
@@ -124,7 +124,7 @@ minix_V1_raw_inode(struct super_block *sb, ino_t ino, struct buffer_head **bh)
                 ino / MINIX_INODES_PER_BLOCK;
        *bh = sb_bread(sb, block);
        if (!*bh) {
-                printk("unable to read i-node block\n");
+                printk("Unable to read inode block\n");
                return NULL;
        }
        p = (void *)(*bh)->b_data;
@@ -149,7 +149,7 @@ minix_V2_raw_inode(struct super_block *sb, ino_t ino, struct buffer_head **bh)
                 ino / MINIX2_INODES_PER_BLOCK;
        *bh = sb_bread(sb, block);
        if (!*bh) {
-                printk("unable to read i-node block\n");
+                printk("Unable to read inode block\n");
                return NULL;
        }
        p = (void *)(*bh)->b_data;
@@ -204,7 +204,7 @@ void minix_free_inode(struct inode * inode)
        bh = sbi->s_imap[ino >> 13];
        lock_kernel();
        if (!minix_test_and_clear_bit(ino & 8191, bh->b_data))
-                printk("minix_free_inode: bit %lu already cleared.\n", ino);
+                printk("minix_free_inode: bit %lu already cleared\n", ino);
        unlock_kernel();
        mark_buffer_dirty(bh);
 out:
@@ -238,7 +238,7 @@ struct inode * minix_new_inode(const struct inode * dir, int * error)
                return NULL;
        }
        if (minix_test_and_set_bit(j,bh->b_data)) {     /* shouldn't happen */
-                printk("new_inode: bit already set");
+                printk("new_inode: bit already set\n");
                unlock_kernel();
                iput(inode);
                return NULL;
diff --git a/fs/minix/inode.c b/fs/minix/inode.c
index d9ffc43fee59..2dcccf1d1b7f 100644
--- a/fs/minix/inode.c
+++ b/fs/minix/inode.c
@@ -127,11 +127,11 @@ static int minix_remount (struct super_block * sb, int * flags, char * data)
                mark_buffer_dirty(sbi->s_sbh);
                if (!(sbi->s_mount_state & MINIX_VALID_FS))
-                        printk ("MINIX-fs warning: remounting unchecked fs, "
+                        printk("MINIX-fs warning: remounting unchecked fs, "
-                                "running fsck is recommended.\n");
+                                "running fsck is recommended\n");
                else if ((sbi->s_mount_state & MINIX_ERROR_FS))
-                        printk ("MINIX-fs warning: remounting fs with errors, "
+                        printk("MINIX-fs warning: remounting fs with errors, "
-                                "running fsck is recommended.\n");
+                                "running fsck is recommended\n");
        }
        return 0;
 }
@@ -245,11 +245,11 @@ static int minix_fill_super(struct super_block *s, void *data, int silent)
                mark_buffer_dirty(bh);
        }
        if (!(sbi->s_mount_state & MINIX_VALID_FS))
-                printk ("MINIX-fs: mounting unchecked file system, "
+                printk("MINIX-fs: mounting unchecked file system, "
-                        "running fsck is recommended.\n");
+                        "running fsck is recommended\n");
        else if (sbi->s_mount_state & MINIX_ERROR_FS)
-                printk ("MINIX-fs: mounting file system with errors, "
+                printk("MINIX-fs: mounting file system with errors, "
-                        "running fsck is recommended.\n");
+                        "running fsck is recommended\n");
        return 0;
 out_iput:
@@ -273,19 +273,19 @@ out_no_bitmap:
 out_no_map:
        if (!silent)
-                printk ("MINIX-fs: can't allocate map\n");
+                printk("MINIX-fs: can't allocate map\n");
        goto out_release;
 out_no_fs:
        if (!silent)
-                printk("VFS: Can't find a Minix or Minix V2 filesystem on device "
+                printk("VFS: Can't find a Minix or Minix V2 filesystem "
-                       "%s.\n", s->s_id);
+                        "on device %s\n", s->s_id);
    out_release:
        brelse(bh);
        goto out;
 out_bad_hblock:
-        printk("MINIX-fs: blocksize too small for device.\n");
+        printk("MINIX-fs: blocksize too small for device\n");
        goto out;
 out_bad_sb:
@@ -524,7 +524,7 @@ int minix_sync_inode(struct inode * inode)
                sync_dirty_buffer(bh);
                if (buffer_req(bh) && !buffer_uptodate(bh))
                {
-                        printk ("IO error syncing minix inode [%s:%08lx]\n",
+                        printk("IO error syncing minix inode [%s:%08lx]\n",
                                inode->i_sb->s_id, inode->i_ino);
                        err = -1;
                }
diff --git a/fs/minix/itree_v1.c b/fs/minix/itree_v1.c
index ba06aef4aca1..656b1347a25b 100644
--- a/fs/minix/itree_v1.c
+++ b/fs/minix/itree_v1.c
@@ -25,9 +25,9 @@ static int block_to_path(struct inode * inode, long block, int offsets[DEPTH])
        int n = 0;
        if (block < 0) {
-                printk("minix_bmap: block<0");
+                printk("minix_bmap: block<0\n");
        } else if (block >= (minix_sb(inode->i_sb)->s_max_size/BLOCK_SIZE)) {
-                printk("minix_bmap: block>big");
+                printk("minix_bmap: block>big\n");
        } else if (block < 7) {
                offsets[n++] = block;
        } else if ((block -= 7) < 512) {
diff --git a/fs/minix/itree_v2.c b/fs/minix/itree_v2.c
index 3adc7675560f..9adcdc754e0f 100644
--- a/fs/minix/itree_v2.c
+++ b/fs/minix/itree_v2.c
@@ -25,9 +25,9 @@ static int block_to_path(struct inode * inode, long block, int offsets[DEPTH])
        int n = 0;
        if (block < 0) {
-                printk("minix_bmap: block<0");
+                printk("minix_bmap: block<0\n");
        } else if (block >= (minix_sb(inode->i_sb)->s_max_size/BLOCK_SIZE)) {
-                printk("minix_bmap: block>big");
+                printk("minix_bmap: block>big\n");
        } else if (block < 7) {
                offsets[n++] = block;
        } else if ((block -= 7) < 256) {
diff --git a/fs/namei.c b/fs/namei.c
index c72b940797fc..712dfc77793b 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -1628,6 +1628,12 @@ do_last:
                goto exit;
        }
+        if (IS_ERR(nd->intent.open.file)) {
+                mutex_unlock(&dir->d_inode->i_mutex);
+                error = PTR_ERR(nd->intent.open.file);
+                goto exit_dput;
+        }
        /* Negative dentry, just create the file */
        if (!path.dentry->d_inode) {
                if (!IS_POSIXACL(dir->d_inode))
@@ -2621,16 +2627,27 @@ int __page_symlink(struct inode *inode, const char *symname, int len,
        int err = -ENOMEM;
        char *kaddr;
+retry:
        page = find_or_create_page(mapping, 0, gfp_mask);
        if (!page)
                goto fail;
        err = mapping->a_ops->prepare_write(NULL, page, 0, len-1);
+        if (err == AOP_TRUNCATED_PAGE) {
+                page_cache_release(page);
+                goto retry;
+        }
        if (err)
                goto fail_map;
        kaddr = kmap_atomic(page, KM_USER0);
        memcpy(kaddr, symname, len-1);
        kunmap_atomic(kaddr, KM_USER0);
-        mapping->a_ops->commit_write(NULL, page, 0, len-1);
+        err = mapping->a_ops->commit_write(NULL, page, 0, len-1);
+        if (err == AOP_TRUNCATED_PAGE) {
+                page_cache_release(page);
+                goto retry;
+        }
+        if (err)
+                goto fail_map;
        /*
         * Notice that we are _not_ going to block here - end of page is
         * unmapped, so this will only try to map the rest of page, see
@@ -2640,7 +2657,8 @@ int __page_symlink(struct inode *inode, const char *symname, int len,
         */
        if (!PageUptodate(page)) {
                err = mapping->a_ops->readpage(NULL, page);
-                wait_on_page_locked(page);
+                if (err != AOP_TRUNCATED_PAGE)
+                        wait_on_page_locked(page);
        } else {
                unlock_page(page);
        }
diff --git a/fs/open.c b/fs/open.c
index 1091dadd6c38..7d02d19bd0a2 100644
--- a/fs/open.c
+++ b/fs/open.c
@@ -890,6 +890,10 @@ EXPORT_SYMBOL(filp_open);
 * a fully instantiated struct file to the caller.
 * This function is meant to be called from within a filesystem's
 * lookup method.
+ * Beware of calling it for non-regular files! Those ->open methods might block
+ * (e.g. in fifo_open), leaving you with parent locked (and in case of fifo,
+ * leading to a deadlock, as nobody can open that fifo anymore, because
+ * another process to open fifo will block on locked parent when doing lookup).
 * Note that in case of error, nd->intent.open.file is destroyed, but the
 * path information remains valid.
 * If the open callback is set to NULL, then the standard f_op->open()
diff --git a/fs/pipe.c b/fs/pipe.c
index 8aada8e426f4..d976866a115b 100644
--- a/fs/pipe.c
+++ b/fs/pipe.c
@@ -662,10 +662,9 @@ struct inode* pipe_new(struct inode* inode)
 {
        struct pipe_inode_info *info;
-        info = kmalloc(sizeof(struct pipe_inode_info), GFP_KERNEL);
+        info = kzalloc(sizeof(struct pipe_inode_info), GFP_KERNEL);
        if (!info)
                goto fail_page;
-        memset(info, 0, sizeof(*info));
        inode->i_pipe = info;
        init_waitqueue_head(PIPE_WAIT(*inode));
diff --git a/fs/proc/proc_misc.c b/fs/proc/proc_misc.c
index 826c131994c3..1e9ea37d457e 100644
--- a/fs/proc/proc_misc.c
+++ b/fs/proc/proc_misc.c
@@ -485,6 +485,40 @@ static struct file_operations proc_slabinfo_operations = {
        .llseek         = seq_lseek,
        .release        = seq_release,
 };
+#ifdef CONFIG_DEBUG_SLAB_LEAK
+extern struct seq_operations slabstats_op;
+static int slabstats_open(struct inode *inode, struct file *file)
+{
+        unsigned long *n = kzalloc(PAGE_SIZE, GFP_KERNEL);
+        int ret = -ENOMEM;
+        if (n) {
+                ret = seq_open(file, &slabstats_op);
+                if (!ret) {
+                        struct seq_file *m = file->private_data;
+                        *n = PAGE_SIZE / (2 * sizeof(unsigned long));
+                        m->private = n;
+                        n = NULL;
+                }
+                kfree(n);
+        }
+        return ret;
+}
+static int slabstats_release(struct inode *inode, struct file *file)
+{
+        struct seq_file *m = file->private_data;
+        kfree(m->private);
+        return seq_release(inode, file);
+}
+static struct file_operations proc_slabstats_operations = {
+        .open           = slabstats_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = slabstats_release,
+};
+#endif
 #endif
 static int show_stat(struct seq_file *p, void *v)
@@ -744,6 +778,9 @@ void __init proc_misc_init(void)
        create_seq_entry("interrupts", 0, &proc_interrupts_operations);
 #ifdef CONFIG_SLAB
        create_seq_entry("slabinfo",S_IWUSR|S_IRUGO,&proc_slabinfo_operations);
+#ifdef CONFIG_DEBUG_SLAB_LEAK
+        create_seq_entry("slab_allocators", 0 ,&proc_slabstats_operations);
+#endif
 #endif
        create_seq_entry("buddyinfo",S_IRUGO, &fragmentation_file_operations);
        create_seq_entry("vmstat",S_IRUGO, &proc_vmstat_file_operations);
diff --git a/fs/read_write.c b/fs/read_write.c
index 3f7a1a62165f..34b1bf259efd 100644
--- a/fs/read_write.c
+++ b/fs/read_write.c
@@ -470,7 +470,7 @@ static ssize_t do_readv_writev(int type, struct file *file,
         * verify all the pointers
         */
        ret = -EINVAL;
-        if ((nr_segs > UIO_MAXIOV) || (nr_segs <= 0))
+        if (nr_segs > UIO_MAXIOV)
                goto out;
        if (!file->f_op)
                goto out;
diff --git a/fs/reiserfs/file.c b/fs/reiserfs/file.c
index be12879bb179..d0c1e865963e 100644
--- a/fs/reiserfs/file.c
+++ b/fs/reiserfs/file.c
@@ -1532,7 +1532,7 @@ static ssize_t reiserfs_file_write(struct file *file,	/* the file we are going t
                buf += write_bytes;
                *ppos = pos += write_bytes;
                count -= write_bytes;
-                balance_dirty_pages_ratelimited(inode->i_mapping);
+                balance_dirty_pages_ratelimited_nr(inode->i_mapping, num_pages);
        }
        /* this is only true on error */
@@ -1546,10 +1546,10 @@ static ssize_t reiserfs_file_write(struct file *file,	/* the file we are going t
                }
        }
-        if ((file->f_flags & O_SYNC) || IS_SYNC(inode))
+        if (likely(res >= 0) &&
-                res =
+            (unlikely((file->f_flags & O_SYNC) || IS_SYNC(inode))))
-                    generic_osync_inode(inode, file->f_mapping,
+                res = generic_osync_inode(inode, file->f_mapping,
-                                        OSYNC_METADATA | OSYNC_DATA);
+                                          OSYNC_METADATA | OSYNC_DATA);
        mutex_unlock(&inode->i_mutex);
        reiserfs_async_progress_wait(inode->i_sb);
diff --git a/fs/reiserfs/fix_node.c b/fs/reiserfs/fix_node.c
index aa22588019ec..5600d3d60cf7 100644
--- a/fs/reiserfs/fix_node.c
+++ b/fs/reiserfs/fix_node.c
@@ -191,9 +191,7 @@ static void create_virtual_node(struct tree_balance *tb, int h)
                                               "vs-8045: create_virtual_node: rdkey %k, affected item==%d (mode==%c) Must be %c",
                                               key, vn->vn_affected_item_num,
                                               vn->vn_mode, M_DELETE);
-                        } else
+                        }
-                                /* we can delete directory item, that has only one directory entry in it */
-                                ;
                }
 #endif
diff --git a/fs/reiserfs/item_ops.c b/fs/reiserfs/item_ops.c
index e237cd668e5b..7a88adbceef6 100644
--- a/fs/reiserfs/item_ops.c
+++ b/fs/reiserfs/item_ops.c
@@ -275,7 +275,7 @@ static void indirect_print_item(struct item_head *ih, char *item)
        int j;
        __le32 *unp;
        __u32 prev = INT_MAX;
-        int num;
+        int num = 0;
        unp = (__le32 *) item;
diff --git a/fs/reiserfs/journal.c b/fs/reiserfs/journal.c
index 5a9d2722fa0a..1b73529b8099 100644
--- a/fs/reiserfs/journal.c
+++ b/fs/reiserfs/journal.c
@@ -2227,6 +2227,9 @@ static int journal_read_transaction(struct super_block *p_s_sb,
        journal->j_start = cur_dblock - SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb);
        journal->j_last_flush_trans_id = trans_id;
        journal->j_trans_id = trans_id + 1;
+        /* check for trans_id overflow */
+        if (journal->j_trans_id == 0)
+                journal->j_trans_id = 10;
        brelse(c_bh);
        brelse(d_bh);
        kfree(log_blocks);
@@ -2450,6 +2453,9 @@ static int journal_read(struct super_block *p_s_sb)
                journal->j_start = le32_to_cpu(jh->j_first_unflushed_offset);
                journal->j_trans_id =
                    le32_to_cpu(jh->j_last_flush_trans_id) + 1;
+                /* check for trans_id overflow */
+                if (journal->j_trans_id == 0)
+                        journal->j_trans_id = 10;
                journal->j_last_flush_trans_id =
                    le32_to_cpu(jh->j_last_flush_trans_id);
                journal->j_mount_id = le32_to_cpu(jh->j_mount_id) + 1;
@@ -3873,8 +3879,8 @@ static int do_journal_end(struct reiserfs_transaction_handle *th,
        int cur_write_start = 0;        /* start index of current log write */
        int old_start;
        int i;
-        int flush = flags & FLUSH_ALL;
+        int flush;
-        int wait_on_commit = flags & WAIT;
+        int wait_on_commit;
        struct reiserfs_journal_list *jl, *temp_jl;
        struct list_head *entry, *safe;
        unsigned long jindex;
@@ -3884,6 +3890,13 @@ static int do_journal_end(struct reiserfs_transaction_handle *th,
        BUG_ON(th->t_refcount > 1);
        BUG_ON(!th->t_trans_id);
+        /* protect flush_older_commits from doing mistakes if the
+           transaction ID counter gets overflowed.  */
+        if (th->t_trans_id == ~0UL)
+                flags |= FLUSH_ALL | COMMIT_NOW | WAIT;
+        flush = flags & FLUSH_ALL;
+        wait_on_commit = flags & WAIT;
        put_fs_excl();
        current->journal_info = th->t_handle_save;
        reiserfs_check_lock_depth(p_s_sb, "journal end");
@@ -4105,7 +4118,9 @@ static int do_journal_end(struct reiserfs_transaction_handle *th,
        journal->j_first = NULL;
        journal->j_len = 0;
        journal->j_trans_start_time = 0;
-        journal->j_trans_id++;
+        /* check for trans_id overflow */
+        if (++journal->j_trans_id == 0)
+                journal->j_trans_id = 10;
        journal->j_current_jl->j_trans_id = journal->j_trans_id;
        journal->j_must_wait = 0;
        journal->j_len_alloc = 0;
diff --git a/fs/reiserfs/stree.c b/fs/reiserfs/stree.c
index e2d08d7bcffc..d2b25e1ba6e9 100644
--- a/fs/reiserfs/stree.c
+++ b/fs/reiserfs/stree.c
@@ -981,6 +981,8 @@ static inline int prepare_for_direntry_item(struct path *path,
        return M_CUT;
 }
+#define JOURNAL_FOR_FREE_BLOCK_AND_UPDATE_SD (2 * JOURNAL_PER_BALANCE_CNT + 1)
 /*  If the path points to a directory or direct item, calculate mode and the size cut, for balance.
    If the path points to an indirect item, remove some number of its unformatted nodes.
    In case of file truncate calculate whether this item must be deleted/truncated or last
@@ -1020,148 +1022,79 @@ static char prepare_for_delete_or_cut(struct reiserfs_transaction_handle *th, st
        /* Case of an indirect item. */
        {
-                int n_unfm_number,      /* Number of the item unformatted nodes. */
+            int blk_size = p_s_sb->s_blocksize;
-                 n_counter, n_blk_size;
+            struct item_head s_ih;
-                __le32 *p_n_unfm_pointer;       /* Pointer to the unformatted node number. */
+            int need_re_search;
-                __u32 tmp;
+            int delete = 0;
-                struct item_head s_ih;  /* Item header. */
+            int result = M_CUT;
-                char c_mode;    /* Returned mode of the balance. */
+            int pos = 0;
-                int need_research;
+            if ( n_new_file_length == max_reiserfs_offset (inode) ) {
-                n_blk_size = p_s_sb->s_blocksize;
+                /* prepare_for_delete_or_cut() is called by
+                 * reiserfs_delete_item() */
-                /* Search for the needed object indirect item until there are no unformatted nodes to be removed. */
+                n_new_file_length = 0;
-                do {
+                delete = 1;
-                        need_research = 0;
+            }
-                        p_s_bh = PATH_PLAST_BUFFER(p_s_path);
-                        /* Copy indirect item header to a temp variable. */
+            do {
-                        copy_item_head(&s_ih, PATH_PITEM_HEAD(p_s_path));
+                need_re_search = 0;
-                        /* Calculate number of unformatted nodes in this item. */
+                *p_n_cut_size = 0;
-                        n_unfm_number = I_UNFM_NUM(&s_ih);
+                p_s_bh = PATH_PLAST_BUFFER(p_s_path);
+                copy_item_head(&s_ih, PATH_PITEM_HEAD(p_s_path));
-                        RFALSE(!is_indirect_le_ih(&s_ih) || !n_unfm_number ||
+                pos = I_UNFM_NUM(&s_ih);
-                               pos_in_item(p_s_path) + 1 != n_unfm_number,
-                               "PAP-5240: invalid item %h "
-                               "n_unfm_number = %d *p_n_pos_in_item = %d",
-                               &s_ih, n_unfm_number, pos_in_item(p_s_path));
-                        /* Calculate balance mode and position in the item to remove unformatted nodes. */
-                        if (n_new_file_length == max_reiserfs_offset(inode)) {  /* Case of delete. */
-                                pos_in_item(p_s_path) = 0;
-                                *p_n_cut_size = -(IH_SIZE + ih_item_len(&s_ih));
-                                c_mode = M_DELETE;
-                        } else {        /* Case of truncate. */
-                                if (n_new_file_length < le_ih_k_offset(&s_ih)) {
-                                        pos_in_item(p_s_path) = 0;
-                                        *p_n_cut_size =
-                                            -(IH_SIZE + ih_item_len(&s_ih));
-                                        c_mode = M_DELETE;      /* Delete this item. */
-                                } else {
-                                        /* indirect item must be truncated starting from *p_n_pos_in_item-th position */
-                                        pos_in_item(p_s_path) =
-                                            (n_new_file_length + n_blk_size -
-                                             le_ih_k_offset(&s_ih)) >> p_s_sb->
-                                            s_blocksize_bits;
-                                        RFALSE(pos_in_item(p_s_path) >
-                                               n_unfm_number,
-                                               "PAP-5250: invalid position in the item");
-                                        /* Either convert last unformatted node of indirect item to direct item or increase
-                                           its free space.  */
-                                        if (pos_in_item(p_s_path) ==
-                                            n_unfm_number) {
-                                                *p_n_cut_size = 0;      /* Nothing to cut. */
-                                                return M_CONVERT;       /* Maybe convert last unformatted node to the direct item. */
-                                        }
-                                        /* Calculate size to cut. */
-                                        *p_n_cut_size =
-                                            -(ih_item_len(&s_ih) -
-                                              pos_in_item(p_s_path) *
-                                              UNFM_P_SIZE);
-                                        c_mode = M_CUT; /* Cut from this indirect item. */
-                                }
-                        }
-                        RFALSE(n_unfm_number <= pos_in_item(p_s_path),
+                while (le_ih_k_offset (&s_ih) + (pos - 1) * blk_size > n_new_file_length) {
-                               "PAP-5260: invalid position in the indirect item");
+                    __u32 *unfm, block;
-                        /* pointers to be cut */
-                        n_unfm_number -= pos_in_item(p_s_path);
-                        /* Set pointer to the last unformatted node pointer that is to be cut. */
-                        p_n_unfm_pointer =
-                            (__le32 *) B_I_PITEM(p_s_bh,
-                                                 &s_ih) + I_UNFM_NUM(&s_ih) -
-                            1 - *p_n_removed;
-                        /* We go through the unformatted nodes pointers of the indirect
-                           item and look for the unformatted nodes in the cache. If we
-                           found some of them we free it, zero corresponding indirect item
-                           entry and log buffer containing that indirect item. For this we
-                           need to prepare last path element for logging. If some
-                           unformatted node has b_count > 1 we must not free this
-                           unformatted node since it is in use. */
-                        reiserfs_prepare_for_journal(p_s_sb, p_s_bh, 1);
-                        // note: path could be changed, first line in for loop takes care
-                        // of it
-                        for (n_counter = *p_n_removed;
+                    /* Each unformatted block deletion may involve one additional
-                             n_counter < n_unfm_number;
+                     * bitmap block into the transaction, thereby the initial
-                             n_counter++, p_n_unfm_pointer--) {
+                     * journal space reservation might not be enough. */
+                    if (!delete && (*p_n_cut_size) != 0 &&
+                        reiserfs_transaction_free_space(th) < JOURNAL_FOR_FREE_BLOCK_AND_UPDATE_SD) {
+                        break;
+                    }
-                                cond_resched();
+                    unfm = (__u32 *)B_I_PITEM(p_s_bh, &s_ih) + pos - 1;
-                                if (item_moved(&s_ih, p_s_path)) {
+                    block = get_block_num(unfm, 0);
-                                        need_research = 1;
-                                        break;
-                                }
-                                RFALSE(p_n_unfm_pointer <
-                                       (__le32 *) B_I_PITEM(p_s_bh, &s_ih)
-                                       || p_n_unfm_pointer >
-                                       (__le32 *) B_I_PITEM(p_s_bh,
-                                                            &s_ih) +
-                                       I_UNFM_NUM(&s_ih) - 1,
-                                       "vs-5265: pointer out of range");
-                                /* Hole, nothing to remove. */
-                                if (!get_block_num(p_n_unfm_pointer, 0)) {
-                                        (*p_n_removed)++;
-                                        continue;
-                                }
-                                (*p_n_removed)++;
+                    if (block != 0) {
+                        reiserfs_prepare_for_journal(p_s_sb, p_s_bh, 1);
+                        put_block_num(unfm, 0, 0);
+                        journal_mark_dirty (th, p_s_sb, p_s_bh);
+                        reiserfs_free_block(th, inode, block, 1);
+                    }
-                                tmp = get_block_num(p_n_unfm_pointer, 0);
+                    cond_resched();
-                                put_block_num(p_n_unfm_pointer, 0, 0);
-                                journal_mark_dirty(th, p_s_sb, p_s_bh);
-                                reiserfs_free_block(th, inode, tmp, 1);
-                                if (item_moved(&s_ih, p_s_path)) {
-                                        need_research = 1;
-                                        break;
-                                }
-                        }
-                        /* a trick.  If the buffer has been logged, this
+                    if (item_moved (&s_ih, p_s_path))  {
-                         ** will do nothing.  If we've broken the loop without
+                        need_re_search = 1;
-                         ** logging it, it will restore the buffer
+                        break;
-                         **
+                    }
-                         */
-                        reiserfs_restore_prepared_buffer(p_s_sb, p_s_bh);
+                    pos --;
+                    (*p_n_removed) ++;
-                        /* This loop can be optimized. */
+                    (*p_n_cut_size) -= UNFM_P_SIZE;
-                } while ((*p_n_removed < n_unfm_number || need_research) &&
-                         search_for_position_by_key(p_s_sb, p_s_item_key,
+                    if (pos == 0) {
-                                                    p_s_path) ==
+                        (*p_n_cut_size) -= IH_SIZE;
-                         POSITION_FOUND);
+                        result = M_DELETE;
+                        break;
-                RFALSE(*p_n_removed < n_unfm_number,
+                    }
-                       "PAP-5310: indirect item is not found");
+                }
-                RFALSE(item_moved(&s_ih, p_s_path),
+                /* a trick.  If the buffer has been logged, this will do nothing.  If
-                       "after while, comp failed, retry");
+                ** we've broken the loop without logging it, it will restore the
+                ** buffer */
-                if (c_mode == M_CUT)
+                reiserfs_restore_prepared_buffer(p_s_sb, p_s_bh);
-                        pos_in_item(p_s_path) *= UNFM_P_SIZE;
+            } while (need_re_search &&
-                return c_mode;
+                     search_for_position_by_key(p_s_sb, p_s_item_key, p_s_path) == POSITION_FOUND);
+            pos_in_item(p_s_path) = pos * UNFM_P_SIZE;
+            if (*p_n_cut_size == 0) {
+                /* Nothing were cut. maybe convert last unformatted node to the
+                 * direct item? */
+                result = M_CONVERT;
+            }
+            return result;
        }
 }
@@ -1948,7 +1881,8 @@ int reiserfs_do_truncate(struct reiserfs_transaction_handle *th, struct inode *p
                 ** sure the file is consistent before ending the current trans
                 ** and starting a new one
                 */
-                if (journal_transaction_should_end(th, th->t_blocks_allocated)) {
+                if (journal_transaction_should_end(th, 0) ||
+                    reiserfs_transaction_free_space(th) <= JOURNAL_FOR_FREE_BLOCK_AND_UPDATE_SD) {
                        int orig_len_alloc = th->t_blocks_allocated;
                        decrement_counters_in_path(&s_search_path);
@@ -1962,7 +1896,7 @@ int reiserfs_do_truncate(struct reiserfs_transaction_handle *th, struct inode *p
                        if (err)
                                goto out;
                        err = journal_begin(th, p_s_inode->i_sb,
-                                            JOURNAL_PER_BALANCE_CNT * 6);
+                                            JOURNAL_FOR_FREE_BLOCK_AND_UPDATE_SD + JOURNAL_PER_BALANCE_CNT * 4) ;
                        if (err)
                                goto out;
                        reiserfs_update_inode_transaction(p_s_inode);
diff --git a/fs/reiserfs/super.c b/fs/reiserfs/super.c
index 93e6ef9360e3..cae2abbc0c71 100644
--- a/fs/reiserfs/super.c
+++ b/fs/reiserfs/super.c
@@ -685,14 +685,14 @@ static const arg_desc_t logging_mode[] = {
         (1 << REISERFS_DATA_ORDERED | 1 << REISERFS_DATA_WRITEBACK)},
        {"writeback", 1 << REISERFS_DATA_WRITEBACK,
         (1 << REISERFS_DATA_ORDERED | 1 << REISERFS_DATA_LOG)},
-        {NULL, 0}
+        {.value = NULL}
 };
 /* possible values for -o barrier= */
 static const arg_desc_t barrier_mode[] = {
        {"none", 1 << REISERFS_BARRIER_NONE, 1 << REISERFS_BARRIER_FLUSH},
        {"flush", 1 << REISERFS_BARRIER_FLUSH, 1 << REISERFS_BARRIER_NONE},
-        {NULL, 0}
+        {.value = NULL}
 };
 /* possible values for "-o block-allocator=" and bits which are to be set in
@@ -890,7 +890,7 @@ static int reiserfs_parse_options(struct super_block *s, char *options,	/* strin
                {"acl",.setmask = 1 << REISERFS_UNSUPPORTED_OPT},
                {"noacl",.clrmask = 1 << REISERFS_UNSUPPORTED_OPT},
 #endif
-                {"nolog",},     /* This is unsupported */
+                {.option_name = "nolog"},
                {"replayonly",.setmask = 1 << REPLAYONLY},
                {"block-allocator",.arg_required = 'a',.values = balloc},
                {"data",.arg_required = 'd',.values = logging_mode},
@@ -908,7 +908,7 @@ static int reiserfs_parse_options(struct super_block *s, char *options,	/* strin
                {"grpjquota",.arg_required =
                 'g' | (1 << REISERFS_OPT_ALLOWEMPTY),.values = NULL},
                {"jqfmt",.arg_required = 'f',.values = NULL},
-                {NULL,}
+                {.option_name = NULL}
        };
        *blocks = 0;
diff --git a/fs/reiserfs/xattr_acl.c b/fs/reiserfs/xattr_acl.c
index ab8894c3b9e5..58c418fbca2c 100644
--- a/fs/reiserfs/xattr_acl.c
+++ b/fs/reiserfs/xattr_acl.c
@@ -182,7 +182,7 @@ struct posix_acl *reiserfs_get_acl(struct inode *inode, int type)
 {
        char *name, *value;
        struct posix_acl *acl, **p_acl;
-        size_t size;
+        int size;
        int retval;
        struct reiserfs_inode_info *reiserfs_i = REISERFS_I(inode);
@@ -206,7 +206,7 @@ struct posix_acl *reiserfs_get_acl(struct inode *inode, int type)
                return posix_acl_dup(*p_acl);
        size = reiserfs_xattr_get(inode, name, NULL, 0);
-        if ((int)size < 0) {
+        if (size < 0) {
                if (size == -ENODATA || size == -ENOSYS) {
                        *p_acl = ERR_PTR(-ENODATA);
                        return NULL;
diff --git a/fs/smbfs/inode.c b/fs/smbfs/inode.c
index 44ed1d418b46..fdeabc0a34f7 100644
--- a/fs/smbfs/inode.c
+++ b/fs/smbfs/inode.c
@@ -217,7 +217,7 @@ smb_set_inode_attr(struct inode *inode, struct smb_fattr *fattr)
        if (inode->i_mtime.tv_sec != last_time || inode->i_size != last_sz) {
                VERBOSE("%ld changed, old=%ld, new=%ld, oz=%ld, nz=%ld\n",
                        inode->i_ino,
-                        (long) last_time, (long) inode->i_mtime,
+                        (long) last_time, (long) inode->i_mtime.tv_sec,
                        (long) last_sz, (long) inode->i_size);
                if (!S_ISDIR(inode->i_mode))
diff --git a/fs/super.c b/fs/super.c
index 37554b876182..8743e9bbb297 100644
--- a/fs/super.c
+++ b/fs/super.c
@@ -55,11 +55,10 @@ DEFINE_SPINLOCK(sb_lock);
 */
 static struct super_block *alloc_super(void)
 {
-        struct super_block *s = kmalloc(sizeof(struct super_block),  GFP_USER);
+        struct super_block *s = kzalloc(sizeof(struct super_block),  GFP_USER);
        static struct super_operations default_op;
        if (s) {
-                memset(s, 0, sizeof(struct super_block));
                if (security_sb_alloc(s)) {
                        kfree(s);
                        s = NULL;
diff --git a/fs/udf/inode.c b/fs/udf/inode.c
index d04cff2273b6..81e0e8459af1 100644
--- a/fs/udf/inode.c
+++ b/fs/udf/inode.c
@@ -1341,13 +1341,11 @@ udf_update_inode(struct inode *inode, int do_sync)
        if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_UID_FORGET))
                fe->uid = cpu_to_le32(-1);
-        else if (inode->i_uid != UDF_SB(inode->i_sb)->s_uid)
+        else fe->uid = cpu_to_le32(inode->i_uid);
-                fe->uid = cpu_to_le32(inode->i_uid);
        if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_GID_FORGET))
                fe->gid = cpu_to_le32(-1);
-        else if (inode->i_gid != UDF_SB(inode->i_sb)->s_gid)
+        else fe->gid = cpu_to_le32(inode->i_gid);
-                fe->gid = cpu_to_le32(inode->i_gid);
        udfperms =      ((inode->i_mode & S_IRWXO)     ) |
                        ((inode->i_mode & S_IRWXG) << 2) |