Merge git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6 into for-linus

21 files changed, 170 insertions, 220 deletions

diff --git a/fs/bio.c b/fs/bio.c
index 242e409dab4b..3312fcc3c098 100644
--- a/fs/bio.c
+++ b/fs/bio.c
@@ -903,7 +903,7 @@ void bio_set_pages_dirty(struct bio *bio)
         }
 }
 
-void bio_release_pages(struct bio *bio)
+static void bio_release_pages(struct bio *bio)
 {
         struct bio_vec *bvec = bio->bi_io_vec;
         int i;
diff --git a/fs/block_dev.c b/fs/block_dev.c
index 67fe72ce6ac7..7d822fae7765 100644
--- a/fs/block_dev.c
+++ b/fs/block_dev.c
@@ -31,6 +31,8 @@ struct bdev_inode {
         struct inode vfs_inode;
 };
 
+static const struct address_space_operations def_blk_aops;
+
 static inline struct bdev_inode *BDEV_I(struct inode *inode)
 {
         return container_of(inode, struct bdev_inode, vfs_inode);
@@ -171,203 +173,6 @@ blkdev_direct_IO(int rw, struct kiocb *iocb, const struct iovec *iov,
                                 iov, offset, nr_segs, blkdev_get_blocks, NULL);
 }
 
-#if 0
-static void blk_end_aio(struct bio *bio, int error)
-{
-        struct kiocb *iocb = bio->bi_private;
-        atomic_t *bio_count = &iocb->ki_bio_count;
-
-        if (bio_data_dir(bio) == READ)
-                bio_check_pages_dirty(bio);
-        else {
-                bio_release_pages(bio);
-                bio_put(bio);
-        }
-
-        /* iocb->ki_nbytes stores error code from LLDD */
-        if (error)
-                iocb->ki_nbytes = -EIO;
-
-        if (atomic_dec_and_test(bio_count)) {
-                if ((long)iocb->ki_nbytes < 0)
-                        aio_complete(iocb, iocb->ki_nbytes, 0);
-                else
-                        aio_complete(iocb, iocb->ki_left, 0);
-        }
-
-        return 0;
-}
-
-#define VEC_SIZE        16
-struct pvec {
-        unsigned short nr;
-        unsigned short idx;
-        struct page *page[VEC_SIZE];
-};
-
-#define PAGES_SPANNED(addr, len)        \
-        (DIV_ROUND_UP((addr) + (len), PAGE_SIZE) - (addr) / PAGE_SIZE);
-
-/*
- * get page pointer for user addr, we internally cache struct page array for
- * (addr, count) range in pvec to avoid frequent call to get_user_pages.  If
- * internal page list is exhausted, a batch count of up to VEC_SIZE is used
- * to get next set of page struct.
- */
-static struct page *blk_get_page(unsigned long addr, size_t count, int rw,
-                                 struct pvec *pvec)
-{
-        int ret, nr_pages;
-        if (pvec->idx == pvec->nr) {
-                nr_pages = PAGES_SPANNED(addr, count);
-                nr_pages = min(nr_pages, VEC_SIZE);
-                down_read(&current->mm->mmap_sem);
-                ret = get_user_pages(current, current->mm, addr, nr_pages,
-                                     rw == READ, 0, pvec->page, NULL);
-                up_read(&current->mm->mmap_sem);
-                if (ret < 0)
-                        return ERR_PTR(ret);
-                pvec->nr = ret;
-                pvec->idx = 0;
-        }
-        return pvec->page[pvec->idx++];
-}
-
-/* return a page back to pvec array */
-static void blk_unget_page(struct page *page, struct pvec *pvec)
-{
-        pvec->page[--pvec->idx] = page;
-}
-
-static ssize_t
-blkdev_direct_IO(int rw, struct kiocb *iocb, const struct iovec *iov,
-                 loff_t pos, unsigned long nr_segs)
-{
-        struct inode *inode = iocb->ki_filp->f_mapping->host;
-        unsigned blkbits = blksize_bits(bdev_hardsect_size(I_BDEV(inode)));
-        unsigned blocksize_mask = (1 << blkbits) - 1;
-        unsigned long seg = 0;  /* iov segment iterator */
-        unsigned long nvec;     /* number of bio vec needed */
-        unsigned long cur_off;  /* offset into current page */
-        unsigned long cur_len;  /* I/O len of current page, up to PAGE_SIZE */
-
-        unsigned long addr;     /* user iovec address */
-        size_t count;           /* user iovec len */
-        size_t nbytes = iocb->ki_nbytes = iocb->ki_left; /* total xfer size */
-        loff_t size;            /* size of block device */
-        struct bio *bio;
-        atomic_t *bio_count = &iocb->ki_bio_count;
-        struct page *page;
-        struct pvec pvec;
-
-        pvec.nr = 0;
-        pvec.idx = 0;
-
-        if (pos & blocksize_mask)
-                return -EINVAL;
-
-        size = i_size_read(inode);
-        if (pos + nbytes > size) {
-                nbytes = size - pos;
-                iocb->ki_left = nbytes;
-        }
-
-        /*
-         * check first non-zero iov alignment, the remaining
-         * iov alignment is checked inside bio loop below.
-         */
-        do {
-                addr = (unsigned long) iov[seg].iov_base;
-                count = min(iov[seg].iov_len, nbytes);
-                if (addr & blocksize_mask || count & blocksize_mask)
-                        return -EINVAL;
-        } while (!count && ++seg < nr_segs);
-        atomic_set(bio_count, 1);
-
-        while (nbytes) {
-                /* roughly estimate number of bio vec needed */
-                nvec = (nbytes + PAGE_SIZE - 1) / PAGE_SIZE;
-                nvec = max(nvec, nr_segs - seg);
-                nvec = min(nvec, (unsigned long) BIO_MAX_PAGES);
-
-                /* bio_alloc should not fail with GFP_KERNEL flag */
-                bio = bio_alloc(GFP_KERNEL, nvec);
-                bio->bi_bdev = I_BDEV(inode);
-                bio->bi_end_io = blk_end_aio;
-                bio->bi_private = iocb;
-                bio->bi_sector = pos >> blkbits;
-same_bio:
-                cur_off = addr & ~PAGE_MASK;
-                cur_len = PAGE_SIZE - cur_off;
-                if (count < cur_len)
-                        cur_len = count;
-
-                page = blk_get_page(addr, count, rw, &pvec);
-                if (unlikely(IS_ERR(page)))
-                        goto backout;
-
-                if (bio_add_page(bio, page, cur_len, cur_off)) {
-                        pos += cur_len;
-                        addr += cur_len;
-                        count -= cur_len;
-                        nbytes -= cur_len;
-
-                        if (count)
-                                goto same_bio;
-                        while (++seg < nr_segs) {
-                                addr = (unsigned long) iov[seg].iov_base;
-                                count = iov[seg].iov_len;
-                                if (!count)
-                                        continue;
-                                if (unlikely(addr & blocksize_mask ||
-                                             count & blocksize_mask)) {
-                                        page = ERR_PTR(-EINVAL);
-                                        goto backout;
-                                }
-                                count = min(count, nbytes);
-                                goto same_bio;
-                        }
-                } else {
-                        blk_unget_page(page, &pvec);
-                }
-
-                /* bio is ready, submit it */
-                if (rw == READ)
-                        bio_set_pages_dirty(bio);
-                atomic_inc(bio_count);
-                submit_bio(rw, bio);
-        }
-
-completion:
-        iocb->ki_left -= nbytes;
-        nbytes = iocb->ki_left;
-        iocb->ki_pos += nbytes;
-
-        blk_run_address_space(inode->i_mapping);
-        if (atomic_dec_and_test(bio_count))
-                aio_complete(iocb, nbytes, 0);
-
-        return -EIOCBQUEUED;
-
-backout:
-        /*
-         * back out nbytes count constructed so far for this bio,
-         * we will throw away current bio.
-         */
-        nbytes += bio->bi_size;
-        bio_release_pages(bio);
-        bio_put(bio);
-
-        /*
-         * if no bio was submmitted, return the error code.
-         * otherwise, proceed with pending I/O completion.
-         */
-        if (atomic_read(bio_count) == 1)
-                return PTR_ERR(page);
-        goto completion;
-}
-#endif
-
 static int blkdev_writepage(struct page *page, struct writeback_control *wbc)
 {
         return block_write_full_page(page, blkdev_get_block, wbc);
@@ -1334,7 +1139,7 @@ static long block_ioctl(struct file *file, unsigned cmd, unsigned long arg)
         return blkdev_ioctl(file->f_mapping->host, file, cmd, arg);
 }
 
-const struct address_space_operations def_blk_aops = {
+static const struct address_space_operations def_blk_aops = {
         .readpage       = blkdev_readpage,
         .writepage      = blkdev_writepage,
         .sync_page      = block_sync_page,
diff --git a/fs/dlm/rcom.c b/fs/dlm/rcom.c
index 035e6f9990b0..67522c268c14 100644
--- a/fs/dlm/rcom.c
+++ b/fs/dlm/rcom.c
@@ -215,6 +215,8 @@ int dlm_rcom_names(struct dlm_ls *ls, int nodeid, char *last_name, int last_len)
         ls->ls_recover_nodeid = nodeid;
 
         if (nodeid == dlm_our_nodeid()) {
+                ls->ls_recover_buf->rc_header.h_length =
+                        dlm_config.ci_buffer_size;
                 dlm_copy_master_names(ls, last_name, last_len,
                                       ls->ls_recover_buf->rc_buf,
                                       max_size, nodeid);
diff --git a/fs/efs/dir.c b/fs/efs/dir.c
index dfb5cb400217..49308a29798a 100644
--- a/fs/efs/dir.c
+++ b/fs/efs/dir.c
@@ -5,8 +5,8 @@
  */
 
 #include <linux/buffer_head.h>
-#include <linux/efs_fs.h>
 #include <linux/smp_lock.h>
+#include "efs.h"
 
 static int efs_readdir(struct file *, void *, filldir_t);
 
diff --git a/fs/efs/efs.h b/fs/efs/efs.h
new file mode 100644
index 000000000000..d8305b582ab0
--- /dev/null
+++ b/fs/efs/efs.h
@@ -0,0 +1,140 @@
+/*
+ * Copyright (c) 1999 Al Smith
+ *
+ * Portions derived from work (c) 1995,1996 Christian Vogelgsang.
+ * Portions derived from IRIX header files (c) 1988 Silicon Graphics
+ */
+#ifndef _EFS_EFS_H_
+#define _EFS_EFS_H_
+
+#include <linux/fs.h>
+#include <asm/uaccess.h>
+
+#define EFS_VERSION "1.0a"
+
+static const char cprt[] = "EFS: "EFS_VERSION" - (c) 1999 Al Smith <Al.Smith@aeschi.ch.eu.org>";
+
+
+/* 1 block is 512 bytes */
+#define EFS_BLOCKSIZE_BITS      9
+#define EFS_BLOCKSIZE           (1 << EFS_BLOCKSIZE_BITS)
+
+typedef int32_t         efs_block_t;
+typedef uint32_t        efs_ino_t;
+
+#define EFS_DIRECTEXTENTS       12
+
+/*
+ * layout of an extent, in memory and on disk. 8 bytes exactly.
+ */
+typedef union extent_u {
+        unsigned char raw[8];
+        struct extent_s {
+                unsigned int    ex_magic:8;     /* magic # (zero) */
+                unsigned int    ex_bn:24;       /* basic block */
+                unsigned int    ex_length:8;    /* numblocks in this extent */
+                unsigned int    ex_offset:24;   /* logical offset into file */
+        } cooked;
+} efs_extent;
+
+typedef struct edevs {
+        __be16          odev;
+        __be32          ndev;
+} efs_devs;
+
+/*
+ * extent based filesystem inode as it appears on disk.  The efs inode
+ * is exactly 128 bytes long.
+ */
+struct  efs_dinode {
+        __be16          di_mode;        /* mode and type of file */
+        __be16          di_nlink;       /* number of links to file */
+        __be16          di_uid;         /* owner's user id */
+        __be16          di_gid;         /* owner's group id */
+        __be32          di_size;        /* number of bytes in file */
+        __be32          di_atime;       /* time last accessed */
+        __be32          di_mtime;       /* time last modified */
+        __be32          di_ctime;       /* time created */
+        __be32          di_gen;         /* generation number */
+        __be16          di_numextents;  /* # of extents */
+        u_char          di_version;     /* version of inode */
+        u_char          di_spare;       /* spare - used by AFS */
+        union di_addr {
+                efs_extent      di_extents[EFS_DIRECTEXTENTS];
+                efs_devs        di_dev; /* device for IFCHR/IFBLK */
+        } di_u;
+};
+
+/* efs inode storage in memory */
+struct efs_inode_info {
+        int             numextents;
+        int             lastextent;
+
+        efs_extent      extents[EFS_DIRECTEXTENTS];
+        struct inode    vfs_inode;
+};
+
+#include <linux/efs_fs_sb.h>
+
+#define EFS_DIRBSIZE_BITS       EFS_BLOCKSIZE_BITS
+#define EFS_DIRBSIZE            (1 << EFS_DIRBSIZE_BITS)
+
+struct efs_dentry {
+        __be32          inode;
+        unsigned char   namelen;
+        char            name[3];
+};
+
+#define EFS_DENTSIZE    (sizeof(struct efs_dentry) - 3 + 1)
+#define EFS_MAXNAMELEN  ((1 << (sizeof(char) * 8)) - 1)
+
+#define EFS_DIRBLK_HEADERSIZE   4
+#define EFS_DIRBLK_MAGIC        0xbeef  /* moo */
+
+struct efs_dir {
+        __be16  magic;
+        unsigned char   firstused;
+        unsigned char   slots;
+
+        unsigned char   space[EFS_DIRBSIZE - EFS_DIRBLK_HEADERSIZE];
+};
+
+#define EFS_MAXENTS \
+        ((EFS_DIRBSIZE - EFS_DIRBLK_HEADERSIZE) / \
+         (EFS_DENTSIZE + sizeof(char)))
+
+#define EFS_SLOTAT(dir, slot) EFS_REALOFF((dir)->space[slot])
+
+#define EFS_REALOFF(offset) ((offset << 1))
+
+
+static inline struct efs_inode_info *INODE_INFO(struct inode *inode)
+{
+        return container_of(inode, struct efs_inode_info, vfs_inode);
+}
+
+static inline struct efs_sb_info *SUPER_INFO(struct super_block *sb)
+{
+        return sb->s_fs_info;
+}
+
+struct statfs;
+struct fid;
+
+extern const struct inode_operations efs_dir_inode_operations;
+extern const struct file_operations efs_dir_operations;
+extern const struct address_space_operations efs_symlink_aops;
+
+extern struct inode *efs_iget(struct super_block *, unsigned long);
+extern efs_block_t efs_map_block(struct inode *, efs_block_t);
+extern int efs_get_block(struct inode *, sector_t, struct buffer_head *, int);
+
+extern struct dentry *efs_lookup(struct inode *, struct dentry *, struct nameidata *);
+extern struct dentry *efs_fh_to_dentry(struct super_block *sb, struct fid *fid,
+                int fh_len, int fh_type);
+extern struct dentry *efs_fh_to_parent(struct super_block *sb, struct fid *fid,
+                int fh_len, int fh_type);
+extern struct dentry *efs_get_parent(struct dentry *);
+extern int efs_bmap(struct inode *, int);
+
+#endif /* _EFS_EFS_H_ */
diff --git a/fs/efs/file.c b/fs/efs/file.c
index 5db20129681e..1ccb364ffa63 100644
--- a/fs/efs/file.c
+++ b/fs/efs/file.c
@@ -7,7 +7,7 @@
  */
 
 #include <linux/buffer_head.h>
-#include <linux/efs_fs.h>
+#include "efs.h"
 
 int efs_get_block(struct inode *inode, sector_t iblock,
                   struct buffer_head *bh_result, int create)
diff --git a/fs/efs/inode.c b/fs/efs/inode.c
index 627c3026946d..79e19e5958e1 100644
--- a/fs/efs/inode.c
+++ b/fs/efs/inode.c
@@ -7,11 +7,11 @@
  *              and from work (c) 1998 Mike Shaver.
  */
 
-#include <linux/efs_fs.h>
-#include <linux/efs_fs_sb.h>
 #include <linux/buffer_head.h>
 #include <linux/module.h>
 #include <linux/fs.h>
+#include "efs.h"
+#include <linux/efs_fs_sb.h>
 
 static int efs_readpage(struct file *file, struct page *page)
 {
diff --git a/fs/efs/namei.c b/fs/efs/namei.c
index e26704742d41..3a404e7fad53 100644
--- a/fs/efs/namei.c
+++ b/fs/efs/namei.c
@@ -8,9 +8,9 @@
 
 #include <linux/buffer_head.h>
 #include <linux/string.h>
-#include <linux/efs_fs.h>
 #include <linux/smp_lock.h>
 #include <linux/exportfs.h>
+#include "efs.h"
 
 
 static efs_ino_t efs_find_entry(struct inode *inode, const char *name, int len) {
diff --git a/fs/efs/super.c b/fs/efs/super.c
index 14082405cdd1..d733531b55e2 100644
--- a/fs/efs/super.c
+++ b/fs/efs/super.c
@@ -8,14 +8,15 @@
 
 #include <linux/init.h>
 #include <linux/module.h>
-#include <linux/efs_fs.h>
-#include <linux/efs_vh.h>
-#include <linux/efs_fs_sb.h>
 #include <linux/exportfs.h>
 #include <linux/slab.h>
 #include <linux/buffer_head.h>
 #include <linux/vfs.h>
 
+#include "efs.h"
+#include <linux/efs_vh.h>
+#include <linux/efs_fs_sb.h>
+
 static int efs_statfs(struct dentry *dentry, struct kstatfs *buf);
 static int efs_fill_super(struct super_block *s, void *d, int silent);
 
diff --git a/fs/efs/symlink.c b/fs/efs/symlink.c
index 1d30d2ff440f..41911ec83aaf 100644
--- a/fs/efs/symlink.c
+++ b/fs/efs/symlink.c
@@ -7,10 +7,10 @@
  */
 
 #include <linux/string.h>
-#include <linux/efs_fs.h>
 #include <linux/pagemap.h>
 #include <linux/buffer_head.h>
 #include <linux/smp_lock.h>
+#include "efs.h"
 
 static int efs_symlink_readpage(struct file *file, struct page *page)
 {
diff --git a/fs/fuse/dir.c b/fs/fuse/dir.c
index 7fb514b6d852..c4807b3fc8a3 100644
--- a/fs/fuse/dir.c
+++ b/fs/fuse/dir.c
@@ -906,7 +906,7 @@ static int fuse_permission(struct inode *inode, int mask, struct nameidata *nd)
         }
 
         if (fc->flags & FUSE_DEFAULT_PERMISSIONS) {
-                int err = generic_permission(inode, mask, NULL);
+                err = generic_permission(inode, mask, NULL);
 
                 /* If permission is denied, try to refresh file
                    attributes.  This is also needed, because the root
diff --git a/fs/lockd/svc.c b/fs/lockd/svc.c
index 08226464e563..1ed8bd4de941 100644
--- a/fs/lockd/svc.c
+++ b/fs/lockd/svc.c
@@ -153,7 +153,7 @@ lockd(struct svc_rqst *rqstp)
          */
         while ((nlmsvc_users || !signalled()) && nlmsvc_pid == current->pid) {
                 long timeout = MAX_SCHEDULE_TIMEOUT;
-                char buf[RPC_MAX_ADDRBUFLEN];
+                RPC_IFDEBUG(char buf[RPC_MAX_ADDRBUFLEN]);
 
                 if (signalled()) {
                         flush_signals(current);
diff --git a/fs/nfs/callback.c b/fs/nfs/callback.c
index ecc06c619494..66648dd92d97 100644
--- a/fs/nfs/callback.c
+++ b/fs/nfs/callback.c
@@ -93,6 +93,7 @@ static void nfs_callback_svc(struct svc_rqst *rqstp)
                 svc_process(rqstp);
         }
 
+        flush_signals(current);
         svc_exit_thread(rqstp);
         nfs_callback_info.pid = 0;
         complete(&nfs_callback_info.stopped);
@@ -171,7 +172,7 @@ void nfs_callback_down(void)
 static int nfs_callback_authenticate(struct svc_rqst *rqstp)
 {
         struct nfs_client *clp;
-        char buf[RPC_MAX_ADDRBUFLEN];
+        RPC_IFDEBUG(char buf[RPC_MAX_ADDRBUFLEN]);
 
         /* Don't talk to strangers */
         clp = nfs_find_client(svc_addr(rqstp), 4);
diff --git a/fs/nfs/callback_xdr.c b/fs/nfs/callback_xdr.c
index c63eb720b68b..13619d24f023 100644
--- a/fs/nfs/callback_xdr.c
+++ b/fs/nfs/callback_xdr.c
@@ -254,7 +254,7 @@ static __be32 encode_attr_change(struct xdr_stream *xdr, const uint32_t *bitmap,
         if (!(bitmap[0] & FATTR4_WORD0_CHANGE))
                 return 0;
         p = xdr_reserve_space(xdr, 8);
-        if (unlikely(p == 0))
+        if (unlikely(!p))
                 return htonl(NFS4ERR_RESOURCE);
         p = xdr_encode_hyper(p, change);
         return 0;
@@ -267,7 +267,7 @@ static __be32 encode_attr_size(struct xdr_stream *xdr, const uint32_t *bitmap, u
         if (!(bitmap[0] & FATTR4_WORD0_SIZE))
                 return 0;
         p = xdr_reserve_space(xdr, 8);
-        if (unlikely(p == 0))
+        if (unlikely(!p))
                 return htonl(NFS4ERR_RESOURCE);
         p = xdr_encode_hyper(p, size);
         return 0;
@@ -278,7 +278,7 @@ static __be32 encode_attr_time(struct xdr_stream *xdr, const struct timespec *ti
         __be32 *p;
 
         p = xdr_reserve_space(xdr, 12);
-        if (unlikely(p == 0))
+        if (unlikely(!p))
                 return htonl(NFS4ERR_RESOURCE);
         p = xdr_encode_hyper(p, time->tv_sec);
         *p = htonl(time->tv_nsec);
diff --git a/fs/nfs/delegation.c b/fs/nfs/delegation.c
index b9eadd18ba70..00a5e4405e16 100644
--- a/fs/nfs/delegation.c
+++ b/fs/nfs/delegation.c
@@ -49,7 +49,7 @@ static int nfs_delegation_claim_locks(struct nfs_open_context *ctx, struct nfs4_
         struct file_lock *fl;
         int status;
 
-        for (fl = inode->i_flock; fl != 0; fl = fl->fl_next) {
+        for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) {
                 if (!(fl->fl_flags & (FL_POSIX|FL_FLOCK)))
                         continue;
                 if (nfs_file_open_context(fl->fl_file) != ctx)
diff --git a/fs/nfs/idmap.c b/fs/nfs/idmap.c
index 8ae5dba2d4e5..86147b0ab2cf 100644
--- a/fs/nfs/idmap.c
+++ b/fs/nfs/idmap.c
@@ -309,7 +309,7 @@ nfs_idmap_name(struct idmap *idmap, struct idmap_hashtable *h,
         mutex_lock(&idmap->idmap_im_lock);
 
         he = idmap_lookup_id(h, id);
-        if (he != 0) {
+        if (he) {
                 memcpy(name, he->ih_name, he->ih_namelen);
                 ret = he->ih_namelen;
                 goto out;
diff --git a/fs/nfs/nfs4state.c b/fs/nfs/nfs4state.c
index 6233eb5e98c1..b962397004c1 100644
--- a/fs/nfs/nfs4state.c
+++ b/fs/nfs/nfs4state.c
@@ -785,7 +785,7 @@ static int nfs4_reclaim_locks(struct nfs4_state_recovery_ops *ops, struct nfs4_s
         struct file_lock *fl;
         int status = 0;
 
-        for (fl = inode->i_flock; fl != 0; fl = fl->fl_next) {
+        for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) {
                 if (!(fl->fl_flags & (FL_POSIX|FL_FLOCK)))
                         continue;
                 if (nfs_file_open_context(fl->fl_file)->state != state)
diff --git a/fs/nfsd/nfsfh.c b/fs/nfsd/nfsfh.c
index 0130b345234d..1eb771d79cca 100644
--- a/fs/nfsd/nfsfh.c
+++ b/fs/nfsd/nfsfh.c
@@ -101,7 +101,7 @@ static __be32 nfsd_setuser_and_check_port(struct svc_rqst *rqstp,
 {
         /* Check if the request originated from a secure port. */
         if (!rqstp->rq_secure && EX_SECURE(exp)) {
-                char buf[RPC_MAX_ADDRBUFLEN];
+                RPC_IFDEBUG(char buf[RPC_MAX_ADDRBUFLEN]);
                 dprintk(KERN_WARNING
                        "nfsd: request from insecure port %s!\n",
                        svc_print_addr(rqstp, buf, sizeof(buf)));
diff --git a/fs/proc/base.c b/fs/proc/base.c
index 88f8edf18258..96ee899d6502 100644
--- a/fs/proc/base.c
+++ b/fs/proc/base.c
@@ -416,6 +416,7 @@ static const struct limit_names lnames[RLIM_NLIMITS] = {
         [RLIMIT_MSGQUEUE] = {"Max msgqueue size", "bytes"},
         [RLIMIT_NICE] = {"Max nice priority", NULL},
         [RLIMIT_RTPRIO] = {"Max realtime priority", NULL},
+        [RLIMIT_RTTIME] = {"Max realtime timeout", "us"},
 };
 
 /* Display limits for a process */
diff --git a/fs/proc/task_mmu.c b/fs/proc/task_mmu.c
index 49958cffbd8d..6dc0334815f7 100644
--- a/fs/proc/task_mmu.c
+++ b/fs/proc/task_mmu.c
@@ -531,7 +531,7 @@ struct pagemapread {
 #define PM_RESERVED_BITS    3
 #define PM_RESERVED_OFFSET  (64 - PM_RESERVED_BITS)
 #define PM_RESERVED_MASK    (((1LL<<PM_RESERVED_BITS)-1) << PM_RESERVED_OFFSET)
-#define PM_SPECIAL(nr)      (((nr) << PM_RESERVED_OFFSET) | PM_RESERVED_MASK)
+#define PM_SPECIAL(nr)      (((nr) << PM_RESERVED_OFFSET) & PM_RESERVED_MASK)
 #define PM_NOT_PRESENT      PM_SPECIAL(1LL)
 #define PM_SWAP             PM_SPECIAL(2LL)
 #define PM_END_OF_BUFFER    1
diff --git a/fs/ufs/util.h b/fs/ufs/util.h
index b26fc4dec1e7..23ceed8c8fb9 100644
--- a/fs/ufs/util.h
+++ b/fs/ufs/util.h
@@ -58,7 +58,7 @@ ufs_set_fs_state(struct super_block *sb, struct ufs_super_block_first *usb1,
 {
         switch (UFS_SB(sb)->s_flags & UFS_ST_MASK) {
         case UFS_ST_SUNOS:
-                if (fs32_to_cpu(sb, usb3->fs_postblformat == UFS_42POSTBLFMT)) {
+                if (fs32_to_cpu(sb, usb3->fs_postblformat) == UFS_42POSTBLFMT) {
                         usb1->fs_u0.fs_sun.fs_state = cpu_to_fs32(sb, value);
                         break;
                 }