Merge branch 'linus' into perf/urgent

Merge reason: Fix upstream breakage introduced by:

 de5d9bf: Move list types from <linux/list.h> to <linux/types.h>.

Signed-off-by: Ingo Molnar <mingo@elte.hu>

8 files changed, 79 insertions, 87 deletions

diff --git a/fs/logfs/dir.c b/fs/logfs/dir.c
index 72d1893ddd36..675cc49197fe 100644
--- a/fs/logfs/dir.c
+++ b/fs/logfs/dir.c
@@ -434,8 +434,11 @@ static int __logfs_create(struct inode *dir, struct dentry *dentry,
         int ret;
 
         ta = kzalloc(sizeof(*ta), GFP_KERNEL);
-        if (!ta)
+        if (!ta) {
+                inode->i_nlink--;
+                iput(inode);
                 return -ENOMEM;
+        }
 
         ta->state = CREATE_1;
         ta->ino = inode->i_ino;
diff --git a/fs/logfs/file.c b/fs/logfs/file.c
index abe1cafbd4c2..4dd0f7c06e39 100644
--- a/fs/logfs/file.c
+++ b/fs/logfs/file.c
@@ -232,15 +232,19 @@ static int logfs_setattr(struct dentry *dentry, struct iattr *attr)
         struct inode *inode = dentry->d_inode;
         int err = 0;
 
-        if (attr->ia_valid & ATTR_SIZE)
+        err = inode_change_ok(inode, attr);
+        if (err)
+                return err;
+
+        if (attr->ia_valid & ATTR_SIZE) {
                 err = logfs_truncate(inode, attr->ia_size);
-        attr->ia_valid &= ~ATTR_SIZE;
+                if (err)
+                        return err;
+        }
 
-        if (!err)
-                err = inode_change_ok(inode, attr);
-        if (!err)
-                err = inode_setattr(inode, attr);
-        return err;
+        setattr_copy(inode, attr);
+        mark_inode_dirty(inode);
+        return 0;
 }
 
 const struct inode_operations logfs_reg_iops = {
diff --git a/fs/logfs/inode.c b/fs/logfs/inode.c
index f602e230e162..d8c71ece098f 100644
--- a/fs/logfs/inode.c
+++ b/fs/logfs/inode.c
@@ -235,33 +235,21 @@ static struct inode *logfs_alloc_inode(struct super_block *sb)
  * purpose is to create a new inode that will not trigger the warning if such
  * an inode is still in use.  An ugly hack, no doubt.  Suggections for
  * improvement are welcome.
+ *
+ * AV: that's what ->put_super() is for...
  */
 struct inode *logfs_new_meta_inode(struct super_block *sb, u64 ino)
 {
         struct inode *inode;
 
-        inode = logfs_alloc_inode(sb);
+        inode = new_inode(sb);
         if (!inode)
                 return ERR_PTR(-ENOMEM);
 
         inode->i_mode = S_IFREG;
         inode->i_ino = ino;
-        inode->i_sb = sb;
-
-        /* This is a blatant copy of alloc_inode code.  We'd need alloc_inode
-         * to be nonstatic, alas. */
-        {
-                struct address_space * const mapping = &inode->i_data;
-
-                mapping->a_ops = &logfs_reg_aops;
-                mapping->host = inode;
-                mapping->flags = 0;
-                mapping_set_gfp_mask(mapping, GFP_NOFS);
-                mapping->assoc_mapping = NULL;
-                mapping->backing_dev_info = &default_backing_dev_info;
-                inode->i_mapping = mapping;
-                inode->i_nlink = 1;
-        }
+        inode->i_data.a_ops = &logfs_reg_aops;
+        mapping_set_gfp_mask(&inode->i_data, GFP_NOFS);
 
         return inode;
 }
@@ -277,7 +265,7 @@ struct inode *logfs_read_meta_inode(struct super_block *sb, u64 ino)
 
         err = logfs_read_inode(inode);
         if (err) {
-                destroy_meta_inode(inode);
+                iput(inode);
                 return ERR_PTR(err);
         }
         logfs_inode_setops(inode);
@@ -298,18 +286,8 @@ static int logfs_write_inode(struct inode *inode, struct writeback_control *wbc)
         return ret;
 }
 
-void destroy_meta_inode(struct inode *inode)
-{
-        if (inode) {
-                if (inode->i_data.nrpages)
-                        truncate_inode_pages(&inode->i_data, 0);
-                logfs_clear_inode(inode);
-                kmem_cache_free(logfs_inode_cache, logfs_inode(inode));
-        }
-}
-
 /* called with inode_lock held */
-static void logfs_drop_inode(struct inode *inode)
+static int logfs_drop_inode(struct inode *inode)
 {
         struct logfs_super *super = logfs_super(inode->i_sb);
         struct logfs_inode *li = logfs_inode(inode);
@@ -317,7 +295,7 @@ static void logfs_drop_inode(struct inode *inode)
         spin_lock(&logfs_inode_lock);
         list_move(&li->li_freeing_list, &super->s_freeing_list);
         spin_unlock(&logfs_inode_lock);
-        generic_drop_inode(inode);
+        return generic_drop_inode(inode);
 }
 
 static void logfs_set_ino_generation(struct super_block *sb,
@@ -384,12 +362,21 @@ static int logfs_sync_fs(struct super_block *sb, int wait)
         return 0;
 }
 
+static void logfs_put_super(struct super_block *sb)
+{
+        struct logfs_super *super = logfs_super(sb);
+        /* kill the meta-inodes */
+        iput(super->s_master_inode);
+        iput(super->s_segfile_inode);
+        iput(super->s_mapping_inode);
+}
+
 const struct super_operations logfs_super_operations = {
         .alloc_inode    = logfs_alloc_inode,
-        .clear_inode    = logfs_clear_inode,
-        .delete_inode   = logfs_delete_inode,
         .destroy_inode  = logfs_destroy_inode,
+        .evict_inode    = logfs_evict_inode,
         .drop_inode     = logfs_drop_inode,
+        .put_super      = logfs_put_super,
         .write_inode    = logfs_write_inode,
         .statfs         = logfs_statfs,
         .sync_fs        = logfs_sync_fs,
diff --git a/fs/logfs/journal.c b/fs/logfs/journal.c
index 4b0e0616b357..f46ee8b0e135 100644
--- a/fs/logfs/journal.c
+++ b/fs/logfs/journal.c
@@ -889,8 +889,6 @@ void logfs_cleanup_journal(struct super_block *sb)
         struct logfs_super *super = logfs_super(sb);
 
         btree_grim_visitor32(&super->s_reserved_segments, 0, NULL);
-        destroy_meta_inode(super->s_master_inode);
-        super->s_master_inode = NULL;
 
         kfree(super->s_compressed_je);
         kfree(super->s_je);
diff --git a/fs/logfs/logfs.h b/fs/logfs/logfs.h
index c838c4d72111..5e3b72077951 100644
--- a/fs/logfs/logfs.h
+++ b/fs/logfs/logfs.h
@@ -525,13 +525,11 @@ struct inode *logfs_new_meta_inode(struct super_block *sb, u64 ino);
 struct inode *logfs_read_meta_inode(struct super_block *sb, u64 ino);
 int logfs_init_inode_cache(void);
 void logfs_destroy_inode_cache(void);
-void destroy_meta_inode(struct inode *inode);
 void logfs_set_blocks(struct inode *inode, u64 no);
 /* these logically belong into inode.c but actually reside in readwrite.c */
 int logfs_read_inode(struct inode *inode);
 int __logfs_write_inode(struct inode *inode, long flags);
-void logfs_delete_inode(struct inode *inode);
-void logfs_clear_inode(struct inode *inode);
+void logfs_evict_inode(struct inode *inode);
 
 /* journal.c */
 void logfs_write_anchor(struct super_block *sb);
diff --git a/fs/logfs/readwrite.c b/fs/logfs/readwrite.c
index 0718d112a1a5..6127baf0e188 100644
--- a/fs/logfs/readwrite.c
+++ b/fs/logfs/readwrite.c
@@ -1972,31 +1972,6 @@ static struct page *inode_to_page(struct inode *inode)
         return page;
 }
 
-/* Cheaper version of write_inode.  All changes are concealed in
- * aliases, which are moved back.  No write to the medium happens.
- */
-void logfs_clear_inode(struct inode *inode)
-{
-        struct super_block *sb = inode->i_sb;
-        struct logfs_inode *li = logfs_inode(inode);
-        struct logfs_block *block = li->li_block;
-        struct page *page;
-
-        /* Only deleted files may be dirty at this point */
-        BUG_ON(inode->i_state & I_DIRTY && inode->i_nlink);
-        if (!block)
-                return;
-        if ((logfs_super(sb)->s_flags & LOGFS_SB_FLAG_SHUTDOWN)) {
-                block->ops->free_block(inode->i_sb, block);
-                return;
-        }
-
-        BUG_ON(inode->i_ino < LOGFS_RESERVED_INOS);
-        page = inode_to_page(inode);
-        BUG_ON(!page); /* FIXME: Use emergency page */
-        logfs_put_write_page(page);
-}
-
 static int do_write_inode(struct inode *inode)
 {
         struct super_block *sb = inode->i_sb;
@@ -2164,18 +2139,40 @@ static int do_delete_inode(struct inode *inode)
  * ZOMBIE inodes have already been deleted before and should remain dead,
  * if it weren't for valid checking.  No need to kill them again here.
  */
-void logfs_delete_inode(struct inode *inode)
+void logfs_evict_inode(struct inode *inode)
 {
+        struct super_block *sb = inode->i_sb;
         struct logfs_inode *li = logfs_inode(inode);
+        struct logfs_block *block = li->li_block;
+        struct page *page;
 
-        if (!(li->li_flags & LOGFS_IF_ZOMBIE)) {
-                li->li_flags |= LOGFS_IF_ZOMBIE;
-                if (i_size_read(inode) > 0)
-                        logfs_truncate(inode, 0);
-                do_delete_inode(inode);
+        if (!inode->i_nlink) {
+                if (!(li->li_flags & LOGFS_IF_ZOMBIE)) {
+                        li->li_flags |= LOGFS_IF_ZOMBIE;
+                        if (i_size_read(inode) > 0)
+                                logfs_truncate(inode, 0);
+                        do_delete_inode(inode);
+                }
         }
         truncate_inode_pages(&inode->i_data, 0);
-        clear_inode(inode);
+        end_writeback(inode);
+
+        /* Cheaper version of write_inode.  All changes are concealed in
+         * aliases, which are moved back.  No write to the medium happens.
+         */
+        /* Only deleted files may be dirty at this point */
+        BUG_ON(inode->i_state & I_DIRTY && inode->i_nlink);
+        if (!block)
+                return;
+        if ((logfs_super(sb)->s_flags & LOGFS_SB_FLAG_SHUTDOWN)) {
+                block->ops->free_block(inode->i_sb, block);
+                return;
+        }
+
+        BUG_ON(inode->i_ino < LOGFS_RESERVED_INOS);
+        page = inode_to_page(inode);
+        BUG_ON(!page); /* FIXME: Use emergency page */
+        logfs_put_write_page(page);
 }
 
 void btree_write_block(struct logfs_block *block)
@@ -2272,7 +2269,6 @@ void logfs_cleanup_rw(struct super_block *sb)
 {
         struct logfs_super *super = logfs_super(sb);
 
-        destroy_meta_inode(super->s_segfile_inode);
         logfs_mempool_destroy(super->s_block_pool);
         logfs_mempool_destroy(super->s_shadow_pool);
 }
diff --git a/fs/logfs/segment.c b/fs/logfs/segment.c
index a9657afb70ad..9d5187353255 100644
--- a/fs/logfs/segment.c
+++ b/fs/logfs/segment.c
@@ -929,5 +929,4 @@ void logfs_cleanup_areas(struct super_block *sb)
         for_each_area(i)
                 free_area(super->s_area[i]);
         free_area(super->s_journal_area);
-        destroy_meta_inode(super->s_mapping_inode);
 }
diff --git a/fs/logfs/super.c b/fs/logfs/super.c
index d651e10a1e9c..5336155c5d81 100644
--- a/fs/logfs/super.c
+++ b/fs/logfs/super.c
@@ -342,24 +342,27 @@ static int logfs_get_sb_final(struct super_block *sb, struct vfsmount *mnt)
                 goto fail;
         }
 
+        /* at that point we know that ->put_super() will be called */
         super->s_erase_page = alloc_pages(GFP_KERNEL, 0);
         if (!super->s_erase_page)
-                goto fail;
+                return -ENOMEM;
         memset(page_address(super->s_erase_page), 0xFF, PAGE_SIZE);
 
         /* FIXME: check for read-only mounts */
         err = logfs_make_writeable(sb);
-        if (err)
-                goto fail1;
+        if (err) {
+                __free_page(super->s_erase_page);
+                return err;
+        }
 
         log_super("LogFS: Finished mounting\n");
         simple_set_mnt(mnt, sb);
         return 0;
 
-fail1:
-        __free_page(super->s_erase_page);
 fail:
-        iput(logfs_super(sb)->s_master_inode);
+        iput(super->s_master_inode);
+        iput(super->s_segfile_inode);
+        iput(super->s_mapping_inode);
         return -EIO;
 }
 
@@ -580,10 +583,14 @@ int logfs_get_sb_device(struct file_system_type *type, int flags,
         sb->s_flags |= MS_ACTIVE;
         err = logfs_get_sb_final(sb, mnt);
         if (err)
-                goto err1;
-        return 0;
+                deactivate_locked_super(sb);
+        return err;
 
 err1:
+        /* no ->s_root, no ->put_super() */
+        iput(super->s_master_inode);
+        iput(super->s_segfile_inode);
+        iput(super->s_mapping_inode);
         deactivate_locked_super(sb);
         return err;
 err0: