Patched in Tegra support.

7 files changed, 92 insertions, 124 deletions

diff --git a/fs/hfs/dir.c b/fs/hfs/dir.c
index 422dde2ec0a..b4d70b13be9 100644
--- a/fs/hfs/dir.c
+++ b/fs/hfs/dir.c
@@ -18,7 +18,7 @@
  * hfs_lookup()
  */
 static struct dentry *hfs_lookup(struct inode *dir, struct dentry *dentry,
-                                 unsigned int flags)
+                                 struct nameidata *nd)
 {
         hfs_cat_rec rec;
         struct hfs_find_data fd;
@@ -186,8 +186,8 @@ static int hfs_dir_release(struct inode *inode, struct file *file)
  * a directory and return a corresponding inode, given the inode for
  * the directory and the name (and its length) of the new file.
  */
-static int hfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
-                      bool excl)
+static int hfs_create(struct inode *dir, struct dentry *dentry, int mode,
+                      struct nameidata *nd)
 {
         struct inode *inode;
         int res;
@@ -198,7 +198,7 @@ static int hfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
 
         res = hfs_cat_create(inode->i_ino, dir, &dentry->d_name, inode);
         if (res) {
-                clear_nlink(inode);
+                inode->i_nlink = 0;
                 hfs_delete_inode(inode);
                 iput(inode);
                 return res;
@@ -216,7 +216,7 @@ static int hfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
  * in a directory, given the inode for the parent directory and the
  * name (and its length) of the new directory.
  */
-static int hfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
+static int hfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
 {
         struct inode *inode;
         int res;
@@ -227,7 +227,7 @@ static int hfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 
         res = hfs_cat_create(inode->i_ino, dir, &dentry->d_name, inode);
         if (res) {
-                clear_nlink(inode);
+                inode->i_nlink = 0;
                 hfs_delete_inode(inode);
                 iput(inode);
                 return res;
diff --git a/fs/hfs/extent.c b/fs/hfs/extent.c
index a67955a0c36..2c16316d291 100644
--- a/fs/hfs/extent.c
+++ b/fs/hfs/extent.c
@@ -432,7 +432,7 @@ out:
                 if (inode->i_ino < HFS_FIRSTUSER_CNID)
                         set_bit(HFS_FLG_ALT_MDB_DIRTY, &HFS_SB(sb)->flags);
                 set_bit(HFS_FLG_MDB_DIRTY, &HFS_SB(sb)->flags);
-                hfs_mark_mdb_dirty(sb);
+                sb->s_dirt = 1;
         }
         return res;
 
diff --git a/fs/hfs/hfs_fs.h b/fs/hfs/hfs_fs.h
index 693df9fe52b..ad97c2d5828 100644
--- a/fs/hfs/hfs_fs.h
+++ b/fs/hfs/hfs_fs.h
@@ -14,7 +14,6 @@
 #include <linux/mutex.h>
 #include <linux/buffer_head.h>
 #include <linux/fs.h>
-#include <linux/workqueue.h>
 
 #include <asm/byteorder.h>
 #include <asm/uaccess.h>
@@ -134,19 +133,20 @@ struct hfs_sb_info {
                                                    permissions on all files */
         umode_t s_dir_umask;                    /* The umask applied to the
                                                    permissions on all dirs */
-        kuid_t s_uid;                           /* The uid of all files */
-        kgid_t s_gid;                           /* The gid of all files */
+        uid_t s_uid;                            /* The uid of all files */
+        gid_t s_gid;                            /* The gid of all files */
 
         int session, part;
+
         struct nls_table *nls_io, *nls_disk;
+
         struct mutex bitmap_lock;
+
         unsigned long flags;
+
         u16 blockoffset;
+
         int fs_div;
-        struct super_block *sb;
-        int work_queued;                /* non-zero delayed work is queued */
-        struct delayed_work mdb_work;   /* MDB flush delayed work */
-        spinlock_t work_lock;           /* protects mdb_work and work_queued */
 };
 
 #define HFS_FLG_BITMAP_DIRTY    0
@@ -184,7 +184,7 @@ extern int hfs_get_block(struct inode *, sector_t, struct buffer_head *, int);
 extern const struct address_space_operations hfs_aops;
 extern const struct address_space_operations hfs_btree_aops;
 
-extern struct inode *hfs_new_inode(struct inode *, struct qstr *, umode_t);
+extern struct inode *hfs_new_inode(struct inode *, struct qstr *, int);
 extern void hfs_inode_write_fork(struct inode *, struct hfs_extent *, __be32 *, __be32 *);
 extern int hfs_write_inode(struct inode *, struct writeback_control *);
 extern int hfs_inode_setattr(struct dentry *, struct iattr *);
@@ -226,9 +226,6 @@ extern int hfs_compare_dentry(const struct dentry *parent,
 extern void hfs_asc2mac(struct super_block *, struct hfs_name *, struct qstr *);
 extern int hfs_mac2asc(struct super_block *, char *, const struct hfs_name *);
 
-/* super.c */
-extern void hfs_mark_mdb_dirty(struct super_block *sb);
-
 extern struct timezone sys_tz;
 
 /*
@@ -256,7 +253,7 @@ static inline const char *hfs_mdb_name(struct super_block *sb)
 static inline void hfs_bitmap_dirty(struct super_block *sb)
 {
         set_bit(HFS_FLG_BITMAP_DIRTY, &HFS_SB(sb)->flags);
-        hfs_mark_mdb_dirty(sb);
+        sb->s_dirt = 1;
 }
 
 #define sb_bread512(sb, sec, data) ({                   \
diff --git a/fs/hfs/inode.c b/fs/hfs/inode.c
index d47f11658c1..96a1b625fc7 100644
--- a/fs/hfs/inode.c
+++ b/fs/hfs/inode.c
@@ -35,16 +35,6 @@ static int hfs_readpage(struct file *file, struct page *page)
         return block_read_full_page(page, hfs_get_block);
 }
 
-static void hfs_write_failed(struct address_space *mapping, loff_t to)
-{
-        struct inode *inode = mapping->host;
-
-        if (to > inode->i_size) {
-                truncate_pagecache(inode, to, inode->i_size);
-                hfs_file_truncate(inode);
-        }
-}
-
 static int hfs_write_begin(struct file *file, struct address_space *mapping,
                         loff_t pos, unsigned len, unsigned flags,
                         struct page **pagep, void **fsdata)
@@ -55,8 +45,11 @@ static int hfs_write_begin(struct file *file, struct address_space *mapping,
         ret = cont_write_begin(file, mapping, pos, len, flags, pagep, fsdata,
                                 hfs_get_block,
                                 &HFS_I(mapping->host)->phys_size);
-        if (unlikely(ret))
-                hfs_write_failed(mapping, pos + len);
+        if (unlikely(ret)) {
+                loff_t isize = mapping->host->i_size;
+                if (pos + len > isize)
+                        vmtruncate(mapping->host, isize);
+        }
 
         return ret;
 }
@@ -127,7 +120,6 @@ static ssize_t hfs_direct_IO(int rw, struct kiocb *iocb,
                 const struct iovec *iov, loff_t offset, unsigned long nr_segs)
 {
         struct file *file = iocb->ki_filp;
-        struct address_space *mapping = file->f_mapping;
         struct inode *inode = file->f_path.dentry->d_inode->i_mapping->host;
         ssize_t ret;
 
@@ -143,7 +135,7 @@ static ssize_t hfs_direct_IO(int rw, struct kiocb *iocb,
                 loff_t end = offset + iov_length(iov, nr_segs);
 
                 if (end > isize)
-                        hfs_write_failed(mapping, end);
+                        vmtruncate(inode, isize);
         }
 
         return ret;
@@ -177,7 +169,7 @@ const struct address_space_operations hfs_aops = {
 /*
  * hfs_new_inode
  */
-struct inode *hfs_new_inode(struct inode *dir, struct qstr *name, umode_t mode)
+struct inode *hfs_new_inode(struct inode *dir, struct qstr *name, int mode)
 {
         struct super_block *sb = dir->i_sb;
         struct inode *inode = new_inode(sb);
@@ -191,7 +183,7 @@ struct inode *hfs_new_inode(struct inode *dir, struct qstr *name, umode_t mode)
         inode->i_mode = mode;
         inode->i_uid = current_fsuid();
         inode->i_gid = current_fsgid();
-        set_nlink(inode, 1);
+        inode->i_nlink = 1;
         inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME_SEC;
         HFS_I(inode)->flags = 0;
         HFS_I(inode)->rsrc_inode = NULL;
@@ -228,7 +220,7 @@ struct inode *hfs_new_inode(struct inode *dir, struct qstr *name, umode_t mode)
         insert_inode_hash(inode);
         mark_inode_dirty(inode);
         set_bit(HFS_FLG_MDB_DIRTY, &HFS_SB(sb)->flags);
-        hfs_mark_mdb_dirty(sb);
+        sb->s_dirt = 1;
 
         return inode;
 }
@@ -243,7 +235,7 @@ void hfs_delete_inode(struct inode *inode)
                 if (HFS_I(inode)->cat_key.ParID == cpu_to_be32(HFS_ROOT_CNID))
                         HFS_SB(sb)->root_dirs--;
                 set_bit(HFS_FLG_MDB_DIRTY, &HFS_SB(sb)->flags);
-                hfs_mark_mdb_dirty(sb);
+                sb->s_dirt = 1;
                 return;
         }
         HFS_SB(sb)->file_count--;
@@ -256,7 +248,7 @@ void hfs_delete_inode(struct inode *inode)
                 }
         }
         set_bit(HFS_FLG_MDB_DIRTY, &HFS_SB(sb)->flags);
-        hfs_mark_mdb_dirty(sb);
+        sb->s_dirt = 1;
 }
 
 void hfs_inode_read_fork(struct inode *inode, struct hfs_extent *ext,
@@ -321,7 +313,7 @@ static int hfs_read_inode(struct inode *inode, void *data)
         /* Initialize the inode */
         inode->i_uid = hsb->s_uid;
         inode->i_gid = hsb->s_gid;
-        set_nlink(inode, 1);
+        inode->i_nlink = 1;
 
         if (idata->key)
                 HFS_I(inode)->cat_key = *idata->key;
@@ -497,7 +489,7 @@ out:
 }
 
 static struct dentry *hfs_file_lookup(struct inode *dir, struct dentry *dentry,
-                                      unsigned int flags)
+                                      struct nameidata *nd)
 {
         struct inode *inode = NULL;
         hfs_cat_rec rec;
@@ -540,7 +532,7 @@ out:
 void hfs_evict_inode(struct inode *inode)
 {
         truncate_inode_pages(&inode->i_data, 0);
-        clear_inode(inode);
+        end_writeback(inode);
         if (HFS_IS_RSRC(inode) && HFS_I(inode)->rsrc_inode) {
                 HFS_I(HFS_I(inode)->rsrc_inode)->rsrc_inode = NULL;
                 iput(HFS_I(inode)->rsrc_inode);
@@ -602,9 +594,9 @@ int hfs_inode_setattr(struct dentry *dentry, struct iattr * attr)
 
         /* no uig/gid changes and limit which mode bits can be set */
         if (((attr->ia_valid & ATTR_UID) &&
-             (!uid_eq(attr->ia_uid, hsb->s_uid))) ||
+             (attr->ia_uid != hsb->s_uid)) ||
             ((attr->ia_valid & ATTR_GID) &&
-             (!gid_eq(attr->ia_gid, hsb->s_gid))) ||
+             (attr->ia_gid != hsb->s_gid)) ||
             ((attr->ia_valid & ATTR_MODE) &&
              ((S_ISDIR(inode->i_mode) &&
                (attr->ia_mode != inode->i_mode)) ||
@@ -625,12 +617,9 @@ int hfs_inode_setattr(struct dentry *dentry, struct iattr * attr)
             attr->ia_size != i_size_read(inode)) {
                 inode_dio_wait(inode);
 
-                error = inode_newsize_ok(inode, attr->ia_size);
+                error = vmtruncate(inode, attr->ia_size);
                 if (error)
                         return error;
-
-                truncate_setsize(inode, attr->ia_size);
-                hfs_file_truncate(inode);
         }
 
         setattr_copy(inode, attr);
@@ -655,7 +644,13 @@ static int hfs_file_fsync(struct file *filp, loff_t start, loff_t end,
 
         /* sync the superblock to buffers */
         sb = inode->i_sb;
-        flush_delayed_work(&HFS_SB(sb)->mdb_work);
+        if (sb->s_dirt) {
+                lock_super(sb);
+                sb->s_dirt = 0;
+                if (!(sb->s_flags & MS_RDONLY))
+                        hfs_mdb_commit(sb);
+                unlock_super(sb);
+        }
         /* .. finally sync the buffers to disk */
         err = sync_blockdev(sb->s_bdev);
         if (!ret)
@@ -679,6 +674,7 @@ static const struct file_operations hfs_file_operations = {
 
 static const struct inode_operations hfs_file_inode_operations = {
         .lookup         = hfs_file_lookup,
+        .truncate       = hfs_file_truncate,
         .setattr        = hfs_inode_setattr,
         .setxattr       = hfs_setxattr,
         .getxattr       = hfs_getxattr,
diff --git a/fs/hfs/mdb.c b/fs/hfs/mdb.c
index b7ec224910c..1563d5ce576 100644
--- a/fs/hfs/mdb.c
+++ b/fs/hfs/mdb.c
@@ -236,10 +236,10 @@ out:
  * hfs_mdb_commit()
  *
  * Description:
- *   This updates the MDB on disk.
+ *   This updates the MDB on disk (look also at hfs_write_super()).
  *   It does not check, if the superblock has been modified, or
  *   if the filesystem has been mounted read-only. It is mainly
- *   called by hfs_sync_fs() and flush_mdb().
+ *   called by hfs_write_super() and hfs_btree_extend().
  * Input Variable(s):
  *   struct hfs_mdb *mdb: Pointer to the hfs MDB
  *   int backup;
@@ -260,10 +260,6 @@ void hfs_mdb_commit(struct super_block *sb)
 {
         struct hfs_mdb *mdb = HFS_SB(sb)->mdb;
 
-        if (sb->s_flags & MS_RDONLY)
-                return;
-
-        lock_buffer(HFS_SB(sb)->mdb_bh);
         if (test_and_clear_bit(HFS_FLG_MDB_DIRTY, &HFS_SB(sb)->flags)) {
                 /* These parameters may have been modified, so write them back */
                 mdb->drLsMod = hfs_mtime();
@@ -287,13 +283,9 @@ void hfs_mdb_commit(struct super_block *sb)
                                      &mdb->drXTFlSize, NULL);
                 hfs_inode_write_fork(HFS_SB(sb)->cat_tree->inode, mdb->drCTExtRec,
                                      &mdb->drCTFlSize, NULL);
-
-                lock_buffer(HFS_SB(sb)->alt_mdb_bh);
                 memcpy(HFS_SB(sb)->alt_mdb, HFS_SB(sb)->mdb, HFS_SECTOR_SIZE);
                 HFS_SB(sb)->alt_mdb->drAtrb |= cpu_to_be16(HFS_SB_ATTRIB_UNMNT);
                 HFS_SB(sb)->alt_mdb->drAtrb &= cpu_to_be16(~HFS_SB_ATTRIB_INCNSTNT);
-                unlock_buffer(HFS_SB(sb)->alt_mdb_bh);
-
                 mark_buffer_dirty(HFS_SB(sb)->alt_mdb_bh);
                 sync_dirty_buffer(HFS_SB(sb)->alt_mdb_bh);
         }
@@ -316,11 +308,7 @@ void hfs_mdb_commit(struct super_block *sb)
                                 break;
                         }
                         len = min((int)sb->s_blocksize - off, size);
-
-                        lock_buffer(bh);
                         memcpy(bh->b_data + off, ptr, len);
-                        unlock_buffer(bh);
-
                         mark_buffer_dirty(bh);
                         brelse(bh);
                         block++;
@@ -329,7 +317,6 @@ void hfs_mdb_commit(struct super_block *sb)
                         size -= len;
                 }
         }
-        unlock_buffer(HFS_SB(sb)->mdb_bh);
 }
 
 void hfs_mdb_close(struct super_block *sb)
diff --git a/fs/hfs/super.c b/fs/hfs/super.c
index e93ddaadfd1..1b55f704fb2 100644
--- a/fs/hfs/super.c
+++ b/fs/hfs/super.c
@@ -29,9 +29,43 @@ static struct kmem_cache *hfs_inode_cachep;
 
 MODULE_LICENSE("GPL");
 
+/*
+ * hfs_write_super()
+ *
+ * Description:
+ *   This function is called by the VFS only. When the filesystem
+ *   is mounted r/w it updates the MDB on disk.
+ * Input Variable(s):
+ *   struct super_block *sb: Pointer to the hfs superblock
+ * Output Variable(s):
+ *   NONE
+ * Returns:
+ *   void
+ * Preconditions:
+ *   'sb' points to a "valid" (struct super_block).
+ * Postconditions:
+ *   The MDB is marked 'unsuccessfully unmounted' by clearing bit 8 of drAtrb
+ *   (hfs_put_super() must set this flag!). Some MDB fields are updated
+ *   and the MDB buffer is written to disk by calling hfs_mdb_commit().
+ */
+static void hfs_write_super(struct super_block *sb)
+{
+        lock_super(sb);
+        sb->s_dirt = 0;
+
+        /* sync everything to the buffers */
+        if (!(sb->s_flags & MS_RDONLY))
+                hfs_mdb_commit(sb);
+        unlock_super(sb);
+}
+
 static int hfs_sync_fs(struct super_block *sb, int wait)
 {
+        lock_super(sb);
         hfs_mdb_commit(sb);
+        sb->s_dirt = 0;
+        unlock_super(sb);
+
         return 0;
 }
 
@@ -44,44 +78,13 @@ static int hfs_sync_fs(struct super_block *sb, int wait)
  */
 static void hfs_put_super(struct super_block *sb)
 {
-        cancel_delayed_work_sync(&HFS_SB(sb)->mdb_work);
+        if (sb->s_dirt)
+                hfs_write_super(sb);
         hfs_mdb_close(sb);
         /* release the MDB's resources */
         hfs_mdb_put(sb);
 }
 
-static void flush_mdb(struct work_struct *work)
-{
-        struct hfs_sb_info *sbi;
-        struct super_block *sb;
-
-        sbi = container_of(work, struct hfs_sb_info, mdb_work.work);
-        sb = sbi->sb;
-
-        spin_lock(&sbi->work_lock);
-        sbi->work_queued = 0;
-        spin_unlock(&sbi->work_lock);
-
-        hfs_mdb_commit(sb);
-}
-
-void hfs_mark_mdb_dirty(struct super_block *sb)
-{
-        struct hfs_sb_info *sbi = HFS_SB(sb);
-        unsigned long delay;
-
-        if (sb->s_flags & MS_RDONLY)
-                return;
-
-        spin_lock(&sbi->work_lock);
-        if (!sbi->work_queued) {
-                delay = msecs_to_jiffies(dirty_writeback_interval * 10);
-                queue_delayed_work(system_long_wq, &sbi->mdb_work, delay);
-                sbi->work_queued = 1;
-        }
-        spin_unlock(&sbi->work_lock);
-}
-
 /*
  * hfs_statfs()
  *
@@ -130,17 +133,15 @@ static int hfs_remount(struct super_block *sb, int *flags, char *data)
         return 0;
 }
 
-static int hfs_show_options(struct seq_file *seq, struct dentry *root)
+static int hfs_show_options(struct seq_file *seq, struct vfsmount *mnt)
 {
-        struct hfs_sb_info *sbi = HFS_SB(root->d_sb);
+        struct hfs_sb_info *sbi = HFS_SB(mnt->mnt_sb);
 
         if (sbi->s_creator != cpu_to_be32(0x3f3f3f3f))
                 seq_printf(seq, ",creator=%.4s", (char *)&sbi->s_creator);
         if (sbi->s_type != cpu_to_be32(0x3f3f3f3f))
                 seq_printf(seq, ",type=%.4s", (char *)&sbi->s_type);
-        seq_printf(seq, ",uid=%u,gid=%u",
-                        from_kuid_munged(&init_user_ns, sbi->s_uid),
-                        from_kgid_munged(&init_user_ns, sbi->s_gid));
+        seq_printf(seq, ",uid=%u,gid=%u", sbi->s_uid, sbi->s_gid);
         if (sbi->s_file_umask != 0133)
                 seq_printf(seq, ",file_umask=%o", sbi->s_file_umask);
         if (sbi->s_dir_umask != 0022)
@@ -169,6 +170,7 @@ static struct inode *hfs_alloc_inode(struct super_block *sb)
 static void hfs_i_callback(struct rcu_head *head)
 {
         struct inode *inode = container_of(head, struct inode, i_rcu);
+        INIT_LIST_HEAD(&inode->i_dentry);
         kmem_cache_free(hfs_inode_cachep, HFS_I(inode));
 }
 
@@ -183,6 +185,7 @@ static const struct super_operations hfs_super_operations = {
         .write_inode    = hfs_write_inode,
         .evict_inode    = hfs_evict_inode,
         .put_super      = hfs_put_super,
+        .write_super    = hfs_write_super,
         .sync_fs        = hfs_sync_fs,
         .statfs         = hfs_statfs,
         .remount_fs     = hfs_remount,
@@ -256,22 +259,14 @@ static int parse_options(char *options, struct hfs_sb_info *hsb)
                                 printk(KERN_ERR "hfs: uid requires an argument\n");
                                 return 0;
                         }
-                        hsb->s_uid = make_kuid(current_user_ns(), (uid_t)tmp);
-                        if (!uid_valid(hsb->s_uid)) {
-                                printk(KERN_ERR "hfs: invalid uid %d\n", tmp);
-                                return 0;
-                        }
+                        hsb->s_uid = (uid_t)tmp;
                         break;
                 case opt_gid:
                         if (match_int(&args[0], &tmp)) {
                                 printk(KERN_ERR "hfs: gid requires an argument\n");
                                 return 0;
                         }
-                        hsb->s_gid = make_kgid(current_user_ns(), (gid_t)tmp);
-                        if (!gid_valid(hsb->s_gid)) {
-                                printk(KERN_ERR "hfs: invalid gid %d\n", tmp);
-                                return 0;
-                        }
+                        hsb->s_gid = (gid_t)tmp;
                         break;
                 case opt_umask:
                         if (match_octal(&args[0], &tmp)) {
@@ -393,10 +388,7 @@ static int hfs_fill_super(struct super_block *sb, void *data, int silent)
         if (!sbi)
                 return -ENOMEM;
 
-        sbi->sb = sb;
         sb->s_fs_info = sbi;
-        spin_lock_init(&sbi->work_lock);
-        INIT_DELAYED_WORK(&sbi->mdb_work, flush_mdb);
 
         res = -EINVAL;
         if (!parse_options((char *)data, sbi)) {
@@ -439,13 +431,15 @@ static int hfs_fill_super(struct super_block *sb, void *data, int silent)
 
         sb->s_d_op = &hfs_dentry_operations;
         res = -ENOMEM;
-        sb->s_root = d_make_root(root_inode);
+        sb->s_root = d_alloc_root(root_inode);
         if (!sb->s_root)
-                goto bail_no_root;
+                goto bail_iput;
 
         /* everything's okay */
         return 0;
 
+bail_iput:
+        iput(root_inode);
 bail_no_root:
         printk(KERN_ERR "hfs: get root inode failed.\n");
 bail:
@@ -492,12 +486,6 @@ static int __init init_hfs_fs(void)
 static void __exit exit_hfs_fs(void)
 {
         unregister_filesystem(&hfs_fs_type);
-
-        /*
-         * Make sure all delayed rcu free inodes are flushed before we
-         * destroy cache.
-         */
-        rcu_barrier();
         kmem_cache_destroy(hfs_inode_cachep);
 }
 
diff --git a/fs/hfs/sysdep.c b/fs/hfs/sysdep.c
index 91b91fd3a90..19cf291eb91 100644
--- a/fs/hfs/sysdep.c
+++ b/fs/hfs/sysdep.c
@@ -13,12 +13,12 @@
 
 /* dentry case-handling: just lowercase everything */
 
-static int hfs_revalidate_dentry(struct dentry *dentry, unsigned int flags)
+static int hfs_revalidate_dentry(struct dentry *dentry, struct nameidata *nd)
 {
         struct inode *inode;
         int diff;
 
-        if (flags & LOOKUP_RCU)
+        if (nd->flags & LOOKUP_RCU)
                 return -ECHILD;
 
         inode = dentry->d_inode;