44 files changed, 523 insertions, 149 deletions

diff --git a/fs/bad_inode.c b/fs/bad_inode.c
index b1342ffb3cf6..922ad460bff9 100644
--- a/fs/bad_inode.c
+++ b/fs/bad_inode.c
@@ -16,7 +16,7 @@
 #include <linux/poll.h>
 
 
-static loff_t bad_file_llseek(struct file *file, loff_t offset, int origin)
+static loff_t bad_file_llseek(struct file *file, loff_t offset, int whence)
 {
         return -EIO;
 }
diff --git a/fs/binfmt_elf.c b/fs/binfmt_elf.c
index 6d7d1647a68c..0c42cdbabecf 100644
--- a/fs/binfmt_elf.c
+++ b/fs/binfmt_elf.c
@@ -1601,8 +1601,10 @@ static int fill_note_info(struct elfhdr *elf, int phdrs,
         info->thread = NULL;
 
         psinfo = kmalloc(sizeof(*psinfo), GFP_KERNEL);
-        if (psinfo == NULL)
+        if (psinfo == NULL) {
+                info->psinfo.data = NULL; /* So we don't free this wrongly */
                 return 0;
+        }
 
         fill_note(&info->psinfo, "CORE", NT_PRPSINFO, sizeof(*psinfo), psinfo);
 
diff --git a/fs/binfmt_em86.c b/fs/binfmt_em86.c
index 4e6cce57d113..037a3e2b045b 100644
--- a/fs/binfmt_em86.c
+++ b/fs/binfmt_em86.c
@@ -42,7 +42,6 @@ static int load_em86(struct linux_binprm *bprm)
                         return -ENOEXEC;
         }
 
-        bprm->recursion_depth++; /* Well, the bang-shell is implicit... */
         allow_write_access(bprm->file);
         fput(bprm->file);
         bprm->file = NULL;
diff --git a/fs/binfmt_misc.c b/fs/binfmt_misc.c
index b0b70fbea06c..9be335fb8a7c 100644
--- a/fs/binfmt_misc.c
+++ b/fs/binfmt_misc.c
@@ -117,10 +117,6 @@ static int load_misc_binary(struct linux_binprm *bprm)
         if (!enabled)
                 goto _ret;
 
-        retval = -ENOEXEC;
-        if (bprm->recursion_depth > BINPRM_MAX_RECURSION)
-                goto _ret;
-
         /* to keep locking time low, we copy the interpreter string */
         read_lock(&entries_lock);
         fmt = check_file(bprm);
@@ -197,8 +193,6 @@ static int load_misc_binary(struct linux_binprm *bprm)
         if (retval < 0)
                 goto _error;
 
-        bprm->recursion_depth++;
-
         retval = search_binary_handler(bprm);
         if (retval < 0)
                 goto _error;
diff --git a/fs/binfmt_script.c b/fs/binfmt_script.c
index 8c954997e7f7..1610a91637e5 100644
--- a/fs/binfmt_script.c
+++ b/fs/binfmt_script.c
@@ -22,15 +22,13 @@ static int load_script(struct linux_binprm *bprm)
         char interp[BINPRM_BUF_SIZE];
         int retval;
 
-        if ((bprm->buf[0] != '#') || (bprm->buf[1] != '!') ||
-            (bprm->recursion_depth > BINPRM_MAX_RECURSION))
+        if ((bprm->buf[0] != '#') || (bprm->buf[1] != '!'))
                 return -ENOEXEC;
         /*
          * This section does the #! interpretation.
          * Sorta complicated, but hopefully it will work.  -TYT
          */
 
-        bprm->recursion_depth++;
         allow_write_access(bprm->file);
         fput(bprm->file);
         bprm->file = NULL;
diff --git a/fs/block_dev.c b/fs/block_dev.c
index ab3a456f6650..172f8491a2bd 100644
--- a/fs/block_dev.c
+++ b/fs/block_dev.c
@@ -321,7 +321,7 @@ static int blkdev_write_end(struct file *file, struct address_space *mapping,
  * for a block special file file->f_path.dentry->d_inode->i_size is zero
  * so we compute the size by hand (just as in block_read/write above)
  */
-static loff_t block_llseek(struct file *file, loff_t offset, int origin)
+static loff_t block_llseek(struct file *file, loff_t offset, int whence)
 {
         struct inode *bd_inode = file->f_mapping->host;
         loff_t size;
@@ -331,7 +331,7 @@ static loff_t block_llseek(struct file *file, loff_t offset, int origin)
         size = i_size_read(bd_inode);
 
         retval = -EINVAL;
-        switch (origin) {
+        switch (whence) {
                 case SEEK_END:
                         offset += size;
                         break;
diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index a8ee75cb96ee..9c6673a9231f 100644
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -2120,7 +2120,7 @@ out:
         return ret;
 }
 
-static int find_desired_extent(struct inode *inode, loff_t *offset, int origin)
+static int find_desired_extent(struct inode *inode, loff_t *offset, int whence)
 {
         struct btrfs_root *root = BTRFS_I(inode)->root;
         struct extent_map *em;
@@ -2154,7 +2154,7 @@ static int find_desired_extent(struct inode *inode, loff_t *offset, int origin)
          * before the position we want in case there is outstanding delalloc
          * going on here.
          */
-        if (origin == SEEK_HOLE && start != 0) {
+        if (whence == SEEK_HOLE && start != 0) {
                 if (start <= root->sectorsize)
                         em = btrfs_get_extent_fiemap(inode, NULL, 0, 0,
                                                      root->sectorsize, 0);
@@ -2188,13 +2188,13 @@ static int find_desired_extent(struct inode *inode, loff_t *offset, int origin)
                                 }
                         }
 
-                        if (origin == SEEK_HOLE) {
+                        if (whence == SEEK_HOLE) {
                                 *offset = start;
                                 free_extent_map(em);
                                 break;
                         }
                 } else {
-                        if (origin == SEEK_DATA) {
+                        if (whence == SEEK_DATA) {
                                 if (em->block_start == EXTENT_MAP_DELALLOC) {
                                         if (start >= inode->i_size) {
                                                 free_extent_map(em);
@@ -2231,16 +2231,16 @@ out:
         return ret;
 }
 
-static loff_t btrfs_file_llseek(struct file *file, loff_t offset, int origin)
+static loff_t btrfs_file_llseek(struct file *file, loff_t offset, int whence)
 {
         struct inode *inode = file->f_mapping->host;
         int ret;
 
         mutex_lock(&inode->i_mutex);
-        switch (origin) {
+        switch (whence) {
         case SEEK_END:
         case SEEK_CUR:
-                offset = generic_file_llseek(file, offset, origin);
+                offset = generic_file_llseek(file, offset, whence);
                 goto out;
         case SEEK_DATA:
         case SEEK_HOLE:
@@ -2249,7 +2249,7 @@ static loff_t btrfs_file_llseek(struct file *file, loff_t offset, int origin)
                         return -ENXIO;
                 }
 
-                ret = find_desired_extent(inode, &offset, origin);
+                ret = find_desired_extent(inode, &offset, whence);
                 if (ret) {
                         mutex_unlock(&inode->i_mutex);
                         return ret;
diff --git a/fs/ceph/dir.c b/fs/ceph/dir.c
index e5b77319c97b..8c1aabe93b67 100644
--- a/fs/ceph/dir.c
+++ b/fs/ceph/dir.c
@@ -454,7 +454,7 @@ static void reset_readdir(struct ceph_file_info *fi)
         fi->flags &= ~CEPH_F_ATEND;
 }
 
-static loff_t ceph_dir_llseek(struct file *file, loff_t offset, int origin)
+static loff_t ceph_dir_llseek(struct file *file, loff_t offset, int whence)
 {
         struct ceph_file_info *fi = file->private_data;
         struct inode *inode = file->f_mapping->host;
@@ -463,7 +463,7 @@ static loff_t ceph_dir_llseek(struct file *file, loff_t offset, int origin)
 
         mutex_lock(&inode->i_mutex);
         retval = -EINVAL;
-        switch (origin) {
+        switch (whence) {
         case SEEK_END:
                 offset += inode->i_size + 2;   /* FIXME */
                 break;
diff --git a/fs/ceph/file.c b/fs/ceph/file.c
index 5840d2aaed15..d4dfdcf76d7f 100644
--- a/fs/ceph/file.c
+++ b/fs/ceph/file.c
@@ -797,7 +797,7 @@ out:
 /*
  * llseek.  be sure to verify file size on SEEK_END.
  */
-static loff_t ceph_llseek(struct file *file, loff_t offset, int origin)
+static loff_t ceph_llseek(struct file *file, loff_t offset, int whence)
 {
         struct inode *inode = file->f_mapping->host;
         int ret;
@@ -805,7 +805,7 @@ static loff_t ceph_llseek(struct file *file, loff_t offset, int origin)
         mutex_lock(&inode->i_mutex);
         __ceph_do_pending_vmtruncate(inode);
 
-        if (origin == SEEK_END || origin == SEEK_DATA || origin == SEEK_HOLE) {
+        if (whence == SEEK_END || whence == SEEK_DATA || whence == SEEK_HOLE) {
                 ret = ceph_do_getattr(inode, CEPH_STAT_CAP_SIZE);
                 if (ret < 0) {
                         offset = ret;
@@ -813,7 +813,7 @@ static loff_t ceph_llseek(struct file *file, loff_t offset, int origin)
                 }
         }
 
-        switch (origin) {
+        switch (whence) {
         case SEEK_END:
                 offset += inode->i_size;
                 break;
diff --git a/fs/cifs/cifsfs.c b/fs/cifs/cifsfs.c
index 210f0af83fc4..ce9f3c5421bf 100644
--- a/fs/cifs/cifsfs.c
+++ b/fs/cifs/cifsfs.c
@@ -695,13 +695,13 @@ static ssize_t cifs_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
         return written;
 }
 
-static loff_t cifs_llseek(struct file *file, loff_t offset, int origin)
+static loff_t cifs_llseek(struct file *file, loff_t offset, int whence)
 {
         /*
-         * origin == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate
+         * whence == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate
          * the cached file length
          */
-        if (origin != SEEK_SET && origin != SEEK_CUR) {
+        if (whence != SEEK_SET && whence != SEEK_CUR) {
                 int rc;
                 struct inode *inode = file->f_path.dentry->d_inode;
 
@@ -728,7 +728,7 @@ static loff_t cifs_llseek(struct file *file, loff_t offset, int origin)
                 if (rc < 0)
                         return (loff_t)rc;
         }
-        return generic_file_llseek(file, offset, origin);
+        return generic_file_llseek(file, offset, whence);
 }
 
 static int cifs_setlease(struct file *file, long arg, struct file_lock **lease)
diff --git a/fs/configfs/dir.c b/fs/configfs/dir.c
index 7414ae24a79b..712b10f64c70 100644
--- a/fs/configfs/dir.c
+++ b/fs/configfs/dir.c
@@ -1613,12 +1613,12 @@ static int configfs_readdir(struct file * filp, void * dirent, filldir_t filldir
         return 0;
 }
 
-static loff_t configfs_dir_lseek(struct file * file, loff_t offset, int origin)
+static loff_t configfs_dir_lseek(struct file *file, loff_t offset, int whence)
 {
         struct dentry * dentry = file->f_path.dentry;
 
         mutex_lock(&dentry->d_inode->i_mutex);
-        switch (origin) {
+        switch (whence) {
                 case 1:
                         offset += file->f_pos;
                 case 0:
diff --git a/fs/eventfd.c b/fs/eventfd.c
index d81b9f654086..35470d9b96e6 100644
--- a/fs/eventfd.c
+++ b/fs/eventfd.c
@@ -19,6 +19,8 @@
 #include <linux/export.h>
 #include <linux/kref.h>
 #include <linux/eventfd.h>
+#include <linux/proc_fs.h>
+#include <linux/seq_file.h>
 
 struct eventfd_ctx {
         struct kref kref;
@@ -284,7 +286,25 @@ static ssize_t eventfd_write(struct file *file, const char __user *buf, size_t c
         return res;
 }
 
+#ifdef CONFIG_PROC_FS
+static int eventfd_show_fdinfo(struct seq_file *m, struct file *f)
+{
+        struct eventfd_ctx *ctx = f->private_data;
+        int ret;
+
+        spin_lock_irq(&ctx->wqh.lock);
+        ret = seq_printf(m, "eventfd-count: %16llx\n",
+                         (unsigned long long)ctx->count);
+        spin_unlock_irq(&ctx->wqh.lock);
+
+        return ret;
+}
+#endif
+
 static const struct file_operations eventfd_fops = {
+#ifdef CONFIG_PROC_FS
+        .show_fdinfo    = eventfd_show_fdinfo,
+#endif
         .release        = eventfd_release,
         .poll           = eventfd_poll,
         .read           = eventfd_read,
diff --git a/fs/eventpoll.c b/fs/eventpoll.c
index cd96649bfe62..be56b21435f8 100644
--- a/fs/eventpoll.c
+++ b/fs/eventpoll.c
@@ -38,6 +38,8 @@
 #include <asm/io.h>
 #include <asm/mman.h>
 #include <linux/atomic.h>
+#include <linux/proc_fs.h>
+#include <linux/seq_file.h>
 
 /*
  * LOCKING:
@@ -783,8 +785,34 @@ static unsigned int ep_eventpoll_poll(struct file *file, poll_table *wait)
         return pollflags != -1 ? pollflags : 0;
 }
 
+#ifdef CONFIG_PROC_FS
+static int ep_show_fdinfo(struct seq_file *m, struct file *f)
+{
+        struct eventpoll *ep = f->private_data;
+        struct rb_node *rbp;
+        int ret = 0;
+
+        mutex_lock(&ep->mtx);
+        for (rbp = rb_first(&ep->rbr); rbp; rbp = rb_next(rbp)) {
+                struct epitem *epi = rb_entry(rbp, struct epitem, rbn);
+
+                ret = seq_printf(m, "tfd: %8d events: %8x data: %16llx\n",
+                                 epi->ffd.fd, epi->event.events,
+                                 (long long)epi->event.data);
+                if (ret)
+                        break;
+        }
+        mutex_unlock(&ep->mtx);
+
+        return ret;
+}
+#endif
+
 /* File callbacks that implement the eventpoll file behaviour */
 static const struct file_operations eventpoll_fops = {
+#ifdef CONFIG_PROC_FS
+        .show_fdinfo    = ep_show_fdinfo,
+#endif
         .release        = ep_eventpoll_release,
         .poll           = ep_eventpoll_poll,
         .llseek         = noop_llseek,
diff --git a/fs/exec.c b/fs/exec.c
index b71b08ce7120..d8e1191cb112 100644
--- a/fs/exec.c
+++ b/fs/exec.c
@@ -1353,6 +1353,10 @@ int search_binary_handler(struct linux_binprm *bprm)
         struct linux_binfmt *fmt;
         pid_t old_pid, old_vpid;
 
+        /* This allows 4 levels of binfmt rewrites before failing hard. */
+        if (depth > 5)
+                return -ELOOP;
+
         retval = security_bprm_check(bprm);
         if (retval)
                 return retval;
@@ -1377,12 +1381,8 @@ int search_binary_handler(struct linux_binprm *bprm)
                         if (!try_module_get(fmt->module))
                                 continue;
                         read_unlock(&binfmt_lock);
+                        bprm->recursion_depth = depth + 1;
                         retval = fn(bprm);
-                        /*
-                         * Restore the depth counter to its starting value
-                         * in this call, so we don't have to rely on every
-                         * load_binary function to restore it on return.
-                         */
                         bprm->recursion_depth = depth;
                         if (retval >= 0) {
                                 if (depth == 0) {
diff --git a/fs/exportfs/expfs.c b/fs/exportfs/expfs.c
index 29ab099e3e08..606bb074c501 100644
--- a/fs/exportfs/expfs.c
+++ b/fs/exportfs/expfs.c
@@ -341,10 +341,21 @@ static int export_encode_fh(struct inode *inode, struct fid *fid,
         return type;
 }
 
+int exportfs_encode_inode_fh(struct inode *inode, struct fid *fid,
+                             int *max_len, struct inode *parent)
+{
+        const struct export_operations *nop = inode->i_sb->s_export_op;
+
+        if (nop && nop->encode_fh)
+                return nop->encode_fh(inode, fid->raw, max_len, parent);
+
+        return export_encode_fh(inode, fid, max_len, parent);
+}
+EXPORT_SYMBOL_GPL(exportfs_encode_inode_fh);
+
 int exportfs_encode_fh(struct dentry *dentry, struct fid *fid, int *max_len,
                 int connectable)
 {
-        const struct export_operations *nop = dentry->d_sb->s_export_op;
         int error;
         struct dentry *p = NULL;
         struct inode *inode = dentry->d_inode, *parent = NULL;
@@ -357,10 +368,8 @@ int exportfs_encode_fh(struct dentry *dentry, struct fid *fid, int *max_len,
                  */
                 parent = p->d_inode;
         }
-        if (nop->encode_fh)
-                error = nop->encode_fh(inode, fid->raw, max_len, parent);
-        else
-                error = export_encode_fh(inode, fid, max_len, parent);
+
+        error = exportfs_encode_inode_fh(inode, fid, max_len, parent);
         dput(p);
 
         return error;
diff --git a/fs/ext3/dir.c b/fs/ext3/dir.c
index c8fff930790d..dd91264ba94f 100644
--- a/fs/ext3/dir.c
+++ b/fs/ext3/dir.c
@@ -296,17 +296,17 @@ static inline loff_t ext3_get_htree_eof(struct file *filp)
  * NOTE: offsets obtained *before* ext3_set_inode_flag(dir, EXT3_INODE_INDEX)
  *       will be invalid once the directory was converted into a dx directory
  */
-loff_t ext3_dir_llseek(struct file *file, loff_t offset, int origin)
+loff_t ext3_dir_llseek(struct file *file, loff_t offset, int whence)
 {
         struct inode *inode = file->f_mapping->host;
         int dx_dir = is_dx_dir(inode);
         loff_t htree_max = ext3_get_htree_eof(file);
 
         if (likely(dx_dir))
-                return generic_file_llseek_size(file, offset, origin,
+                return generic_file_llseek_size(file, offset, whence,
                                                 htree_max, htree_max);
         else
-                return generic_file_llseek(file, offset, origin);
+                return generic_file_llseek(file, offset, whence);
 }
 
 /*
diff --git a/fs/ext4/dir.c b/fs/ext4/dir.c
index b8d877f6c1fa..80a28b297279 100644
--- a/fs/ext4/dir.c
+++ b/fs/ext4/dir.c
@@ -333,17 +333,17 @@ static inline loff_t ext4_get_htree_eof(struct file *filp)
  *
  * For non-htree, ext4_llseek already chooses the proper max offset.
  */
-loff_t ext4_dir_llseek(struct file *file, loff_t offset, int origin)
+loff_t ext4_dir_llseek(struct file *file, loff_t offset, int whence)
 {
         struct inode *inode = file->f_mapping->host;
         int dx_dir = is_dx_dir(inode);
         loff_t htree_max = ext4_get_htree_eof(file);
 
         if (likely(dx_dir))
-                return generic_file_llseek_size(file, offset, origin,
+                return generic_file_llseek_size(file, offset, whence,
                                                     htree_max, htree_max);
         else
-                return ext4_llseek(file, offset, origin);
+                return ext4_llseek(file, offset, whence);
 }
 
 /*
diff --git a/fs/ext4/file.c b/fs/ext4/file.c
index b64a60bf105a..d07c27ca594a 100644
--- a/fs/ext4/file.c
+++ b/fs/ext4/file.c
@@ -303,7 +303,7 @@ static int ext4_file_open(struct inode * inode, struct file * filp)
  * page cache has data or not.
  */
 static int ext4_find_unwritten_pgoff(struct inode *inode,
-                                     int origin,
+                                     int whence,
                                      struct ext4_map_blocks *map,
                                      loff_t *offset)
 {
@@ -333,10 +333,10 @@ static int ext4_find_unwritten_pgoff(struct inode *inode,
                 nr_pages = pagevec_lookup(&pvec, inode->i_mapping, index,
                                           (pgoff_t)num);
                 if (nr_pages == 0) {
-                        if (origin == SEEK_DATA)
+                        if (whence == SEEK_DATA)
                                 break;
 
-                        BUG_ON(origin != SEEK_HOLE);
+                        BUG_ON(whence != SEEK_HOLE);
                         /*
                          * If this is the first time to go into the loop and
                          * offset is not beyond the end offset, it will be a
@@ -352,7 +352,7 @@ static int ext4_find_unwritten_pgoff(struct inode *inode,
                  * offset is smaller than the first page offset, it will be a
                  * hole at this offset.
                  */
-                if (lastoff == startoff && origin == SEEK_HOLE &&
+                if (lastoff == startoff && whence == SEEK_HOLE &&
                     lastoff < page_offset(pvec.pages[0])) {
                         found = 1;
                         break;
@@ -366,7 +366,7 @@ static int ext4_find_unwritten_pgoff(struct inode *inode,
                          * If the current offset is not beyond the end of given
                          * range, it will be a hole.
                          */
-                        if (lastoff < endoff && origin == SEEK_HOLE &&
+                        if (lastoff < endoff && whence == SEEK_HOLE &&
                             page->index > end) {
                                 found = 1;
                                 *offset = lastoff;
@@ -391,10 +391,10 @@ static int ext4_find_unwritten_pgoff(struct inode *inode,
                                 do {
                                         if (buffer_uptodate(bh) ||
                                             buffer_unwritten(bh)) {
-                                                if (origin == SEEK_DATA)
+                                                if (whence == SEEK_DATA)
                                                         found = 1;
                                         } else {
-                                                if (origin == SEEK_HOLE)
+                                                if (whence == SEEK_HOLE)
                                                         found = 1;
                                         }
                                         if (found) {
@@ -416,7 +416,7 @@ static int ext4_find_unwritten_pgoff(struct inode *inode,
                  * The no. of pages is less than our desired, that would be a
                  * hole in there.
                  */
-                if (nr_pages < num && origin == SEEK_HOLE) {
+                if (nr_pages < num && whence == SEEK_HOLE) {
                         found = 1;
                         *offset = lastoff;
                         break;
@@ -609,7 +609,7 @@ static loff_t ext4_seek_hole(struct file *file, loff_t offset, loff_t maxsize)
  * by calling generic_file_llseek_size() with the appropriate maxbytes
  * value for each.
  */
-loff_t ext4_llseek(struct file *file, loff_t offset, int origin)
+loff_t ext4_llseek(struct file *file, loff_t offset, int whence)
 {
         struct inode *inode = file->f_mapping->host;
         loff_t maxbytes;
@@ -619,11 +619,11 @@ loff_t ext4_llseek(struct file *file, loff_t offset, int origin)
         else
                 maxbytes = inode->i_sb->s_maxbytes;
 
-        switch (origin) {
+        switch (whence) {
         case SEEK_SET:
         case SEEK_CUR:
         case SEEK_END:
-                return generic_file_llseek_size(file, offset, origin,
+                return generic_file_llseek_size(file, offset, whence,
                                                 maxbytes, i_size_read(inode));
         case SEEK_DATA:
                 return ext4_seek_data(file, offset, maxbytes);
diff --git a/fs/fat/fat.h b/fs/fat/fat.h
index 623f36f0423b..12701a567752 100644
--- a/fs/fat/fat.h
+++ b/fs/fat/fat.h
@@ -29,6 +29,7 @@ struct fat_mount_options {
         unsigned short fs_fmask;
         unsigned short fs_dmask;
         unsigned short codepage;   /* Codepage for shortname conversions */
+        int time_offset;           /* Offset of timestamps from UTC (in minutes) */
         char *iocharset;           /* Charset used for filename input/display */
         unsigned short shortname;  /* flags for shortname display/create rule */
         unsigned char name_check;  /* r = relaxed, n = normal, s = strict */
@@ -45,7 +46,7 @@ struct fat_mount_options {
                  flush:1,          /* write things quickly */
                  nocase:1,         /* Does this need case conversion? 0=need case conversion*/
                  usefree:1,        /* Use free_clusters for FAT32 */
-                 tz_utc:1,         /* Filesystem timestamps are in UTC */
+                 tz_set:1,         /* Filesystem timestamps' offset set */
                  rodir:1,          /* allow ATTR_RO for directory */
                  discard:1,        /* Issue discard requests on deletions */
                  nfs:1;            /* Do extra work needed for NFS export */
diff --git a/fs/fat/inode.c b/fs/fat/inode.c
index 5bafaad00530..35806813ea4e 100644
--- a/fs/fat/inode.c
+++ b/fs/fat/inode.c
@@ -26,6 +26,7 @@
 #include <linux/writeback.h>
 #include <linux/log2.h>
 #include <linux/hash.h>
+#include <linux/blkdev.h>
 #include <asm/unaligned.h>
 #include "fat.h"
 
@@ -725,7 +726,8 @@ static int fat_show_options(struct seq_file *m, struct dentry *root)
         if (opts->allow_utime)
                 seq_printf(m, ",allow_utime=%04o", opts->allow_utime);
         if (sbi->nls_disk)
-                seq_printf(m, ",codepage=%s", sbi->nls_disk->charset);
+                /* strip "cp" prefix from displayed option */
+                seq_printf(m, ",codepage=%s", &sbi->nls_disk->charset[2]);
         if (isvfat) {
                 if (sbi->nls_io)
                         seq_printf(m, ",iocharset=%s", sbi->nls_io->charset);
@@ -777,8 +779,12 @@ static int fat_show_options(struct seq_file *m, struct dentry *root)
         }
         if (opts->flush)
                 seq_puts(m, ",flush");
-        if (opts->tz_utc)
-                seq_puts(m, ",tz=UTC");
+        if (opts->tz_set) {
+                if (opts->time_offset)
+                        seq_printf(m, ",time_offset=%d", opts->time_offset);
+                else
+                        seq_puts(m, ",tz=UTC");
+        }
         if (opts->errors == FAT_ERRORS_CONT)
                 seq_puts(m, ",errors=continue");
         else if (opts->errors == FAT_ERRORS_PANIC)
@@ -800,7 +806,8 @@ enum {
         Opt_shortname_winnt, Opt_shortname_mixed, Opt_utf8_no, Opt_utf8_yes,
         Opt_uni_xl_no, Opt_uni_xl_yes, Opt_nonumtail_no, Opt_nonumtail_yes,
         Opt_obsolete, Opt_flush, Opt_tz_utc, Opt_rodir, Opt_err_cont,
-        Opt_err_panic, Opt_err_ro, Opt_discard, Opt_nfs, Opt_err,
+        Opt_err_panic, Opt_err_ro, Opt_discard, Opt_nfs, Opt_time_offset,
+        Opt_err,
 };
 
 static const match_table_t fat_tokens = {
@@ -825,6 +832,7 @@ static const match_table_t fat_tokens = {
         {Opt_immutable, "sys_immutable"},
         {Opt_flush, "flush"},
         {Opt_tz_utc, "tz=UTC"},
+        {Opt_time_offset, "time_offset=%d"},
         {Opt_err_cont, "errors=continue"},
         {Opt_err_panic, "errors=panic"},
         {Opt_err_ro, "errors=remount-ro"},
@@ -909,7 +917,7 @@ static int parse_options(struct super_block *sb, char *options, int is_vfat,
         opts->utf8 = opts->unicode_xlate = 0;
         opts->numtail = 1;
         opts->usefree = opts->nocase = 0;
-        opts->tz_utc = 0;
+        opts->tz_set = 0;
         opts->nfs = 0;
         opts->errors = FAT_ERRORS_RO;
         *debug = 0;
@@ -965,48 +973,57 @@ static int parse_options(struct super_block *sb, char *options, int is_vfat,
                         break;
                 case Opt_uid:
                         if (match_int(&args[0], &option))
-                                return 0;
+                                return -EINVAL;
                         opts->fs_uid = make_kuid(current_user_ns(), option);
                         if (!uid_valid(opts->fs_uid))
-                                return 0;
+                                return -EINVAL;
                         break;
                 case Opt_gid:
                         if (match_int(&args[0], &option))
-                                return 0;
+                                return -EINVAL;
                         opts->fs_gid = make_kgid(current_user_ns(), option);
                         if (!gid_valid(opts->fs_gid))
-                                return 0;
+                                return -EINVAL;
                         break;
                 case Opt_umask:
                         if (match_octal(&args[0], &option))
-                                return 0;
+                                return -EINVAL;
                         opts->fs_fmask = opts->fs_dmask = option;
                         break;
                 case Opt_dmask:
                         if (match_octal(&args[0], &option))
-                                return 0;
+                                return -EINVAL;
                         opts->fs_dmask = option;
                         break;
                 case Opt_fmask:
                         if (match_octal(&args[0], &option))
-                                return 0;
+                                return -EINVAL;
                         opts->fs_fmask = option;
                         break;
                 case Opt_allow_utime:
                         if (match_octal(&args[0], &option))
-                                return 0;
+                                return -EINVAL;
                         opts->allow_utime = option & (S_IWGRP | S_IWOTH);
                         break;
                 case Opt_codepage:
                         if (match_int(&args[0], &option))
-                                return 0;
+                                return -EINVAL;
                         opts->codepage = option;
                         break;
                 case Opt_flush:
                         opts->flush = 1;
                         break;
+                case Opt_time_offset:
+                        if (match_int(&args[0], &option))
+                                return -EINVAL;
+                        if (option < -12 * 60 || option > 12 * 60)
+                                return -EINVAL;
+                        opts->tz_set = 1;
+                        opts->time_offset = option;
+                        break;
                 case Opt_tz_utc:
-                        opts->tz_utc = 1;
+                        opts->tz_set = 1;
+                        opts->time_offset = 0;
                         break;
                 case Opt_err_cont:
                         opts->errors = FAT_ERRORS_CONT;
@@ -1431,6 +1448,14 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, int isvfat,
                 goto out_fail;
         }
 
+        if (sbi->options.discard) {
+                struct request_queue *q = bdev_get_queue(sb->s_bdev);
+                if (!blk_queue_discard(q))
+                        fat_msg(sb, KERN_WARNING,
+                                        "mounting with \"discard\" option, but "
+                                        "the device does not support discard");
+        }
+
         return 0;
 
 out_invalid:
diff --git a/fs/fat/misc.c b/fs/fat/misc.c
index 6d93360ca0cc..5eb600dc43a9 100644
--- a/fs/fat/misc.c
+++ b/fs/fat/misc.c
@@ -212,8 +212,10 @@ void fat_time_fat2unix(struct msdos_sb_info *sbi, struct timespec *ts,
                    + days_in_year[month] + day
                    + DAYS_DELTA) * SECS_PER_DAY;
 
-        if (!sbi->options.tz_utc)
+        if (!sbi->options.tz_set)
                 second += sys_tz.tz_minuteswest * SECS_PER_MIN;
+        else
+                second -= sbi->options.time_offset * SECS_PER_MIN;
 
         if (time_cs) {
                 ts->tv_sec = second + (time_cs / 100);
@@ -229,8 +231,9 @@ void fat_time_unix2fat(struct msdos_sb_info *sbi, struct timespec *ts,
                        __le16 *time, __le16 *date, u8 *time_cs)
 {
         struct tm tm;
-        time_to_tm(ts->tv_sec, sbi->options.tz_utc ? 0 :
-                   -sys_tz.tz_minuteswest * 60, &tm);
+        time_to_tm(ts->tv_sec,
+                   (sbi->options.tz_set ? sbi->options.time_offset :
+                   -sys_tz.tz_minuteswest) * SECS_PER_MIN, &tm);
 
         /*  FAT can only support year between 1980 to 2107 */
         if (tm.tm_year < 1980 - 1900) {
diff --git a/fs/fuse/file.c b/fs/fuse/file.c
index 78d2837bc940..e21d4d8f87e3 100644
--- a/fs/fuse/file.c
+++ b/fs/fuse/file.c
@@ -1599,19 +1599,19 @@ static sector_t fuse_bmap(struct address_space *mapping, sector_t block)
         return err ? 0 : outarg.block;
 }
 
-static loff_t fuse_file_llseek(struct file *file, loff_t offset, int origin)
+static loff_t fuse_file_llseek(struct file *file, loff_t offset, int whence)
 {
         loff_t retval;
         struct inode *inode = file->f_path.dentry->d_inode;
 
         /* No i_mutex protection necessary for SEEK_CUR and SEEK_SET */
-        if (origin == SEEK_CUR || origin == SEEK_SET)
-                return generic_file_llseek(file, offset, origin);
+        if (whence == SEEK_CUR || whence == SEEK_SET)
+                return generic_file_llseek(file, offset, whence);
 
         mutex_lock(&inode->i_mutex);
         retval = fuse_update_attributes(inode, NULL, file, NULL);
         if (!retval)
-                retval = generic_file_llseek(file, offset, origin);
+                retval = generic_file_llseek(file, offset, whence);
         mutex_unlock(&inode->i_mutex);
 
         return retval;
diff --git a/fs/gfs2/file.c b/fs/gfs2/file.c
index dfe2d8cb9b2c..991ab2d484dd 100644
--- a/fs/gfs2/file.c
+++ b/fs/gfs2/file.c
@@ -44,7 +44,7 @@
  * gfs2_llseek - seek to a location in a file
  * @file: the file
  * @offset: the offset
- * @origin: Where to seek from (SEEK_SET, SEEK_CUR, or SEEK_END)
+ * @whence: Where to seek from (SEEK_SET, SEEK_CUR, or SEEK_END)
  *
  * SEEK_END requires the glock for the file because it references the
  * file's size.
@@ -52,26 +52,26 @@
  * Returns: The new offset, or errno
  */
 
-static loff_t gfs2_llseek(struct file *file, loff_t offset, int origin)
+static loff_t gfs2_llseek(struct file *file, loff_t offset, int whence)
 {
         struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
         struct gfs2_holder i_gh;
         loff_t error;
 
-        switch (origin) {
+        switch (whence) {
         case SEEK_END: /* These reference inode->i_size */
         case SEEK_DATA:
         case SEEK_HOLE:
                 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY,
                                            &i_gh);
                 if (!error) {
-                        error = generic_file_llseek(file, offset, origin);
+                        error = generic_file_llseek(file, offset, whence);
                         gfs2_glock_dq_uninit(&i_gh);
                 }
                 break;
         case SEEK_CUR:
         case SEEK_SET:
-                error = generic_file_llseek(file, offset, origin);
+                error = generic_file_llseek(file, offset, whence);
                 break;
         default:
                 error = -EINVAL;
diff --git a/fs/libfs.c b/fs/libfs.c
index 7cc37ca19cd8..35fc6e74cd88 100644
--- a/fs/libfs.c
+++ b/fs/libfs.c
@@ -81,11 +81,11 @@ int dcache_dir_close(struct inode *inode, struct file *file)
         return 0;
 }
 
-loff_t dcache_dir_lseek(struct file *file, loff_t offset, int origin)
+loff_t dcache_dir_lseek(struct file *file, loff_t offset, int whence)
 {
         struct dentry *dentry = file->f_path.dentry;
         mutex_lock(&dentry->d_inode->i_mutex);
-        switch (origin) {
+        switch (whence) {
                 case 1:
                         offset += file->f_pos;
                 case 0:
diff --git a/fs/nfs/dir.c b/fs/nfs/dir.c
index b9e66b7e0c14..1cc71f60b491 100644
--- a/fs/nfs/dir.c
+++ b/fs/nfs/dir.c
@@ -871,7 +871,7 @@ out:
         return res;
 }
 
-static loff_t nfs_llseek_dir(struct file *filp, loff_t offset, int origin)
+static loff_t nfs_llseek_dir(struct file *filp, loff_t offset, int whence)
 {
         struct dentry *dentry = filp->f_path.dentry;
         struct inode *inode = dentry->d_inode;
@@ -880,10 +880,10 @@ static loff_t nfs_llseek_dir(struct file *filp, loff_t offset, int origin)
         dfprintk(FILE, "NFS: llseek dir(%s/%s, %lld, %d)\n",
                         dentry->d_parent->d_name.name,
                         dentry->d_name.name,
-                        offset, origin);
+                        offset, whence);
 
         mutex_lock(&inode->i_mutex);
-        switch (origin) {
+        switch (whence) {
                 case 1:
                         offset += filp->f_pos;
                 case 0:
diff --git a/fs/nfs/file.c b/fs/nfs/file.c
index 582bb8866131..3c2b893665ba 100644
--- a/fs/nfs/file.c
+++ b/fs/nfs/file.c
@@ -119,18 +119,18 @@ force_reval:
         return __nfs_revalidate_inode(server, inode);
 }
 
-loff_t nfs_file_llseek(struct file *filp, loff_t offset, int origin)
+loff_t nfs_file_llseek(struct file *filp, loff_t offset, int whence)
 {
         dprintk("NFS: llseek file(%s/%s, %lld, %d)\n",
                         filp->f_path.dentry->d_parent->d_name.name,
                         filp->f_path.dentry->d_name.name,
-                        offset, origin);
+                        offset, whence);
 
         /*
-         * origin == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate
+         * whence == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate
          * the cached file length
          */
-        if (origin != SEEK_SET && origin != SEEK_CUR) {
+        if (whence != SEEK_SET && whence != SEEK_CUR) {
                 struct inode *inode = filp->f_mapping->host;
 
                 int retval = nfs_revalidate_file_size(inode, filp);
@@ -138,7 +138,7 @@ loff_t nfs_file_llseek(struct file *filp, loff_t offset, int origin)
                         return (loff_t)retval;
         }
 
-        return generic_file_llseek(filp, offset, origin);
+        return generic_file_llseek(filp, offset, whence);
 }
 EXPORT_SYMBOL_GPL(nfs_file_llseek);
 
diff --git a/fs/notify/Makefile b/fs/notify/Makefile
index ae5f33a6d868..96d3420d0242 100644
--- a/fs/notify/Makefile
+++ b/fs/notify/Makefile
@@ -1,5 +1,5 @@
 obj-$(CONFIG_FSNOTIFY)          += fsnotify.o notification.o group.o inode_mark.o \
-                                   mark.o vfsmount_mark.o
+                                   mark.o vfsmount_mark.o fdinfo.o
 
 obj-y                   += dnotify/
 obj-y                   += inotify/
diff --git a/fs/notify/fanotify/fanotify_user.c b/fs/notify/fanotify/fanotify_user.c
index 6fcaeb8c902e..a5cd9bba022f 100644
--- a/fs/notify/fanotify/fanotify_user.c
+++ b/fs/notify/fanotify/fanotify_user.c
@@ -17,6 +17,7 @@
 #include <asm/ioctls.h>
 
 #include "../../mount.h"
+#include "../fdinfo.h"
 
 #define FANOTIFY_DEFAULT_MAX_EVENTS     16384
 #define FANOTIFY_DEFAULT_MAX_MARKS      8192
@@ -428,6 +429,7 @@ static long fanotify_ioctl(struct file *file, unsigned int cmd, unsigned long ar
 }
 
 static const struct file_operations fanotify_fops = {
+        .show_fdinfo    = fanotify_show_fdinfo,
         .poll           = fanotify_poll,
         .read           = fanotify_read,
         .write          = fanotify_write,
diff --git a/fs/notify/fdinfo.c b/fs/notify/fdinfo.c
new file mode 100644
index 000000000000..514c4b81483d
--- /dev/null
+++ b/fs/notify/fdinfo.c
@@ -0,0 +1,179 @@
+#include <linux/file.h>
+#include <linux/fs.h>
+#include <linux/fsnotify_backend.h>
+#include <linux/idr.h>
+#include <linux/init.h>
+#include <linux/inotify.h>
+#include <linux/fanotify.h>
+#include <linux/kernel.h>
+#include <linux/namei.h>
+#include <linux/sched.h>
+#include <linux/types.h>
+#include <linux/seq_file.h>
+#include <linux/proc_fs.h>
+#include <linux/exportfs.h>
+
+#include "inotify/inotify.h"
+#include "../fs/mount.h"
+
+#if defined(CONFIG_PROC_FS)
+
+#if defined(CONFIG_INOTIFY_USER) || defined(CONFIG_FANOTIFY)
+
+static int show_fdinfo(struct seq_file *m, struct file *f,
+                       int (*show)(struct seq_file *m, struct fsnotify_mark *mark))
+{
+        struct fsnotify_group *group = f->private_data;
+        struct fsnotify_mark *mark;
+        int ret = 0;
+
+        spin_lock(&group->mark_lock);
+        list_for_each_entry(mark, &group->marks_list, g_list) {
+                ret = show(m, mark);
+                if (ret)
+                        break;
+        }
+        spin_unlock(&group->mark_lock);
+        return ret;
+}
+
+#if defined(CONFIG_EXPORTFS)
+static int show_mark_fhandle(struct seq_file *m, struct inode *inode)
+{
+        struct {
+                struct file_handle handle;
+                u8 pad[64];
+        } f;
+        int size, ret, i;
+
+        f.handle.handle_bytes = sizeof(f.pad);
+        size = f.handle.handle_bytes >> 2;
+
+        ret = exportfs_encode_inode_fh(inode, (struct fid *)f.handle.f_handle, &size, 0);
+        if ((ret == 255) || (ret == -ENOSPC)) {
+                WARN_ONCE(1, "Can't encode file handler for inotify: %d\n", ret);
+                return 0;
+        }
+
+        f.handle.handle_type = ret;
+        f.handle.handle_bytes = size * sizeof(u32);
+
+        ret = seq_printf(m, "fhandle-bytes:%x fhandle-type:%x f_handle:",
+                         f.handle.handle_bytes, f.handle.handle_type);
+
+        for (i = 0; i < f.handle.handle_bytes; i++)
+                ret |= seq_printf(m, "%02x", (int)f.handle.f_handle[i]);
+
+        return ret;
+}
+#else
+static int show_mark_fhandle(struct seq_file *m, struct inode *inode)
+{
+        return 0;
+}
+#endif
+
+#ifdef CONFIG_INOTIFY_USER
+
+static int inotify_fdinfo(struct seq_file *m, struct fsnotify_mark *mark)
+{
+        struct inotify_inode_mark *inode_mark;
+        struct inode *inode;
+        int ret = 0;
+
+        if (!(mark->flags & (FSNOTIFY_MARK_FLAG_ALIVE | FSNOTIFY_MARK_FLAG_INODE)))
+                return 0;
+
+        inode_mark = container_of(mark, struct inotify_inode_mark, fsn_mark);
+        inode = igrab(mark->i.inode);
+        if (inode) {
+                ret = seq_printf(m, "inotify wd:%x ino:%lx sdev:%x "
+                                 "mask:%x ignored_mask:%x ",
+                                 inode_mark->wd, inode->i_ino,
+                                 inode->i_sb->s_dev,
+                                 mark->mask, mark->ignored_mask);
+                ret |= show_mark_fhandle(m, inode);
+                ret |= seq_putc(m, '\n');
+                iput(inode);
+        }
+
+        return ret;
+}
+
+int inotify_show_fdinfo(struct seq_file *m, struct file *f)
+{
+        return show_fdinfo(m, f, inotify_fdinfo);
+}
+
+#endif /* CONFIG_INOTIFY_USER */
+
+#ifdef CONFIG_FANOTIFY
+
+static int fanotify_fdinfo(struct seq_file *m, struct fsnotify_mark *mark)
+{
+        unsigned int mflags = 0;
+        struct inode *inode;
+        int ret = 0;
+
+        if (!(mark->flags & FSNOTIFY_MARK_FLAG_ALIVE))
+                return 0;
+
+        if (mark->flags & FSNOTIFY_MARK_FLAG_IGNORED_SURV_MODIFY)
+                mflags |= FAN_MARK_IGNORED_SURV_MODIFY;
+
+        if (mark->flags & FSNOTIFY_MARK_FLAG_INODE) {
+                inode = igrab(mark->i.inode);
+                if (!inode)
+                        goto out;
+                ret = seq_printf(m, "fanotify ino:%lx sdev:%x "
+                                 "mflags:%x mask:%x ignored_mask:%x ",
+                                 inode->i_ino, inode->i_sb->s_dev,
+                                 mflags, mark->mask, mark->ignored_mask);
+                ret |= show_mark_fhandle(m, inode);
+                ret |= seq_putc(m, '\n');
+                iput(inode);
+        } else if (mark->flags & FSNOTIFY_MARK_FLAG_VFSMOUNT) {
+                struct mount *mnt = real_mount(mark->m.mnt);
+
+                ret = seq_printf(m, "fanotify mnt_id:%x mflags:%x mask:%x "
+                                 "ignored_mask:%x\n", mnt->mnt_id, mflags,
+                                 mark->mask, mark->ignored_mask);
+        }
+out:
+        return ret;
+}
+
+int fanotify_show_fdinfo(struct seq_file *m, struct file *f)
+{
+        struct fsnotify_group *group = f->private_data;
+        unsigned int flags = 0;
+
+        switch (group->priority) {
+        case FS_PRIO_0:
+                flags |= FAN_CLASS_NOTIF;
+                break;
+        case FS_PRIO_1:
+                flags |= FAN_CLASS_CONTENT;
+                break;
+        case FS_PRIO_2:
+                flags |= FAN_CLASS_PRE_CONTENT;
+                break;
+        }
+
+        if (group->max_events == UINT_MAX)
+                flags |= FAN_UNLIMITED_QUEUE;
+
+        if (group->fanotify_data.max_marks == UINT_MAX)
+                flags |= FAN_UNLIMITED_MARKS;
+
+        seq_printf(m, "fanotify flags:%x event-flags:%x\n",
+                   flags, group->fanotify_data.f_flags);
+
+        return show_fdinfo(m, f, fanotify_fdinfo);
+}
+
+#endif /* CONFIG_FANOTIFY */
+
+#endif /* CONFIG_INOTIFY_USER || CONFIG_FANOTIFY */
+
+#endif /* CONFIG_PROC_FS */
diff --git a/fs/notify/fdinfo.h b/fs/notify/fdinfo.h
new file mode 100644
index 000000000000..556afda990e9
--- /dev/null
+++ b/fs/notify/fdinfo.h
@@ -0,0 +1,27 @@
+#ifndef __FSNOTIFY_FDINFO_H__
+#define __FSNOTIFY_FDINFO_H__
+
+#include <linux/errno.h>
+#include <linux/proc_fs.h>
+
+struct seq_file;
+struct file;
+
+#ifdef CONFIG_PROC_FS
+
+#ifdef CONFIG_INOTIFY_USER
+extern int inotify_show_fdinfo(struct seq_file *m, struct file *f);
+#endif
+
+#ifdef CONFIG_FANOTIFY
+extern int fanotify_show_fdinfo(struct seq_file *m, struct file *f);
+#endif
+
+#else /* CONFIG_PROC_FS */
+
+#define inotify_show_fdinfo     NULL
+#define fanotify_show_fdinfo    NULL
+
+#endif /* CONFIG_PROC_FS */
+
+#endif /* __FSNOTIFY_FDINFO_H__ */
diff --git a/fs/notify/inode_mark.c b/fs/notify/inode_mark.c
index b13c00ac48eb..f3035691f528 100644
--- a/fs/notify/inode_mark.c
+++ b/fs/notify/inode_mark.c
@@ -116,8 +116,9 @@ void fsnotify_clear_inode_marks_by_group(struct fsnotify_group *group)
  * given a group and inode, find the mark associated with that combination.
  * if found take a reference to that mark and return it, else return NULL
  */
-struct fsnotify_mark *fsnotify_find_inode_mark_locked(struct fsnotify_group *group,
-                                                      struct inode *inode)
+static struct fsnotify_mark *fsnotify_find_inode_mark_locked(
+                struct fsnotify_group *group,
+                struct inode *inode)
 {
         struct fsnotify_mark *mark;
         struct hlist_node *pos;
diff --git a/fs/notify/inotify/inotify_user.c b/fs/notify/inotify/inotify_user.c
index c311dda054a3..36cb013c7c13 100644
--- a/fs/notify/inotify/inotify_user.c
+++ b/fs/notify/inotify/inotify_user.c
@@ -40,6 +40,7 @@
 #include <linux/wait.h>
 
 #include "inotify.h"
+#include "../fdinfo.h"
 
 #include <asm/ioctls.h>
 
@@ -335,6 +336,7 @@ static long inotify_ioctl(struct file *file, unsigned int cmd,
 }
 
 static const struct file_operations inotify_fops = {
+        .show_fdinfo    = inotify_show_fdinfo,
         .poll           = inotify_poll,
         .read           = inotify_read,
         .fasync         = inotify_fasync,
diff --git a/fs/ocfs2/extent_map.c b/fs/ocfs2/extent_map.c
index 70b5863a2d64..f487aa343442 100644
--- a/fs/ocfs2/extent_map.c
+++ b/fs/ocfs2/extent_map.c
@@ -832,7 +832,7 @@ out:
         return ret;
 }
 
-int ocfs2_seek_data_hole_offset(struct file *file, loff_t *offset, int origin)
+int ocfs2_seek_data_hole_offset(struct file *file, loff_t *offset, int whence)
 {
         struct inode *inode = file->f_mapping->host;
         int ret;
@@ -843,7 +843,7 @@ int ocfs2_seek_data_hole_offset(struct file *file, loff_t *offset, int origin)
         struct buffer_head *di_bh = NULL;
         struct ocfs2_extent_rec rec;
 
-        BUG_ON(origin != SEEK_DATA && origin != SEEK_HOLE);
+        BUG_ON(whence != SEEK_DATA && whence != SEEK_HOLE);
 
         ret = ocfs2_inode_lock(inode, &di_bh, 0);
         if (ret) {
@@ -859,7 +859,7 @@ int ocfs2_seek_data_hole_offset(struct file *file, loff_t *offset, int origin)
         }
 
         if (OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL) {
-                if (origin == SEEK_HOLE)
+                if (whence == SEEK_HOLE)
                         *offset = inode->i_size;
                 goto out_unlock;
         }
@@ -888,8 +888,8 @@ int ocfs2_seek_data_hole_offset(struct file *file, loff_t *offset, int origin)
                         is_data = (rec.e_flags & OCFS2_EXT_UNWRITTEN) ?  0 : 1;
                 }
 
-                if ((!is_data && origin == SEEK_HOLE) ||
-                    (is_data && origin == SEEK_DATA)) {
+                if ((!is_data && whence == SEEK_HOLE) ||
+                    (is_data && whence == SEEK_DATA)) {
                         if (extoff > *offset)
                                 *offset = extoff;
                         goto out_unlock;
@@ -899,7 +899,7 @@ int ocfs2_seek_data_hole_offset(struct file *file, loff_t *offset, int origin)
                         cpos += clen;
         }
 
-        if (origin == SEEK_HOLE) {
+        if (whence == SEEK_HOLE) {
                 extoff = cpos;
                 extoff <<= cs_bits;
                 extlen = clen;
diff --git a/fs/ocfs2/file.c b/fs/ocfs2/file.c
index dda089804942..fe492e1a3cfc 100644
--- a/fs/ocfs2/file.c
+++ b/fs/ocfs2/file.c
@@ -2637,14 +2637,14 @@ bail:
 }
 
 /* Refer generic_file_llseek_unlocked() */
-static loff_t ocfs2_file_llseek(struct file *file, loff_t offset, int origin)
+static loff_t ocfs2_file_llseek(struct file *file, loff_t offset, int whence)
 {
         struct inode *inode = file->f_mapping->host;
         int ret = 0;
 
         mutex_lock(&inode->i_mutex);
 
-        switch (origin) {
+        switch (whence) {
         case SEEK_SET:
                 break;
         case SEEK_END:
@@ -2659,7 +2659,7 @@ static loff_t ocfs2_file_llseek(struct file *file, loff_t offset, int origin)
                 break;
         case SEEK_DATA:
         case SEEK_HOLE:
-                ret = ocfs2_seek_data_hole_offset(file, &offset, origin);
+                ret = ocfs2_seek_data_hole_offset(file, &offset, whence);
                 if (ret)
                         goto out;
                 break;
diff --git a/fs/proc/array.c b/fs/proc/array.c
index d66248a1919b..6a91e6ffbcbd 100644
--- a/fs/proc/array.c
+++ b/fs/proc/array.c
@@ -212,7 +212,7 @@ static inline void task_state(struct seq_file *m, struct pid_namespace *ns,
         group_info = cred->group_info;
         task_unlock(p);
 
-        for (g = 0; g < min(group_info->ngroups, NGROUPS_SMALL); g++)
+        for (g = 0; g < group_info->ngroups; g++)
                 seq_printf(m, "%d ",
                            from_kgid_munged(user_ns, GROUP_AT(group_info, g)));
         put_cred(cred);
@@ -220,7 +220,7 @@ static inline void task_state(struct seq_file *m, struct pid_namespace *ns,
         seq_putc(m, '\n');
 }
 
-static void render_sigset_t(struct seq_file *m, const char *header,
+void render_sigset_t(struct seq_file *m, const char *header,
                                 sigset_t *set)
 {
         int i;
@@ -308,6 +308,10 @@ static void render_cap_t(struct seq_file *m, const char *header,
         seq_putc(m, '\n');
 }
 
+/* Remove non-existent capabilities */
+#define NORM_CAPS(v) (v.cap[CAP_TO_INDEX(CAP_LAST_CAP)] &= \
+                                CAP_TO_MASK(CAP_LAST_CAP + 1) - 1)
+
 static inline void task_cap(struct seq_file *m, struct task_struct *p)
 {
         const struct cred *cred;
@@ -321,12 +325,24 @@ static inline void task_cap(struct seq_file *m, struct task_struct *p)
         cap_bset        = cred->cap_bset;
         rcu_read_unlock();
 
+        NORM_CAPS(cap_inheritable);
+        NORM_CAPS(cap_permitted);
+        NORM_CAPS(cap_effective);
+        NORM_CAPS(cap_bset);
+
         render_cap_t(m, "CapInh:\t", &cap_inheritable);
         render_cap_t(m, "CapPrm:\t", &cap_permitted);
         render_cap_t(m, "CapEff:\t", &cap_effective);
         render_cap_t(m, "CapBnd:\t", &cap_bset);
 }
 
+static inline void task_seccomp(struct seq_file *m, struct task_struct *p)
+{
+#ifdef CONFIG_SECCOMP
+        seq_printf(m, "Seccomp:\t%d\n", p->seccomp.mode);
+#endif
+}
+
 static inline void task_context_switch_counts(struct seq_file *m,
                                                 struct task_struct *p)
 {
@@ -360,6 +376,7 @@ int proc_pid_status(struct seq_file *m, struct pid_namespace *ns,
         }
         task_sig(m, task);
         task_cap(m, task);
+        task_seccomp(m, task);
         task_cpus_allowed(m, task);
         cpuset_task_status_allowed(m, task);
         task_context_switch_counts(m, task);
diff --git a/fs/proc/fd.c b/fs/proc/fd.c
index f28a875f8779..d7a4a28ef630 100644
--- a/fs/proc/fd.c
+++ b/fs/proc/fd.c
@@ -50,6 +50,8 @@ static int seq_show(struct seq_file *m, void *v)
         if (!ret) {
                 seq_printf(m, "pos:\t%lli\nflags:\t0%o\n",
                            (long long)file->f_pos, f_flags);
+                if (file->f_op->show_fdinfo)
+                        ret = file->f_op->show_fdinfo(m, file);
                 fput(file);
         }
 
diff --git a/fs/proc/proc_devtree.c b/fs/proc/proc_devtree.c
index df7dd08d4391..de20ec480fa0 100644
--- a/fs/proc/proc_devtree.c
+++ b/fs/proc/proc_devtree.c
@@ -195,11 +195,7 @@ void proc_device_tree_add_node(struct device_node *np,
         set_node_proc_entry(np, de);
         for (child = NULL; (child = of_get_next_child(np, child));) {
                 /* Use everything after the last slash, or the full name */
-                p = strrchr(child->full_name, '/');
-                if (!p)
-                        p = child->full_name;
-                else
-                        ++p;
+                p = kbasename(child->full_name);
 
                 if (duplicate_name(de, p))
                         p = fixup_name(np, de, p);
diff --git a/fs/proc/task_mmu.c b/fs/proc/task_mmu.c
index 48775628abbf..448455b7fd91 100644
--- a/fs/proc/task_mmu.c
+++ b/fs/proc/task_mmu.c
@@ -526,6 +526,57 @@ static int smaps_pte_range(pmd_t *pmd, unsigned long addr, unsigned long end,
         return 0;
 }
 
+static void show_smap_vma_flags(struct seq_file *m, struct vm_area_struct *vma)
+{
+        /*
+         * Don't forget to update Documentation/ on changes.
+         */
+        static const char mnemonics[BITS_PER_LONG][2] = {
+                /*
+                 * In case if we meet a flag we don't know about.
+                 */
+                [0 ... (BITS_PER_LONG-1)] = "??",
+
+                [ilog2(VM_READ)]        = "rd",
+                [ilog2(VM_WRITE)]       = "wr",
+                [ilog2(VM_EXEC)]        = "ex",
+                [ilog2(VM_SHARED)]      = "sh",
+                [ilog2(VM_MAYREAD)]     = "mr",
+                [ilog2(VM_MAYWRITE)]    = "mw",
+                [ilog2(VM_MAYEXEC)]     = "me",
+                [ilog2(VM_MAYSHARE)]    = "ms",
+                [ilog2(VM_GROWSDOWN)]   = "gd",
+                [ilog2(VM_PFNMAP)]      = "pf",
+                [ilog2(VM_DENYWRITE)]   = "dw",
+                [ilog2(VM_LOCKED)]      = "lo",
+                [ilog2(VM_IO)]          = "io",
+                [ilog2(VM_SEQ_READ)]    = "sr",
+                [ilog2(VM_RAND_READ)]   = "rr",
+                [ilog2(VM_DONTCOPY)]    = "dc",
+                [ilog2(VM_DONTEXPAND)]  = "de",
+                [ilog2(VM_ACCOUNT)]     = "ac",
+                [ilog2(VM_NORESERVE)]   = "nr",
+                [ilog2(VM_HUGETLB)]     = "ht",
+                [ilog2(VM_NONLINEAR)]   = "nl",
+                [ilog2(VM_ARCH_1)]      = "ar",
+                [ilog2(VM_DONTDUMP)]    = "dd",
+                [ilog2(VM_MIXEDMAP)]    = "mm",
+                [ilog2(VM_HUGEPAGE)]    = "hg",
+                [ilog2(VM_NOHUGEPAGE)]  = "nh",
+                [ilog2(VM_MERGEABLE)]   = "mg",
+        };
+        size_t i;
+
+        seq_puts(m, "VmFlags: ");
+        for (i = 0; i < BITS_PER_LONG; i++) {
+                if (vma->vm_flags & (1UL << i)) {
+                        seq_printf(m, "%c%c ",
+                                   mnemonics[i][0], mnemonics[i][1]);
+                }
+        }
+        seq_putc(m, '\n');
+}
+
 static int show_smap(struct seq_file *m, void *v, int is_pid)
 {
         struct proc_maps_private *priv = m->private;
@@ -581,6 +632,8 @@ static int show_smap(struct seq_file *m, void *v, int is_pid)
                 seq_printf(m, "Nonlinear:      %8lu kB\n",
                                 mss.nonlinear >> 10);
 
+        show_smap_vma_flags(m, vma);
+
         if (m->count < m->size)  /* vma is copied successfully */
                 m->version = (vma != get_gate_vma(task->mm))
                         ? vma->vm_start : 0;
diff --git a/fs/pstore/inode.c b/fs/pstore/inode.c
index ed1d8c7212da..67de74ca85f4 100644
--- a/fs/pstore/inode.c
+++ b/fs/pstore/inode.c
@@ -151,13 +151,13 @@ static int pstore_file_open(struct inode *inode, struct file *file)
         return 0;
 }
 
-static loff_t pstore_file_llseek(struct file *file, loff_t off, int origin)
+static loff_t pstore_file_llseek(struct file *file, loff_t off, int whence)
 {
         struct seq_file *sf = file->private_data;
 
         if (sf->op)
-                return seq_lseek(file, off, origin);
-        return default_llseek(file, off, origin);
+                return seq_lseek(file, off, whence);
+        return default_llseek(file, off, whence);
 }
 
 static const struct file_operations pstore_file_operations = {
diff --git a/fs/read_write.c b/fs/read_write.c
index d06534857e9e..1edaf099ddd7 100644
--- a/fs/read_write.c
+++ b/fs/read_write.c
@@ -54,7 +54,7 @@ static loff_t lseek_execute(struct file *file, struct inode *inode,
  * generic_file_llseek_size - generic llseek implementation for regular files
  * @file:       file structure to seek on
  * @offset:     file offset to seek to
- * @origin:     type of seek
+ * @whence:     type of seek
  * @size:       max size of this file in file system
  * @eof:        offset used for SEEK_END position
  *
@@ -67,12 +67,12 @@ static loff_t lseek_execute(struct file *file, struct inode *inode,
  * read/writes behave like SEEK_SET against seeks.
  */
 loff_t
-generic_file_llseek_size(struct file *file, loff_t offset, int origin,
+generic_file_llseek_size(struct file *file, loff_t offset, int whence,
                 loff_t maxsize, loff_t eof)
 {
         struct inode *inode = file->f_mapping->host;
 
-        switch (origin) {
+        switch (whence) {
         case SEEK_END:
                 offset += eof;
                 break;
@@ -122,17 +122,17 @@ EXPORT_SYMBOL(generic_file_llseek_size);
  * generic_file_llseek - generic llseek implementation for regular files
  * @file:       file structure to seek on
  * @offset:     file offset to seek to
- * @origin:     type of seek
+ * @whence:     type of seek
  *
  * This is a generic implemenation of ->llseek useable for all normal local
  * filesystems.  It just updates the file offset to the value specified by
- * @offset and @origin under i_mutex.
+ * @offset and @whence under i_mutex.
  */
-loff_t generic_file_llseek(struct file *file, loff_t offset, int origin)
+loff_t generic_file_llseek(struct file *file, loff_t offset, int whence)
 {
         struct inode *inode = file->f_mapping->host;
 
-        return generic_file_llseek_size(file, offset, origin,
+        return generic_file_llseek_size(file, offset, whence,
                                         inode->i_sb->s_maxbytes,
                                         i_size_read(inode));
 }
@@ -142,32 +142,32 @@ EXPORT_SYMBOL(generic_file_llseek);
  * noop_llseek - No Operation Performed llseek implementation
  * @file:       file structure to seek on
  * @offset:     file offset to seek to
- * @origin:     type of seek
+ * @whence:     type of seek
  *
  * This is an implementation of ->llseek useable for the rare special case when
  * userspace expects the seek to succeed but the (device) file is actually not
  * able to perform the seek. In this case you use noop_llseek() instead of
  * falling back to the default implementation of ->llseek.
  */
-loff_t noop_llseek(struct file *file, loff_t offset, int origin)
+loff_t noop_llseek(struct file *file, loff_t offset, int whence)
 {
         return file->f_pos;
 }
 EXPORT_SYMBOL(noop_llseek);
 
-loff_t no_llseek(struct file *file, loff_t offset, int origin)
+loff_t no_llseek(struct file *file, loff_t offset, int whence)
 {
         return -ESPIPE;
 }
 EXPORT_SYMBOL(no_llseek);
 
-loff_t default_llseek(struct file *file, loff_t offset, int origin)
+loff_t default_llseek(struct file *file, loff_t offset, int whence)
 {
         struct inode *inode = file->f_path.dentry->d_inode;
         loff_t retval;
 
         mutex_lock(&inode->i_mutex);
-        switch (origin) {
+        switch (whence) {
                 case SEEK_END:
                         offset += i_size_read(inode);
                         break;
@@ -216,7 +216,7 @@ out:
 }
 EXPORT_SYMBOL(default_llseek);
 
-loff_t vfs_llseek(struct file *file, loff_t offset, int origin)
+loff_t vfs_llseek(struct file *file, loff_t offset, int whence)
 {
         loff_t (*fn)(struct file *, loff_t, int);
 
@@ -225,11 +225,11 @@ loff_t vfs_llseek(struct file *file, loff_t offset, int origin)
                 if (file->f_op && file->f_op->llseek)
                         fn = file->f_op->llseek;
         }
-        return fn(file, offset, origin);
+        return fn(file, offset, whence);
 }
 EXPORT_SYMBOL(vfs_llseek);
 
-SYSCALL_DEFINE3(lseek, unsigned int, fd, off_t, offset, unsigned int, origin)
+SYSCALL_DEFINE3(lseek, unsigned int, fd, off_t, offset, unsigned int, whence)
 {
         off_t retval;
         struct fd f = fdget(fd);
@@ -237,8 +237,8 @@ SYSCALL_DEFINE3(lseek, unsigned int, fd, off_t, offset, unsigned int, origin)
                 return -EBADF;
 
         retval = -EINVAL;
-        if (origin <= SEEK_MAX) {
-                loff_t res = vfs_llseek(f.file, offset, origin);
+        if (whence <= SEEK_MAX) {
+                loff_t res = vfs_llseek(f.file, offset, whence);
                 retval = res;
                 if (res != (loff_t)retval)
                         retval = -EOVERFLOW;    /* LFS: should only happen on 32 bit platforms */
@@ -250,7 +250,7 @@ SYSCALL_DEFINE3(lseek, unsigned int, fd, off_t, offset, unsigned int, origin)
 #ifdef __ARCH_WANT_SYS_LLSEEK
 SYSCALL_DEFINE5(llseek, unsigned int, fd, unsigned long, offset_high,
                 unsigned long, offset_low, loff_t __user *, result,
-                unsigned int, origin)
+                unsigned int, whence)
 {
         int retval;
         struct fd f = fdget(fd);
@@ -260,11 +260,11 @@ SYSCALL_DEFINE5(llseek, unsigned int, fd, unsigned long, offset_high,
                 return -EBADF;
 
         retval = -EINVAL;
-        if (origin > SEEK_MAX)
+        if (whence > SEEK_MAX)
                 goto out_putf;
 
         offset = vfs_llseek(f.file, ((loff_t) offset_high << 32) | offset_low,
-                        origin);
+                        whence);
 
         retval = (int)offset;
         if (offset >= 0) {
diff --git a/fs/seq_file.c b/fs/seq_file.c
index 99dffab4c4e4..9d863fb501f9 100644
--- a/fs/seq_file.c
+++ b/fs/seq_file.c
@@ -300,14 +300,14 @@ EXPORT_SYMBOL(seq_read);
  *
  *      Ready-made ->f_op->llseek()
  */
-loff_t seq_lseek(struct file *file, loff_t offset, int origin)
+loff_t seq_lseek(struct file *file, loff_t offset, int whence)
 {
         struct seq_file *m = file->private_data;
         loff_t retval = -EINVAL;
 
         mutex_lock(&m->lock);
         m->version = file->f_version;
-        switch (origin) {
+        switch (whence) {
                 case 1:
                         offset += file->f_pos;
                 case 0:
diff --git a/fs/signalfd.c b/fs/signalfd.c
index 8bee4e570911..b53486961735 100644
--- a/fs/signalfd.c
+++ b/fs/signalfd.c
@@ -29,6 +29,7 @@
 #include <linux/anon_inodes.h>
 #include <linux/signalfd.h>
 #include <linux/syscalls.h>
+#include <linux/proc_fs.h>
 
 void signalfd_cleanup(struct sighand_struct *sighand)
 {
@@ -227,7 +228,24 @@ static ssize_t signalfd_read(struct file *file, char __user *buf, size_t count,
         return total ? total: ret;
 }
 
+#ifdef CONFIG_PROC_FS
+static int signalfd_show_fdinfo(struct seq_file *m, struct file *f)
+{
+        struct signalfd_ctx *ctx = f->private_data;
+        sigset_t sigmask;
+
+        sigmask = ctx->sigmask;
+        signotset(&sigmask);
+        render_sigset_t(m, "sigmask:\t", &sigmask);
+
+        return 0;
+}
+#endif
+
 static const struct file_operations signalfd_fops = {
+#ifdef CONFIG_PROC_FS
+        .show_fdinfo    = signalfd_show_fdinfo,
+#endif
         .release        = signalfd_release,
         .poll           = signalfd_poll,
         .read           = signalfd_read,
diff --git a/fs/ubifs/debug.c b/fs/ubifs/debug.c
index 62911637e12f..12817ffc7345 100644
--- a/fs/ubifs/debug.c
+++ b/fs/ubifs/debug.c
@@ -2560,7 +2560,7 @@ static int power_cut_emulated(struct ubifs_info *c, int lnum, int write)
 static int corrupt_data(const struct ubifs_info *c, const void *buf,
                         unsigned int len)
 {
-        unsigned int from, to, i, ffs = chance(1, 2);
+        unsigned int from, to, ffs = chance(1, 2);
         unsigned char *p = (void *)buf;
 
         from = random32() % (len + 1);
@@ -2571,11 +2571,9 @@ static int corrupt_data(const struct ubifs_info *c, const void *buf,
                    ffs ? "0xFFs" : "random data");
 
         if (ffs)
-                for (i = from; i < to; i++)
-                        p[i] = 0xFF;
+                memset(p + from, 0xFF, to - from);
         else
-                for (i = from; i < to; i++)
-                        p[i] = random32() % 0x100;
+                prandom_bytes(p + from, to - from);
 
         return to;
 }
diff --git a/fs/ubifs/dir.c b/fs/ubifs/dir.c
index e271fba1651b..8a574776a493 100644
--- a/fs/ubifs/dir.c
+++ b/fs/ubifs/dir.c
@@ -453,11 +453,11 @@ out:
 }
 
 /* If a directory is seeked, we have to free saved readdir() state */
-static loff_t ubifs_dir_llseek(struct file *file, loff_t offset, int origin)
+static loff_t ubifs_dir_llseek(struct file *file, loff_t offset, int whence)
 {
         kfree(file->private_data);
         file->private_data = NULL;
-        return generic_file_llseek(file, offset, origin);
+        return generic_file_llseek(file, offset, whence);
 }
 
 /* Free saved readdir() state when the directory is closed */