15 files changed, 222 insertions, 80 deletions

diff --git a/fs/affs/affs.h b/fs/affs/affs.h
index d5bd497ab9cb..223b1917093e 100644
--- a/fs/affs/affs.h
+++ b/fs/affs/affs.h
@@ -48,7 +48,7 @@ struct affs_ext_key {
  * affs fs inode data in memory
  */
 struct affs_inode_info {
-        u32      i_opencnt;
+        atomic_t i_opencnt;
         struct semaphore i_link_lock;           /* Protects internal inode access. */
         struct semaphore i_ext_lock;            /* Protects internal inode access. */
 #define i_hash_lock i_ext_lock
@@ -170,8 +170,6 @@ extern int	affs_rename(struct inode *old_dir, struct dentry *old_dentry,
 extern unsigned long             affs_parent_ino(struct inode *dir);
 extern struct inode             *affs_new_inode(struct inode *dir);
 extern int                       affs_notify_change(struct dentry *dentry, struct iattr *attr);
-extern void                      affs_put_inode(struct inode *inode);
-extern void                      affs_drop_inode(struct inode *inode);
 extern void                      affs_delete_inode(struct inode *inode);
 extern void                      affs_clear_inode(struct inode *inode);
 extern struct inode             *affs_iget(struct super_block *sb,
diff --git a/fs/affs/file.c b/fs/affs/file.c
index 1a4f092f24ef..6eac7bdeec94 100644
--- a/fs/affs/file.c
+++ b/fs/affs/file.c
@@ -48,8 +48,9 @@ affs_file_open(struct inode *inode, struct file *filp)
 {
         if (atomic_read(&filp->f_count) != 1)
                 return 0;
-        pr_debug("AFFS: open(%d)\n", AFFS_I(inode)->i_opencnt);
-        AFFS_I(inode)->i_opencnt++;
+        pr_debug("AFFS: open(%lu,%d)\n",
+                 inode->i_ino, atomic_read(&AFFS_I(inode)->i_opencnt));
+        atomic_inc(&AFFS_I(inode)->i_opencnt);
         return 0;
 }
 
@@ -58,10 +59,16 @@ affs_file_release(struct inode *inode, struct file *filp)
 {
         if (atomic_read(&filp->f_count) != 0)
                 return 0;
-        pr_debug("AFFS: release(%d)\n", AFFS_I(inode)->i_opencnt);
-        AFFS_I(inode)->i_opencnt--;
-        if (!AFFS_I(inode)->i_opencnt)
+        pr_debug("AFFS: release(%lu, %d)\n",
+                 inode->i_ino, atomic_read(&AFFS_I(inode)->i_opencnt));
+
+        if (atomic_dec_and_test(&AFFS_I(inode)->i_opencnt)) {
+                mutex_lock(&inode->i_mutex);
+                if (inode->i_size != AFFS_I(inode)->mmu_private)
+                        affs_truncate(inode);
                 affs_free_prealloc(inode);
+                mutex_unlock(&inode->i_mutex);
+        }
 
         return 0;
 }
@@ -180,7 +187,7 @@ affs_get_extblock(struct inode *inode, u32 ext)
         /* inline the simplest case: same extended block as last time */
         struct buffer_head *bh = AFFS_I(inode)->i_ext_bh;
         if (ext == AFFS_I(inode)->i_ext_last)
-                atomic_inc(&bh->b_count);
+                get_bh(bh);
         else
                 /* we have to do more (not inlined) */
                 bh = affs_get_extblock_slow(inode, ext);
@@ -306,7 +313,7 @@ store_ext:
         affs_brelse(AFFS_I(inode)->i_ext_bh);
         AFFS_I(inode)->i_ext_last = ext;
         AFFS_I(inode)->i_ext_bh = bh;
-        atomic_inc(&bh->b_count);
+        get_bh(bh);
 
         return bh;
 
@@ -324,7 +331,6 @@ affs_get_block(struct inode *inode, sector_t block, struct buffer_head *bh_resul
 
         pr_debug("AFFS: get_block(%u, %lu)\n", (u32)inode->i_ino, (unsigned long)block);
 
-
         BUG_ON(block > (sector_t)0x7fffffffUL);
 
         if (block >= AFFS_I(inode)->i_blkcnt) {
@@ -827,6 +833,8 @@ affs_truncate(struct inode *inode)
                 res = mapping->a_ops->write_begin(NULL, mapping, size, 0, 0, &page, &fsdata);
                 if (!res)
                         res = mapping->a_ops->write_end(NULL, mapping, size, 0, 0, page, fsdata);
+                else
+                        inode->i_size = AFFS_I(inode)->mmu_private;
                 mark_inode_dirty(inode);
                 return;
         } else if (inode->i_size == AFFS_I(inode)->mmu_private)
@@ -862,6 +870,7 @@ affs_truncate(struct inode *inode)
                 blk++;
         } else
                 AFFS_HEAD(ext_bh)->first_data = 0;
+        AFFS_HEAD(ext_bh)->block_count = cpu_to_be32(i);
         size = AFFS_SB(sb)->s_hashsize;
         if (size > blkcnt - blk + i)
                 size = blkcnt - blk + i;
diff --git a/fs/affs/inode.c b/fs/affs/inode.c
index 27fe6cbe43ae..a13b334a3910 100644
--- a/fs/affs/inode.c
+++ b/fs/affs/inode.c
@@ -58,7 +58,7 @@ struct inode *affs_iget(struct super_block *sb, unsigned long ino)
         AFFS_I(inode)->i_extcnt = 1;
         AFFS_I(inode)->i_ext_last = ~1;
         AFFS_I(inode)->i_protect = prot;
-        AFFS_I(inode)->i_opencnt = 0;
+        atomic_set(&AFFS_I(inode)->i_opencnt, 0);
         AFFS_I(inode)->i_blkcnt = 0;
         AFFS_I(inode)->i_lc = NULL;
         AFFS_I(inode)->i_lc_size = 0;
@@ -108,8 +108,6 @@ struct inode *affs_iget(struct super_block *sb, unsigned long ino)
                         inode->i_mode |= S_IFDIR;
                 } else
                         inode->i_mode = S_IRUGO | S_IXUGO | S_IWUSR | S_IFDIR;
-                if (tail->link_chain)
-                        inode->i_nlink = 2;
                 /* Maybe it should be controlled by mount parameter? */
                 //inode->i_mode |= S_ISVTX;
                 inode->i_op = &affs_dir_inode_operations;
@@ -245,31 +243,12 @@ out:
 }
 
 void
-affs_put_inode(struct inode *inode)
-{
-        pr_debug("AFFS: put_inode(ino=%lu, nlink=%u)\n", inode->i_ino, inode->i_nlink);
-        affs_free_prealloc(inode);
-}
-
-void
-affs_drop_inode(struct inode *inode)
-{
-        mutex_lock(&inode->i_mutex);
-        if (inode->i_size != AFFS_I(inode)->mmu_private)
-                affs_truncate(inode);
-        mutex_unlock(&inode->i_mutex);
-
-        generic_drop_inode(inode);
-}
-
-void
 affs_delete_inode(struct inode *inode)
 {
         pr_debug("AFFS: delete_inode(ino=%lu, nlink=%u)\n", inode->i_ino, inode->i_nlink);
         truncate_inode_pages(&inode->i_data, 0);
         inode->i_size = 0;
-        if (S_ISREG(inode->i_mode))
-                affs_truncate(inode);
+        affs_truncate(inode);
         clear_inode(inode);
         affs_free_block(inode->i_sb, inode->i_ino);
 }
@@ -277,9 +256,12 @@ affs_delete_inode(struct inode *inode)
 void
 affs_clear_inode(struct inode *inode)
 {
-        unsigned long cache_page = (unsigned long) AFFS_I(inode)->i_lc;
+        unsigned long cache_page;
 
         pr_debug("AFFS: clear_inode(ino=%lu, nlink=%u)\n", inode->i_ino, inode->i_nlink);
+
+        affs_free_prealloc(inode);
+        cache_page = (unsigned long)AFFS_I(inode)->i_lc;
         if (cache_page) {
                 pr_debug("AFFS: freeing ext cache\n");
                 AFFS_I(inode)->i_lc = NULL;
@@ -316,7 +298,7 @@ affs_new_inode(struct inode *dir)
         inode->i_ino     = block;
         inode->i_nlink   = 1;
         inode->i_mtime   = inode->i_atime = inode->i_ctime = CURRENT_TIME_SEC;
-        AFFS_I(inode)->i_opencnt = 0;
+        atomic_set(&AFFS_I(inode)->i_opencnt, 0);
         AFFS_I(inode)->i_blkcnt = 0;
         AFFS_I(inode)->i_lc = NULL;
         AFFS_I(inode)->i_lc_size = 0;
@@ -369,12 +351,12 @@ affs_add_entry(struct inode *dir, struct inode *inode, struct dentry *dentry, s3
         switch (type) {
         case ST_LINKFILE:
         case ST_LINKDIR:
-                inode_bh = bh;
                 retval = -ENOSPC;
                 block = affs_alloc_block(dir, dir->i_ino);
                 if (!block)
                         goto err;
                 retval = -EIO;
+                inode_bh = bh;
                 bh = affs_getzeroblk(sb, block);
                 if (!bh)
                         goto err;
diff --git a/fs/affs/namei.c b/fs/affs/namei.c
index 2218f1ee71ce..cfcf1b6cf82b 100644
--- a/fs/affs/namei.c
+++ b/fs/affs/namei.c
@@ -234,7 +234,8 @@ affs_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
 int
 affs_unlink(struct inode *dir, struct dentry *dentry)
 {
-        pr_debug("AFFS: unlink(dir=%d, \"%.*s\")\n", (u32)dir->i_ino,
+        pr_debug("AFFS: unlink(dir=%d, %lu \"%.*s\")\n", (u32)dir->i_ino,
+                 dentry->d_inode->i_ino,
                  (int)dentry->d_name.len, dentry->d_name.name);
 
         return affs_remove_header(dentry);
@@ -302,7 +303,8 @@ affs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
 int
 affs_rmdir(struct inode *dir, struct dentry *dentry)
 {
-        pr_debug("AFFS: rmdir(dir=%u, \"%.*s\")\n", (u32)dir->i_ino,
+        pr_debug("AFFS: rmdir(dir=%u, %lu \"%.*s\")\n", (u32)dir->i_ino,
+                 dentry->d_inode->i_ino,
                  (int)dentry->d_name.len, dentry->d_name.name);
 
         return affs_remove_header(dentry);
diff --git a/fs/affs/super.c b/fs/affs/super.c
index 01d25d532541..d214837d5e42 100644
--- a/fs/affs/super.c
+++ b/fs/affs/super.c
@@ -71,12 +71,18 @@ static struct kmem_cache * affs_inode_cachep;
 
 static struct inode *affs_alloc_inode(struct super_block *sb)
 {
-        struct affs_inode_info *ei;
-        ei = (struct affs_inode_info *)kmem_cache_alloc(affs_inode_cachep, GFP_KERNEL);
-        if (!ei)
+        struct affs_inode_info *i;
+
+        i = kmem_cache_alloc(affs_inode_cachep, GFP_KERNEL);
+        if (!i)
                 return NULL;
-        ei->vfs_inode.i_version = 1;
-        return &ei->vfs_inode;
+
+        i->vfs_inode.i_version = 1;
+        i->i_lc = NULL;
+        i->i_ext_bh = NULL;
+        i->i_pa_cnt = 0;
+
+        return &i->vfs_inode;
 }
 
 static void affs_destroy_inode(struct inode *inode)
@@ -114,8 +120,6 @@ static const struct super_operations affs_sops = {
         .alloc_inode    = affs_alloc_inode,
         .destroy_inode  = affs_destroy_inode,
         .write_inode    = affs_write_inode,
-        .put_inode      = affs_put_inode,
-        .drop_inode     = affs_drop_inode,
         .delete_inode   = affs_delete_inode,
         .clear_inode    = affs_clear_inode,
         .put_super      = affs_put_super,
diff --git a/fs/bio.c b/fs/bio.c
index 799f86deff24..78562574cb52 100644
--- a/fs/bio.c
+++ b/fs/bio.c
@@ -158,7 +158,7 @@ struct bio *bio_alloc_bioset(gfp_t gfp_mask, int nr_iovecs, struct bio_set *bs)
 
                 bio_init(bio);
                 if (likely(nr_iovecs)) {
-                        unsigned long idx = 0; /* shut up gcc */
+                        unsigned long uninitialized_var(idx);
 
                         bvl = bvec_alloc_bs(gfp_mask, nr_iovecs, &idx, bs);
                         if (unlikely(!bvl)) {
@@ -963,6 +963,7 @@ static void bio_copy_kern_endio(struct bio *bio, int err)
  *      @data: pointer to buffer to copy
  *      @len: length in bytes
  *      @gfp_mask: allocation flags for bio and page allocation
+ *      @reading: data direction is READ
  *
  *      copy the kernel address into a bio suitable for io to a block
  *      device. Returns an error pointer in case of error.
diff --git a/fs/inode.c b/fs/inode.c
index bf6478130424..c36d9480335c 100644
--- a/fs/inode.c
+++ b/fs/inode.c
@@ -1149,13 +1149,8 @@ static inline void iput_final(struct inode *inode)
 void iput(struct inode *inode)
 {
         if (inode) {
-                const struct super_operations *op = inode->i_sb->s_op;
-
                 BUG_ON(inode->i_state == I_CLEAR);
 
-                if (op && op->put_inode)
-                        op->put_inode(inode);
-
                 if (atomic_dec_and_lock(&inode->i_count, &inode_lock))
                         iput_final(inode);
         }
diff --git a/fs/locks.c b/fs/locks.c
index 663c069b59b3..0ac6b92cb0b6 100644
--- a/fs/locks.c
+++ b/fs/locks.c
@@ -1753,6 +1753,7 @@ int fcntl_setlk(unsigned int fd, struct file *filp, unsigned int cmd,
         struct file_lock *file_lock = locks_alloc_lock();
         struct flock flock;
         struct inode *inode;
+        struct file *f;
         int error;
 
         if (file_lock == NULL)
@@ -1825,7 +1826,15 @@ again:
          * Attempt to detect a close/fcntl race and recover by
          * releasing the lock that was just acquired.
          */
-        if (!error && fcheck(fd) != filp && flock.l_type != F_UNLCK) {
+        /*
+         * we need that spin_lock here - it prevents reordering between
+         * update of inode->i_flock and check for it done in close().
+         * rcu_read_lock() wouldn't do.
+         */
+        spin_lock(&current->files->file_lock);
+        f = fcheck(fd);
+        spin_unlock(&current->files->file_lock);
+        if (!error && f != filp && flock.l_type != F_UNLCK) {
                 flock.l_type = F_UNLCK;
                 goto again;
         }
@@ -1881,6 +1890,7 @@ int fcntl_setlk64(unsigned int fd, struct file *filp, unsigned int cmd,
         struct file_lock *file_lock = locks_alloc_lock();
         struct flock64 flock;
         struct inode *inode;
+        struct file *f;
         int error;
 
         if (file_lock == NULL)
@@ -1953,7 +1963,10 @@ again:
          * Attempt to detect a close/fcntl race and recover by
          * releasing the lock that was just acquired.
          */
-        if (!error && fcheck(fd) != filp && flock.l_type != F_UNLCK) {
+        spin_lock(&current->files->file_lock);
+        f = fcheck(fd);
+        spin_unlock(&current->files->file_lock);
+        if (!error && f != filp && flock.l_type != F_UNLCK) {
                 flock.l_type = F_UNLCK;
                 goto again;
         }
diff --git a/fs/pipe.c b/fs/pipe.c
index 3499f9ff6316..ec228bc9f882 100644
--- a/fs/pipe.c
+++ b/fs/pipe.c
@@ -17,6 +17,7 @@
 #include <linux/highmem.h>
 #include <linux/pagemap.h>
 #include <linux/audit.h>
+#include <linux/syscalls.h>
 
 #include <asm/uaccess.h>
 #include <asm/ioctls.h>
@@ -1086,8 +1087,11 @@ asmlinkage long __weak sys_pipe(int __user *fildes)
 
         error = do_pipe(fd);
         if (!error) {
-                if (copy_to_user(fildes, fd, sizeof(fd)))
+                if (copy_to_user(fildes, fd, sizeof(fd))) {
+                        sys_close(fd[0]);
+                        sys_close(fd[1]);
                         error = -EFAULT;
+                }
         }
         return error;
 }
diff --git a/fs/proc/task_mmu.c b/fs/proc/task_mmu.c
index e2b8e769f510..88717c0f941b 100644
--- a/fs/proc/task_mmu.c
+++ b/fs/proc/task_mmu.c
@@ -5,11 +5,9 @@
 #include <linux/highmem.h>
 #include <linux/ptrace.h>
 #include <linux/pagemap.h>
-#include <linux/ptrace.h>
 #include <linux/mempolicy.h>
 #include <linux/swap.h>
 #include <linux/swapops.h>
-#include <linux/seq_file.h>
 
 #include <asm/elf.h>
 #include <asm/uaccess.h>
diff --git a/fs/splice.c b/fs/splice.c
index 633f58ebfb72..78150038b584 100644
--- a/fs/splice.c
+++ b/fs/splice.c
@@ -811,24 +811,19 @@ generic_file_splice_write(struct pipe_inode_info *pipe, struct file *out,
 {
         struct address_space *mapping = out->f_mapping;
         struct inode *inode = mapping->host;
-        int killsuid, killpriv;
+        struct splice_desc sd = {
+                .total_len = len,
+                .flags = flags,
+                .pos = *ppos,
+                .u.file = out,
+        };
         ssize_t ret;
-        int err = 0;
-
-        killpriv = security_inode_need_killpriv(out->f_path.dentry);
-        killsuid = should_remove_suid(out->f_path.dentry);
-        if (unlikely(killsuid || killpriv)) {
-                mutex_lock(&inode->i_mutex);
-                if (killpriv)
-                        err = security_inode_killpriv(out->f_path.dentry);
-                if (!err && killsuid)
-                        err = __remove_suid(out->f_path.dentry, killsuid);
-                mutex_unlock(&inode->i_mutex);
-                if (err)
-                        return err;
-        }
 
-        ret = splice_from_pipe(pipe, out, ppos, len, flags, pipe_to_file);
+        inode_double_lock(inode, pipe->inode);
+        ret = remove_suid(out->f_path.dentry);
+        if (likely(!ret))
+                ret = __splice_from_pipe(pipe, &sd, pipe_to_file);
+        inode_double_unlock(inode, pipe->inode);
         if (ret > 0) {
                 unsigned long nr_pages;
 
@@ -840,6 +835,8 @@ generic_file_splice_write(struct pipe_inode_info *pipe, struct file *out,
                  * sync it.
                  */
                 if (unlikely((out->f_flags & O_SYNC) || IS_SYNC(inode))) {
+                        int err;
+
                         mutex_lock(&inode->i_mutex);
                         err = generic_osync_inode(inode, mapping,
                                                   OSYNC_METADATA|OSYNC_DATA);
@@ -1075,7 +1072,7 @@ long do_splice_direct(struct file *in, loff_t *ppos, struct file *out,
 
         ret = splice_direct_to_actor(in, &sd, direct_splice_actor);
         if (ret > 0)
-                *ppos = sd.pos;
+                *ppos += ret;
 
         return ret;
 }
diff --git a/fs/udf/namei.c b/fs/udf/namei.c
index 2b34c8ca6c83..d3231947db19 100644
--- a/fs/udf/namei.c
+++ b/fs/udf/namei.c
@@ -32,6 +32,7 @@
 #include <linux/buffer_head.h>
 #include <linux/sched.h>
 #include <linux/crc-itu-t.h>
+#include <linux/exportfs.h>
 
 static inline int udf_match(int len1, const char *name1, int len2,
                             const char *name2)
@@ -158,6 +159,8 @@ static struct fileIdentDesc *udf_find_entry(struct inode *dir,
         sector_t offset;
         struct extent_position epos = {};
         struct udf_inode_info *dinfo = UDF_I(dir);
+        int isdotdot = dentry->d_name.len == 2 &&
+                dentry->d_name.name[0] == '.' && dentry->d_name.name[1] == '.';
 
         size = udf_ext0_offset(dir) + dir->i_size;
         f_pos = udf_ext0_offset(dir);
@@ -225,6 +228,12 @@ static struct fileIdentDesc *udf_find_entry(struct inode *dir,
                                 continue;
                 }
 
+                if ((cfi->fileCharacteristics & FID_FILE_CHAR_PARENT) &&
+                    isdotdot) {
+                        brelse(epos.bh);
+                        return fi;
+                }
+
                 if (!lfi)
                         continue;
 
@@ -286,9 +295,8 @@ static struct dentry *udf_lookup(struct inode *dir, struct dentry *dentry,
                 }
         }
         unlock_kernel();
-        d_add(dentry, inode);
 
-        return NULL;
+        return d_splice_alias(inode, dentry);
 }
 
 static struct fileIdentDesc *udf_add_entry(struct inode *dir,
@@ -307,7 +315,7 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir,
         uint16_t liu;
         int block;
         kernel_lb_addr eloc;
-        uint32_t elen;
+        uint32_t elen = 0;
         sector_t offset;
         struct extent_position epos = {};
         struct udf_inode_info *dinfo;
@@ -398,7 +406,8 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir,
         }
 
 add:
-        if (dinfo->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB) {
+        /* Is there any extent whose size we need to round up? */
+        if (dinfo->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB && elen) {
                 elen = (elen + sb->s_blocksize - 1) & ~(sb->s_blocksize - 1);
                 if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
                         epos.offset -= sizeof(short_ad);
@@ -1232,6 +1241,134 @@ end_rename:
         return retval;
 }
 
+static struct dentry *udf_get_parent(struct dentry *child)
+{
+        struct dentry *parent;
+        struct inode *inode = NULL;
+        struct dentry dotdot;
+        struct fileIdentDesc cfi;
+        struct udf_fileident_bh fibh;
+
+        dotdot.d_name.name = "..";
+        dotdot.d_name.len = 2;
+
+        lock_kernel();
+        if (!udf_find_entry(child->d_inode, &dotdot, &fibh, &cfi))
+                goto out_unlock;
+
+        if (fibh.sbh != fibh.ebh)
+                brelse(fibh.ebh);
+        brelse(fibh.sbh);
+
+        inode = udf_iget(child->d_inode->i_sb,
+                         lelb_to_cpu(cfi.icb.extLocation));
+        if (!inode)
+                goto out_unlock;
+        unlock_kernel();
+
+        parent = d_alloc_anon(inode);
+        if (!parent) {
+                iput(inode);
+                parent = ERR_PTR(-ENOMEM);
+        }
+
+        return parent;
+out_unlock:
+        unlock_kernel();
+        return ERR_PTR(-EACCES);
+}
+
+
+static struct dentry *udf_nfs_get_inode(struct super_block *sb, u32 block,
+                                        u16 partref, __u32 generation)
+{
+        struct inode *inode;
+        struct dentry *result;
+        kernel_lb_addr loc;
+
+        if (block == 0)
+                return ERR_PTR(-ESTALE);
+
+        loc.logicalBlockNum = block;
+        loc.partitionReferenceNum = partref;
+        inode = udf_iget(sb, loc);
+
+        if (inode == NULL)
+                return ERR_PTR(-ENOMEM);
+
+        if (generation && inode->i_generation != generation) {
+                iput(inode);
+                return ERR_PTR(-ESTALE);
+        }
+        result = d_alloc_anon(inode);
+        if (!result) {
+                iput(inode);
+                return ERR_PTR(-ENOMEM);
+        }
+        return result;
+}
+
+static struct dentry *udf_fh_to_dentry(struct super_block *sb,
+                                       struct fid *fid, int fh_len, int fh_type)
+{
+        if ((fh_len != 3 && fh_len != 5) ||
+            (fh_type != FILEID_UDF_WITH_PARENT &&
+             fh_type != FILEID_UDF_WITHOUT_PARENT))
+                return NULL;
+
+        return udf_nfs_get_inode(sb, fid->udf.block, fid->udf.partref,
+                        fid->udf.generation);
+}
+
+static struct dentry *udf_fh_to_parent(struct super_block *sb,
+                                       struct fid *fid, int fh_len, int fh_type)
+{
+        if (fh_len != 5 || fh_type != FILEID_UDF_WITH_PARENT)
+                return NULL;
+
+        return udf_nfs_get_inode(sb, fid->udf.parent_block,
+                                 fid->udf.parent_partref,
+                                 fid->udf.parent_generation);
+}
+static int udf_encode_fh(struct dentry *de, __u32 *fh, int *lenp,
+                         int connectable)
+{
+        int len = *lenp;
+        struct inode *inode =  de->d_inode;
+        kernel_lb_addr location = UDF_I(inode)->i_location;
+        struct fid *fid = (struct fid *)fh;
+        int type = FILEID_UDF_WITHOUT_PARENT;
+
+        if (len < 3 || (connectable && len < 5))
+                return 255;
+
+        *lenp = 3;
+        fid->udf.block = location.logicalBlockNum;
+        fid->udf.partref = location.partitionReferenceNum;
+        fid->udf.generation = inode->i_generation;
+
+        if (connectable && !S_ISDIR(inode->i_mode)) {
+                spin_lock(&de->d_lock);
+                inode = de->d_parent->d_inode;
+                location = UDF_I(inode)->i_location;
+                fid->udf.parent_block = location.logicalBlockNum;
+                fid->udf.parent_partref = location.partitionReferenceNum;
+                fid->udf.parent_generation = inode->i_generation;
+                spin_unlock(&de->d_lock);
+                *lenp = 5;
+                type = FILEID_UDF_WITH_PARENT;
+        }
+
+        return type;
+}
+
+const struct export_operations udf_export_ops = {
+        .encode_fh      = udf_encode_fh,
+        .fh_to_dentry   = udf_fh_to_dentry,
+        .fh_to_parent   = udf_fh_to_parent,
+        .get_parent     = udf_get_parent,
+};
+
 const struct inode_operations udf_dir_inode_operations = {
         .lookup                         = udf_lookup,
         .create                         = udf_create,
diff --git a/fs/udf/partition.c b/fs/udf/partition.c
index 63610f026ae1..96dfd207c3d6 100644
--- a/fs/udf/partition.c
+++ b/fs/udf/partition.c
@@ -27,8 +27,8 @@
 #include <linux/slab.h>
 #include <linux/buffer_head.h>
 
-inline uint32_t udf_get_pblock(struct super_block *sb, uint32_t block,
-                               uint16_t partition, uint32_t offset)
+uint32_t udf_get_pblock(struct super_block *sb, uint32_t block,
+                        uint16_t partition, uint32_t offset)
 {
         struct udf_sb_info *sbi = UDF_SB(sb);
         struct udf_part_map *map;
diff --git a/fs/udf/super.c b/fs/udf/super.c
index 9fb18a340fc1..7a5f69be6ac2 100644
--- a/fs/udf/super.c
+++ b/fs/udf/super.c
@@ -1933,6 +1933,7 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
 
         /* Fill in the rest of the superblock */
         sb->s_op = &udf_sb_ops;
+        sb->s_export_op = &udf_export_ops;
         sb->dq_op = NULL;
         sb->s_dirt = 0;
         sb->s_magic = UDF_SUPER_MAGIC;
diff --git a/fs/udf/udfdecl.h b/fs/udf/udfdecl.h
index f3f45d029277..8fa9c2d70911 100644
--- a/fs/udf/udfdecl.h
+++ b/fs/udf/udfdecl.h
@@ -73,6 +73,7 @@ struct task_struct;
 struct buffer_head;
 struct super_block;
 
+extern const struct export_operations udf_export_ops;
 extern const struct inode_operations udf_dir_inode_operations;
 extern const struct file_operations udf_dir_operations;
 extern const struct inode_operations udf_file_inode_operations;