52 files changed, 203 insertions, 96 deletions
diff --git a/arch/powerpc/platforms/cell/spufs/file.c b/arch/powerpc/platforms/cell/spufs/file.c
index 64a4c2d85f7c..f078fe70d3cd 100644
--- a/arch/powerpc/platforms/cell/spufs/file.c
+++ b/arch/powerpc/platforms/cell/spufs/file.c
@@ -1548,7 +1548,7 @@ static int spufs_mfc_open(struct inode *inode, struct file *file)
        if (ctx->owner != current->mm)
                return -EINVAL;
-        if (atomic_read(&inode->i_count) != 1)
+        if (inode->i_count != 1)
                return -EBUSY;
        mutex_lock(&ctx->mapping_lock);
diff --git a/fs/affs/inode.c b/fs/affs/inode.c
index 3c4ec7d864c4..9af06f0b355c 100644
--- a/fs/affs/inode.c
+++ b/fs/affs/inode.c
@@ -379,7 +379,9 @@ affs_add_entry(struct inode *dir, struct inode *inode, struct dentry *dentry, s3
                affs_adjust_checksum(inode_bh, block - be32_to_cpu(chain));
                mark_buffer_dirty_inode(inode_bh, inode);
                inode->i_nlink = 2;
-                atomic_inc(&inode->i_count);
+                spin_lock(&inode->i_lock);
+                inode->i_count++;
+                spin_unlock(&inode->i_lock);
        }
        affs_fix_checksum(sb, bh);
        mark_buffer_dirty_inode(bh, inode);
diff --git a/fs/afs/dir.c b/fs/afs/dir.c
index 88067f36e5e7..88106a018440 100644
--- a/fs/afs/dir.c
+++ b/fs/afs/dir.c
@@ -1007,7 +1007,9 @@ static int afs_link(struct dentry *from, struct inode *dir,
        if (ret < 0)
                goto link_error;
-        atomic_inc(&vnode->vfs_inode.i_count);
+        spin_lock(&vnode->vfs_inode.i_lock);
+        vnode->vfs_inode.i_count++;
+        spin_unlock(&vnode->vfs_inode.i_lock);
        d_instantiate(dentry, &vnode->vfs_inode);
        key_put(key);
        _leave(" = 0");
diff --git a/fs/anon_inodes.c b/fs/anon_inodes.c
index 9f0bf13291e5..81f82e7e7290 100644
--- a/fs/anon_inodes.c
+++ b/fs/anon_inodes.c
@@ -115,7 +115,9 @@ struct file *anon_inode_getfile(const char *name,
         * so we can avoid doing an igrab() and we can use an open-coded
         * atomic_inc().
         */
-        atomic_inc(&anon_inode_inode->i_count);
+        spin_lock(&anon_inode_inode->i_lock);
+        anon_inode_inode->i_count++;
+        spin_unlock(&anon_inode_inode->i_lock);
        path.dentry->d_op = &anon_inodefs_dentry_operations;
        d_instantiate(path.dentry, anon_inode_inode);
diff --git a/fs/bfs/dir.c b/fs/bfs/dir.c
index 1e41aadb1068..a822829df2f2 100644
--- a/fs/bfs/dir.c
+++ b/fs/bfs/dir.c
@@ -178,7 +178,9 @@ static int bfs_link(struct dentry *old, struct inode *dir,
        inc_nlink(inode);
        inode->i_ctime = CURRENT_TIME_SEC;
        mark_inode_dirty(inode);
-        atomic_inc(&inode->i_count);
+        spin_lock(&inode->i_lock);
+        inode->i_count++;
+        spin_unlock(&inode->i_lock);
        d_instantiate(new, inode);
        mutex_unlock(&info->bfs_lock);
        return 0;
diff --git a/fs/block_dev.c b/fs/block_dev.c
index 8db62b2b6df8..bf503be689c3 100644
--- a/fs/block_dev.c
+++ b/fs/block_dev.c
@@ -587,7 +587,12 @@ EXPORT_SYMBOL(bdget);
 */
 struct block_device *bdgrab(struct block_device *bdev)
 {
-        atomic_inc(&bdev->bd_inode->i_count);
+        struct inode *inode = bdev->bd_inode;
+        spin_lock(&inode->i_lock);
+        inode->i_count++;
+        spin_unlock(&inode->i_lock);
        return bdev;
 }
@@ -617,7 +622,9 @@ static struct block_device *bd_acquire(struct inode *inode)
        spin_lock(&bdev_lock);
        bdev = inode->i_bdev;
        if (bdev) {
-                atomic_inc(&bdev->bd_inode->i_count);
+                spin_lock(&inode->i_lock);
+                bdev->bd_inode->i_count++;
+                spin_unlock(&inode->i_lock);
                spin_unlock(&bdev_lock);
                return bdev;
        }
@@ -633,7 +640,9 @@ static struct block_device *bd_acquire(struct inode *inode)
                         * So, we can access it via ->i_mapping always
                         * without igrab().
                         */
-                        atomic_inc(&bdev->bd_inode->i_count);
+                        spin_lock(&inode->i_lock);
+                        bdev->bd_inode->i_count++;
+                        spin_unlock(&inode->i_lock);
                        inode->i_bdev = bdev;
                        inode->i_mapping = bdev->bd_inode->i_mapping;
                        list_add(&inode->i_devices, &bdev->bd_inodes);
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 4deb280f8969..9dcc771ff485 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -4446,7 +4446,9 @@ static int btrfs_link(struct dentry *old_dentry, struct inode *dir,
        trans = btrfs_start_transaction(root, 1);
        btrfs_set_trans_block_group(trans, dir);
-        atomic_inc(&inode->i_count);
+        spin_lock(&inode->i_lock);
+        inode->i_count++;
+        spin_unlock(&inode->i_lock);
        err = btrfs_add_nondir(trans, dentry, inode, 1, index);
diff --git a/fs/cifs/inode.c b/fs/cifs/inode.c
index e3fda978f481..d7346de1049a 100644
--- a/fs/cifs/inode.c
+++ b/fs/cifs/inode.c
@@ -1425,7 +1425,7 @@ int cifs_revalidate(struct dentry *direntry)
        }
        cFYI(1, ("Revalidate: %s inode 0x%p count %d dentry: 0x%p d_time %ld "
                 "jiffies %ld", full_path, direntry->d_inode,
-                 direntry->d_inode->i_count.counter, direntry,
+                 direntry->d_inode->i_count, direntry,
                 direntry->d_time, jiffies));
        if (cifsInode->time == 0) {
diff --git a/fs/coda/dir.c b/fs/coda/dir.c
index 397d0f598553..ee3410542b72 100644
--- a/fs/coda/dir.c
+++ b/fs/coda/dir.c
@@ -302,7 +302,9 @@ static int coda_link(struct dentry *source_de, struct inode *dir_inode,
        }
        coda_dir_update_mtime(dir_inode);
-        atomic_inc(&inode->i_count);
+        spin_lock(&inode->i_lock);
+        inode->i_count++;
+        spin_unlock(&inode->i_lock);
        d_instantiate(de, inode);
        inc_nlink(inode);
diff --git a/fs/exofs/inode.c b/fs/exofs/inode.c
index 2afbcebeda71..44fcbf48c01f 100644
--- a/fs/exofs/inode.c
+++ b/fs/exofs/inode.c
@@ -1054,7 +1054,9 @@ static void create_done(struct exofs_io_state *ios, void *p)
        set_obj_created(oi);
-        atomic_dec(&inode->i_count);
+        spin_lock(&inode->i_lock);
+        inode->i_count--;
+        spin_unlock(&inode->i_lock);
        wake_up(&oi->i_wq);
 }
@@ -1116,14 +1118,18 @@ struct inode *exofs_new_inode(struct inode *dir, int mode)
        /* increment the refcount so that the inode will still be around when we
         * reach the callback
         */
-        atomic_inc(&inode->i_count);
+        spin_lock(&inode->i_lock);
+        inode->i_count++;
+        spin_unlock(&inode->i_lock);
        ios->done = create_done;
        ios->private = inode;
        ios->cred = oi->i_cred;
        ret = exofs_sbi_create(ios);
        if (ret) {
-                atomic_dec(&inode->i_count);
+                spin_lock(&inode->i_lock);
+                inode->i_count--;
+                spin_unlock(&inode->i_lock);
                exofs_put_io_state(ios);
                return ERR_PTR(ret);
        }
diff --git a/fs/exofs/namei.c b/fs/exofs/namei.c
index b7dd0c236863..506778ac4fcd 100644
--- a/fs/exofs/namei.c
+++ b/fs/exofs/namei.c
@@ -153,7 +153,9 @@ static int exofs_link(struct dentry *old_dentry, struct inode *dir,
        inode->i_ctime = CURRENT_TIME;
        inode_inc_link_count(inode);
-        atomic_inc(&inode->i_count);
+        spin_lock(&inode->i_lock);
+        inode->i_count++;
+        spin_unlock(&inode->i_lock);
        return exofs_add_nondir(dentry, inode);
 }
diff --git a/fs/ext2/namei.c b/fs/ext2/namei.c
index dd7175ce5606..34259ac72cef 100644
--- a/fs/ext2/namei.c
+++ b/fs/ext2/namei.c
@@ -196,7 +196,9 @@ static int ext2_link (struct dentry * old_dentry, struct inode * dir,
        inode->i_ctime = CURRENT_TIME_SEC;
        inode_inc_link_count(inode);
-        atomic_inc(&inode->i_count);
+        spin_lock(&inode->i_lock);
+        inode->i_count++;
+        spin_unlock(&inode->i_lock);
        err = ext2_add_link(dentry, inode);
        if (!err) {
diff --git a/fs/ext3/ialloc.c b/fs/ext3/ialloc.c
index b39991285136..2b40cffa2432 100644
--- a/fs/ext3/ialloc.c
+++ b/fs/ext3/ialloc.c
@@ -100,9 +100,9 @@ void ext3_free_inode (handle_t *handle, struct inode * inode)
        struct ext3_sb_info *sbi;
        int fatal = 0, err;
-        if (atomic_read(&inode->i_count) > 1) {
+        if (inode->i_count > 1) {
                printk ("ext3_free_inode: inode has count=%d\n",
-                                        atomic_read(&inode->i_count));
+                                        inode->i_count);
                return;
        }
        if (inode->i_nlink) {
diff --git a/fs/ext3/namei.c b/fs/ext3/namei.c
index 7b0e44f7d66f..ee6676c11b5c 100644
--- a/fs/ext3/namei.c
+++ b/fs/ext3/namei.c
@@ -2246,7 +2246,9 @@ retry:
        inode->i_ctime = CURRENT_TIME_SEC;
        inc_nlink(inode);
-        atomic_inc(&inode->i_count);
+        spin_lock(&inode->i_lock);
+        inode->i_count++;
+        spin_unlock(&inode->i_lock);
        err = ext3_add_entry(handle, dentry, inode);
        if (!err) {
diff --git a/fs/ext4/ialloc.c b/fs/ext4/ialloc.c
index f3624ead4f6c..8297fad406c6 100644
--- a/fs/ext4/ialloc.c
+++ b/fs/ext4/ialloc.c
@@ -192,9 +192,9 @@ void ext4_free_inode(handle_t *handle, struct inode *inode)
        struct ext4_sb_info *sbi;
        int fatal = 0, err, count, cleared;
-        if (atomic_read(&inode->i_count) > 1) {
+        if (inode->i_count > 1) {
                printk(KERN_ERR "ext4_free_inode: inode has count=%d\n",
-                       atomic_read(&inode->i_count));
+                       inode->i_count);
                return;
        }
        if (inode->i_nlink) {
diff --git a/fs/ext4/namei.c b/fs/ext4/namei.c
index 17a17e10dd60..70150b6f09a2 100644
--- a/fs/ext4/namei.c
+++ b/fs/ext4/namei.c
@@ -2326,7 +2326,9 @@ retry:
        inode->i_ctime = ext4_current_time(inode);
        ext4_inc_count(handle, inode);
-        atomic_inc(&inode->i_count);
+        spin_lock(&inode->i_lock);
+        inode->i_count++;
+        spin_unlock(&inode->i_lock);
        err = ext4_add_entry(handle, dentry, inode);
        if (!err) {
diff --git a/fs/fs-writeback.c b/fs/fs-writeback.c
index 8d57f0e14ebb..1e9ead755050 100644
--- a/fs/fs-writeback.c
+++ b/fs/fs-writeback.c
@@ -427,7 +427,7 @@ writeback_single_inode(struct inode *inode, struct writeback_control *wbc)
        unsigned dirty;
        int ret;
-        if (!atomic_read(&inode->i_count))
+        if (!inode->i_count)
                WARN_ON(!(inode->i_state & (I_WILL_FREE|I_FREEING)));
        else
                WARN_ON(inode->i_state & I_WILL_FREE);
@@ -537,7 +537,7 @@ select_queue:
                                inode->i_state |= I_DIRTY_PAGES;
                                redirty_tail(inode);
                        }
-                } else if (atomic_read(&inode->i_count)) {
+                } else if (inode->i_count) {
                        /*
                         * The inode is clean, inuse
                         */
diff --git a/fs/gfs2/ops_inode.c b/fs/gfs2/ops_inode.c
index 84350e1be66d..f5a07d98ec06 100644
--- a/fs/gfs2/ops_inode.c
+++ b/fs/gfs2/ops_inode.c
@@ -253,7 +253,9 @@ out_parent:
        gfs2_holder_uninit(ghs);
        gfs2_holder_uninit(ghs + 1);
        if (!error) {
-                atomic_inc(&inode->i_count);
+                spin_lock(&inode->i_lock);
+                inode->i_count++;
+                spin_unlock(&inode->i_lock);
                d_instantiate(dentry, inode);
                mark_inode_dirty(inode);
        }
diff --git a/fs/hfsplus/dir.c b/fs/hfsplus/dir.c
index 5f4023678251..557c5335de66 100644
--- a/fs/hfsplus/dir.c
+++ b/fs/hfsplus/dir.c
@@ -301,7 +301,9 @@ static int hfsplus_link(struct dentry *src_dentry, struct inode *dst_dir,
        inc_nlink(inode);
        hfsplus_instantiate(dst_dentry, inode, cnid);
-        atomic_inc(&inode->i_count);
+        spin_lock(&inode->i_lock);
+        inode->i_count++;
+        spin_unlock(&inode->i_lock);
        inode->i_ctime = CURRENT_TIME_SEC;
        mark_inode_dirty(inode);
        HFSPLUS_SB(sb).file_count++;
diff --git a/fs/hpfs/inode.c b/fs/hpfs/inode.c
index fe703ae46bc7..b22044cb988b 100644
--- a/fs/hpfs/inode.c
+++ b/fs/hpfs/inode.c
@@ -182,7 +182,7 @@ void hpfs_write_inode(struct inode *i)
        struct hpfs_inode_info *hpfs_inode = hpfs_i(i);
        struct inode *parent;
        if (i->i_ino == hpfs_sb(i->i_sb)->sb_root) return;
-        if (hpfs_inode->i_rddir_off && !atomic_read(&i->i_count)) {
+        if (hpfs_inode->i_rddir_off && !i->i_count) {
                if (*hpfs_inode->i_rddir_off) printk("HPFS: write_inode: some position still there\n");
                kfree(hpfs_inode->i_rddir_off);
                hpfs_inode->i_rddir_off = NULL;
diff --git a/fs/inode.c b/fs/inode.c
index a1f5c2fa1d4a..99d664bafe9f 100644
--- a/fs/inode.c
+++ b/fs/inode.c
@@ -136,7 +136,7 @@ int inode_init_always(struct super_block *sb, struct inode *inode)
        inode->i_sb = sb;
        inode->i_blkbits = sb->s_blocksize_bits;
        inode->i_flags = 0;
-        atomic_set(&inode->i_count, 1);
+        inode->i_count = 1;
        inode->i_op = &empty_iops;
        inode->i_fop = &empty_fops;
        inode->i_nlink = 1;
@@ -290,11 +290,10 @@ static void init_once(void *foo)
 void __iget(struct inode *inode)
 {
        assert_spin_locked(&inode->i_lock);
-        if (atomic_read(&inode->i_count)) {
+        inode->i_count++;
-                atomic_inc(&inode->i_count);
+        if (inode->i_count > 1)
                return;
-        }
-        atomic_inc(&inode->i_count);
        if (!(inode->i_state & (I_DIRTY|I_SYNC)))
                list_move(&inode->i_list, &inode_in_use);
        inodes_stat.nr_unused--;
@@ -399,7 +398,7 @@ static int invalidate_list(struct list_head *head, struct list_head *dispose)
                        continue;
                }
                invalidate_inode_buffers(inode);
-                if (!atomic_read(&inode->i_count)) {
+                if (!inode->i_count) {
                        list_move(&inode->i_list, dispose);
                        WARN_ON(inode->i_state & I_NEW);
                        inode->i_state |= I_FREEING;
@@ -450,7 +449,7 @@ static int can_unuse(struct inode *inode)
                return 0;
        if (inode_has_buffers(inode))
                return 0;
-        if (atomic_read(&inode->i_count))
+        if (inode->i_count)
                return 0;
        if (inode->i_data.nrpages)
                return 0;
@@ -488,7 +487,7 @@ static void prune_icache(int nr_to_scan)
                inode = list_entry(inode_unused.prev, struct inode, i_list);
                spin_lock(&inode->i_lock);
-                if (inode->i_state || atomic_read(&inode->i_count)) {
+                if (inode->i_state || inode->i_count) {
                        list_move(&inode->i_list, &inode_unused);
                        spin_unlock(&inode->i_lock);
                        continue;
@@ -1277,8 +1276,6 @@ void generic_delete_inode(struct inode *inode)
 {
        const struct super_operations *op = inode->i_sb->s_op;
-        spin_lock(&sb_inode_list_lock);
-        spin_lock(&inode->i_lock);
        list_del_init(&inode->i_list);
        list_del_init(&inode->i_sb_list);
        spin_unlock(&sb_inode_list_lock);
@@ -1327,8 +1324,6 @@ int generic_detach_inode(struct inode *inode)
 {
        struct super_block *sb = inode->i_sb;
-        spin_lock(&sb_inode_list_lock);
-        spin_lock(&inode->i_lock);
        if (!hlist_unhashed(&inode->i_hash)) {
                if (!(inode->i_state & (I_DIRTY|I_SYNC)))
                        list_move(&inode->i_list, &inode_unused);
@@ -1427,8 +1422,24 @@ void iput(struct inode *inode)
        if (inode) {
                BUG_ON(inode->i_state == I_CLEAR);
-                if (atomic_dec_and_lock(&inode->i_count, &inode_lock))
+retry:
+                spin_lock(&inode->i_lock);
+                if (inode->i_count == 1) {
+                        if (!spin_trylock(&inode_lock)) {
+                                spin_unlock(&inode->i_lock);
+                                goto retry;
+                        }
+                        if (!spin_trylock(&sb_inode_list_lock)) {
+                                spin_unlock(&inode_lock);
+                                spin_unlock(&inode->i_lock);
+                                goto retry;
+                        }
+                        inode->i_count--;
                        iput_final(inode);
+                } else {
+                        inode->i_count--;
+                        spin_unlock(&inode->i_lock);
+                }
        }
 }
 EXPORT_SYMBOL(iput);
diff --git a/fs/jffs2/dir.c b/fs/jffs2/dir.c
index 7aa4417e085f..40bc1705fa05 100644
--- a/fs/jffs2/dir.c
+++ b/fs/jffs2/dir.c
@@ -287,7 +287,9 @@ static int jffs2_link (struct dentry *old_dentry, struct inode *dir_i, struct de
                mutex_unlock(&f->sem);
                d_instantiate(dentry, old_dentry->d_inode);
                dir_i->i_mtime = dir_i->i_ctime = ITIME(now);
-                atomic_inc(&old_dentry->d_inode->i_count);
+                spin_lock(&old_dentry->d_inode->i_lock);
+                old_dentry->d_inode->i_count++;
+                spin_unlock(&old_dentry->d_inode->i_lock);
        }
        return ret;
 }
@@ -866,7 +868,9 @@ static int jffs2_rename (struct inode *old_dir_i, struct dentry *old_dentry,
                printk(KERN_NOTICE "jffs2_rename(): Link succeeded, unlink failed (err %d). You now have a hard link\n", ret);
                /* Might as well let the VFS know */
                d_instantiate(new_dentry, old_dentry->d_inode);
-                atomic_inc(&old_dentry->d_inode->i_count);
+                spin_lock(&old_dentry->d_inode->i_lock);
+                old_dentry->d_inode->i_count++;
+                spin_unlock(&old_dentry->d_inode->i_lock);
                new_dir_i->i_mtime = new_dir_i->i_ctime = ITIME(now);
                return ret;
        }
diff --git a/fs/jfs/jfs_txnmgr.c b/fs/jfs/jfs_txnmgr.c
index d945ea76b445..820212f3fc88 100644
--- a/fs/jfs/jfs_txnmgr.c
+++ b/fs/jfs/jfs_txnmgr.c
@@ -1279,7 +1279,9 @@ int txCommit(tid_t tid,		/* transaction identifier */
         * lazy commit thread finishes processing
         */
        if (tblk->xflag & COMMIT_DELETE) {
-                atomic_inc(&tblk->u.ip->i_count);
+                spin_lock(&tblk->u.ip->i_lock);
+                tblk->u.ip->i_count++;
+                spin_unlock(&tblk->u.ip->i_lock);
                /*
                 * Avoid a rare deadlock
                 *
diff --git a/fs/jfs/namei.c b/fs/jfs/namei.c
index c79a4270f083..8fa6219d0eeb 100644
--- a/fs/jfs/namei.c
+++ b/fs/jfs/namei.c
@@ -831,7 +831,9 @@ static int jfs_link(struct dentry *old_dentry,
        ip->i_ctime = CURRENT_TIME;
        dir->i_ctime = dir->i_mtime = CURRENT_TIME;
        mark_inode_dirty(dir);
-        atomic_inc(&ip->i_count);
+        spin_lock(&ip->i_lock);
+        ip->i_count++;
+        spin_unlock(&ip->i_lock);
        iplist[0] = ip;
        iplist[1] = dir;
diff --git a/fs/libfs.c b/fs/libfs.c
index 47e587e0e694..e8a7923a9fbb 100644
--- a/fs/libfs.c
+++ b/fs/libfs.c
@@ -280,7 +280,9 @@ int simple_link(struct dentry *old_dentry, struct inode *dir, struct dentry *den
        inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME;
        inc_nlink(inode);
-        atomic_inc(&inode->i_count);
+        spin_lock(&inode->i_lock);
+        inode->i_count++;
+        spin_unlock(&inode->i_lock);
        dget(dentry);
        d_instantiate(dentry, inode);
        return 0;
diff --git a/fs/locks.c b/fs/locks.c
index 66ac25aab803..0e074d5417b0 100644
--- a/fs/locks.c
+++ b/fs/locks.c
@@ -1374,8 +1374,7 @@ int generic_setlease(struct file *filp, long arg, struct file_lock **flp)
                if ((arg == F_RDLCK) && (atomic_read(&inode->i_writecount) > 0))
                        goto out;
                if ((arg == F_WRLCK)
-                    && (dentry->d_count > 1
+                    && (dentry->d_count > 1 || inode->i_count > 1))
-                        || (atomic_read(&inode->i_count) > 1)))
                        goto out;
        }
diff --git a/fs/minix/namei.c b/fs/minix/namei.c
index 32b131cd6121..1b0b9f081ffa 100644
--- a/fs/minix/namei.c
+++ b/fs/minix/namei.c
@@ -103,7 +103,9 @@ static int minix_link(struct dentry * old_dentry, struct inode * dir,
        inode->i_ctime = CURRENT_TIME_SEC;
        inode_inc_link_count(inode);
-        atomic_inc(&inode->i_count);
+        spin_lock(&inode->i_lock);
+        inode->i_count++;
+        spin_unlock(&inode->i_lock);
        return add_nondir(dentry, inode);
 }
diff --git a/fs/namei.c b/fs/namei.c
index 69e79576c899..157d4e4fc9f9 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -2317,8 +2317,11 @@ static long do_unlinkat(int dfd, const char __user *pathname)
                if (nd.last.name[nd.last.len])
                        goto slashes;
                inode = dentry->d_inode;
-                if (inode)
+                if (inode) {
-                        atomic_inc(&inode->i_count);
+                        spin_lock(&inode->i_lock);
+                        inode->i_count++;
+                        spin_unlock(&inode->i_lock);
+                }
                error = mnt_want_write(nd.path.mnt);
                if (error)
                        goto exit2;
diff --git a/fs/nfs/dir.c b/fs/nfs/dir.c
index a2538cf79fc9..6527b589d5b2 100644
--- a/fs/nfs/dir.c
+++ b/fs/nfs/dir.c
@@ -1538,7 +1538,9 @@ nfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry)
        d_drop(dentry);
        error = NFS_PROTO(dir)->link(inode, dir, &dentry->d_name);
        if (error == 0) {
-                atomic_inc(&inode->i_count);
+                spin_lock(&inode->i_lock);
+                inode->i_count++;
+                spin_unlock(&inode->i_lock);
                d_add(dentry, inode);
        }
        return error;
diff --git a/fs/nfs/getroot.c b/fs/nfs/getroot.c
index f90a380a6364..5b79ff1dd3a9 100644
--- a/fs/nfs/getroot.c
+++ b/fs/nfs/getroot.c
@@ -55,7 +55,9 @@ static int nfs_superblock_set_dummy_root(struct super_block *sb, struct inode *i
                        return -ENOMEM;
                }
                /* Circumvent igrab(): we know the inode is not being freed */
-                atomic_inc(&inode->i_count);
+                spin_lock(&inode->i_lock);
+                inode->i_count++;
+                spin_unlock(&inode->i_lock);
                /*
                 * Ensure that this dentry is invisible to d_find_alias().
                 * Otherwise, it may be spliced into the tree by
diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index 5f59a2df21aa..8e7fcc253e43 100644
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -396,7 +396,7 @@ nfs_fhget(struct super_block *sb, struct nfs_fh *fh, struct nfs_fattr *fattr)
        dprintk("NFS: nfs_fhget(%s/%Ld ct=%d)\n",
                inode->i_sb->s_id,
                (long long)NFS_FILEID(inode),
-                atomic_read(&inode->i_count));
+                inode->i_count);
 out:
        return inode;
@@ -1153,7 +1153,7 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
        dfprintk(VFS, "NFS: %s(%s/%ld ct=%d info=0x%x)\n",
                        __func__, inode->i_sb->s_id, inode->i_ino,
-                        atomic_read(&inode->i_count), fattr->valid);
+                        inode->i_count, fattr->valid);
        if ((fattr->valid & NFS_ATTR_FATTR_FILEID) && nfsi->fileid != fattr->fileid)
                goto out_fileid;
diff --git a/fs/nilfs2/mdt.c b/fs/nilfs2/mdt.c
index e7ed4cdd0ecf..a7dccc002a85 100644
--- a/fs/nilfs2/mdt.c
+++ b/fs/nilfs2/mdt.c
@@ -478,7 +478,7 @@ nilfs_mdt_new_common(struct the_nilfs *nilfs, struct super_block *sb,
                inode->i_sb = sb; /* sb may be NULL for some meta data files */
                inode->i_blkbits = nilfs->ns_blocksize_bits;
                inode->i_flags = 0;
-                atomic_set(&inode->i_count, 1);
+                inode->i_count = 1;
                inode->i_nlink = 1;
                inode->i_ino = ino;
                inode->i_mode = S_IFREG;
diff --git a/fs/nilfs2/namei.c b/fs/nilfs2/namei.c
index 07ba838ef089..bc9308f1d616 100644
--- a/fs/nilfs2/namei.c
+++ b/fs/nilfs2/namei.c
@@ -222,7 +222,9 @@ static int nilfs_link(struct dentry *old_dentry, struct inode *dir,
        inode->i_ctime = CURRENT_TIME;
        inode_inc_link_count(inode);
-        atomic_inc(&inode->i_count);
+        spin_lock(&inode->i_lock);
+        inode->i_count++;
+        spin_unlock(&inode->i_lock);
        err = nilfs_add_nondir(dentry, inode);
        if (!err)
diff --git a/fs/notify/inode_mark.c b/fs/notify/inode_mark.c
index bfe1d2e676fd..869f94bb040f 100644
--- a/fs/notify/inode_mark.c
+++ b/fs/notify/inode_mark.c
@@ -383,24 +383,30 @@ void fsnotify_unmount_inodes(struct list_head *list)
                 * evict all inodes with zero i_count from icache which is
                 * unnecessarily violent and may in fact be illegal to do.
                 */
-                if (!atomic_read(&inode->i_count))
+                if (!inode->i_count)
                        continue;
                need_iput_tmp = need_iput;
                need_iput = NULL;
                /* In case fsnotify_inode_delete() drops a reference. */
-                if (inode != need_iput_tmp)
+                if (inode != need_iput_tmp) {
+                        spin_lock(&inode->i_lock);
                        __iget(inode);
-                else
+                        spin_unlock(&inode->i_lock);
+                } else
                        need_iput_tmp = NULL;
                /* In case the dropping of a reference would nuke next_i. */
-                if ((&next_i->i_sb_list != list) &&
+                if (&next_i->i_sb_list != list) {
-                    atomic_read(&next_i->i_count) &&
+                        spin_lock(&next_i->i_lock);
-                    !(next_i->i_state & (I_CLEAR | I_FREEING | I_WILL_FREE))) {
+                        if (next_i->i_count &&
-                        __iget(next_i);
+                                !(next_i->i_state &
-                        need_iput = next_i;
+                                        (I_CLEAR | I_FREEING | I_WILL_FREE))) {
+                                __iget(next_i);
+                                need_iput = next_i;
+                        }
+                        spin_unlock(&next_i->i_lock);
                }
                /*
diff --git a/fs/notify/inotify/inotify.c b/fs/notify/inotify/inotify.c
index c3dd7655338b..44e90ef0b0a3 100644
--- a/fs/notify/inotify/inotify.c
+++ b/fs/notify/inotify/inotify.c
@@ -408,23 +408,28 @@ void inotify_unmount_inodes(struct list_head *list)
                 * evict all inodes with zero i_count from icache which is
                 * unnecessarily violent and may in fact be illegal to do.
                 */
-                if (!atomic_read(&inode->i_count))
+                if (!inode->i_count)
                        continue;
                need_iput_tmp = need_iput;
                need_iput = NULL;
                /* In case inotify_remove_watch_locked() drops a reference. */
-                if (inode != need_iput_tmp)
+                if (inode != need_iput_tmp) {
+                        spin_lock(&inode->i_lock);
                        __iget(inode);
-                else
+                        spin_unlock(&inode->i_lock);
+                } else
                        need_iput_tmp = NULL;
                /* In case the dropping of a reference would nuke next_i. */
-                if ((&next_i->i_sb_list != list) &&
+                if (&next_i->i_sb_list != list) {
-                                atomic_read(&next_i->i_count) &&
+                        spin_lock(&next_i->i_lock);
-                                !(next_i->i_state & (I_CLEAR | I_FREEING |
+                        if (next_i->i_count &&
-                                        I_WILL_FREE))) {
+                                !(next_i->i_state &
-                        __iget(next_i);
+                                        (I_CLEAR|I_FREEING|I_WILL_FREE))) {
-                        need_iput = next_i;
+                                __iget(next_i);
+                                need_iput = next_i;
+                        }
+                        spin_unlock(&next_i->i_lock);
                }
                /*
@@ -443,11 +448,10 @@ void inotify_unmount_inodes(struct list_head *list)
                mutex_lock(&inode->inotify_mutex);
                watches = &inode->inotify_watches;
                list_for_each_entry_safe(watch, next_w, watches, i_list) {
-                        struct inotify_handle *ih= watch->ih;
+                        struct inotify_handle *ih = watch->ih;
                        get_inotify_watch(watch);
                        mutex_lock(&ih->mutex);
-                        ih->in_ops->handle_event(watch, watch->wd, IN_UNMOUNT, 0,
+                        ih->in_ops->handle_event(watch, watch->wd, IN_UNMOUNT, 0, NULL, NULL);
-                                                 NULL, NULL);
                        inotify_remove_watch_locked(ih, watch);
                        mutex_unlock(&ih->mutex);
                        put_inotify_watch(watch);
diff --git a/fs/ntfs/super.c b/fs/ntfs/super.c
index 80b04770e8e9..3475c2e98c80 100644
--- a/fs/ntfs/super.c
+++ b/fs/ntfs/super.c
@@ -2921,7 +2921,9 @@ static int ntfs_fill_super(struct super_block *sb, void *opt, const int silent)
        }
        if ((sb->s_root = d_alloc_root(vol->root_ino))) {
                /* We increment i_count simulating an ntfs_iget(). */
-                atomic_inc(&vol->root_ino->i_count);
+                spin_lock(&vol->root_ino->i_lock);
+                vol->root_ino->i_count++;
+                spin_unlock(&vol->root_ino->i_lock);
                ntfs_debug("Exiting, status successful.");
                /* Release the default upcase if it has no users. */
                mutex_lock(&ntfs_lock);
diff --git a/fs/ocfs2/namei.c b/fs/ocfs2/namei.c
index 50fb26a6a5f5..3d4b7e210bb9 100644
--- a/fs/ocfs2/namei.c
+++ b/fs/ocfs2/namei.c
@@ -719,7 +719,9 @@ static int ocfs2_link(struct dentry *old_dentry,
                goto out_commit;
        }
-        atomic_inc(&inode->i_count);
+        spin_lock(&inode->i_lock);
+        inode->i_count++;
+        spin_unlock(&inode->i_lock);
        dentry->d_op = &ocfs2_dentry_ops;
        d_instantiate(dentry, inode);
diff --git a/fs/reiserfs/file.c b/fs/reiserfs/file.c
index da2dba082e2d..d3f9b7d05307 100644
--- a/fs/reiserfs/file.c
+++ b/fs/reiserfs/file.c
@@ -39,7 +39,7 @@ static int reiserfs_file_release(struct inode *inode, struct file *filp)
        BUG_ON(!S_ISREG(inode->i_mode));
        /* fast out for when nothing needs to be done */
-        if ((atomic_read(&inode->i_count) > 1 ||
+        if ((inode->i_count > 1 ||
             !(REISERFS_I(inode)->i_flags & i_pack_on_close_mask) ||
             !tail_has_to_be_packed(inode)) &&
            REISERFS_I(inode)->i_prealloc_count <= 0) {
@@ -94,7 +94,7 @@ static int reiserfs_file_release(struct inode *inode, struct file *filp)
        if (!err)
                err = jbegin_failure;
-        if (!err && atomic_read(&inode->i_count) <= 1 &&
+        if (!err && inode->i_count <= 1 &&
            (REISERFS_I(inode)->i_flags & i_pack_on_close_mask) &&
            tail_has_to_be_packed(inode)) {
                /* if regular file is released by last holder and it has been
diff --git a/fs/reiserfs/namei.c b/fs/reiserfs/namei.c
index 9d4dcf0b07cb..05b3240ed9ab 100644
--- a/fs/reiserfs/namei.c
+++ b/fs/reiserfs/namei.c
@@ -1151,7 +1151,9 @@ static int reiserfs_link(struct dentry *old_dentry, struct inode *dir,
        inode->i_ctime = CURRENT_TIME_SEC;
        reiserfs_update_sd(&th, inode);
-        atomic_inc(&inode->i_count);
+        spin_lock(&inode->i_lock);
+        inode->i_count++;
+        spin_unlock(&inode->i_lock);
        d_instantiate(dentry, inode);
        retval = journal_end(&th, dir->i_sb, jbegin_count);
        reiserfs_write_unlock(dir->i_sb);
diff --git a/fs/reiserfs/stree.c b/fs/reiserfs/stree.c
index 5fa7118f04e1..17f52e8bb739 100644
--- a/fs/reiserfs/stree.c
+++ b/fs/reiserfs/stree.c
@@ -1477,7 +1477,7 @@ static int maybe_indirect_to_direct(struct reiserfs_transaction_handle *th,
         ** reading in the last block.  The user will hit problems trying to
         ** read the file, but for now we just skip the indirect2direct
         */
-        if (atomic_read(&inode->i_count) > 1 ||
+        if (inode->i_count > 1 ||
            !tail_has_to_be_packed(inode) ||
            !page || (REISERFS_I(inode)->i_flags & i_nopack_mask)) {
                /* leave tail in an unformatted node */
diff --git a/fs/sysv/namei.c b/fs/sysv/namei.c
index 33e047b59b8d..d63da9be14cc 100644
--- a/fs/sysv/namei.c
+++ b/fs/sysv/namei.c
@@ -126,7 +126,9 @@ static int sysv_link(struct dentry * old_dentry, struct inode * dir,
        inode->i_ctime = CURRENT_TIME_SEC;
        inode_inc_link_count(inode);
-        atomic_inc(&inode->i_count);
+        spin_lock(&inode->i_lock);
+        inode->i_count++;
+        spin_unlock(&inode->i_lock);
        return add_nondir(dentry, inode);
 }
diff --git a/fs/ubifs/dir.c b/fs/ubifs/dir.c
index 552fb0111fff..1eed16ffdd68 100644
--- a/fs/ubifs/dir.c
+++ b/fs/ubifs/dir.c
@@ -557,7 +557,9 @@ static int ubifs_link(struct dentry *old_dentry, struct inode *dir,
        lock_2_inodes(dir, inode);
        inc_nlink(inode);
-        atomic_inc(&inode->i_count);
+        spin_lock(&inode->i_lock);
+        inode->i_count++;
+        spin_unlock(&inode->i_lock);
        inode->i_ctime = ubifs_current_time(inode);
        dir->i_size += sz_change;
        dir_ui->ui_size = dir->i_size;
diff --git a/fs/ubifs/super.c b/fs/ubifs/super.c
index 43f9d19a6f33..d020118df827 100644
--- a/fs/ubifs/super.c
+++ b/fs/ubifs/super.c
@@ -342,7 +342,7 @@ static void ubifs_delete_inode(struct inode *inode)
                goto out;
        dbg_gen("inode %lu, mode %#x", inode->i_ino, (int)inode->i_mode);
-        ubifs_assert(!atomic_read(&inode->i_count));
+        ubifs_assert(!inode->i_count);
        ubifs_assert(inode->i_nlink == 0);
        truncate_inode_pages(&inode->i_data, 0);
diff --git a/fs/udf/namei.c b/fs/udf/namei.c
index cd2115060fdc..9e85540e9e01 100644
--- a/fs/udf/namei.c
+++ b/fs/udf/namei.c
@@ -1108,7 +1108,9 @@ static int udf_link(struct dentry *old_dentry, struct inode *dir,
        inc_nlink(inode);
        inode->i_ctime = current_fs_time(inode->i_sb);
        mark_inode_dirty(inode);
-        atomic_inc(&inode->i_count);
+        spin_lock(&inode->i_lock);
+        inode->i_count++;
+        spin_unlock(&inode->i_lock);
        d_instantiate(dentry, inode);
        unlock_kernel();
diff --git a/fs/ufs/namei.c b/fs/ufs/namei.c
index 4c26d9e8bc94..ece37bbb3ea4 100644
--- a/fs/ufs/namei.c
+++ b/fs/ufs/namei.c
@@ -178,7 +178,9 @@ static int ufs_link (struct dentry * old_dentry, struct inode * dir,
        inode->i_ctime = CURRENT_TIME_SEC;
        inode_inc_link_count(inode);
-        atomic_inc(&inode->i_count);
+        spin_lock(&inode->i_lock);
+        inode->i_count++;
+        spin_unlock(&inode->i_lock);
        error = ufs_add_nondir(dentry, inode);
        unlock_kernel();
diff --git a/fs/xfs/linux-2.6/xfs_iops.c b/fs/xfs/linux-2.6/xfs_iops.c
index 225946012d0b..f78e1df5353c 100644
--- a/fs/xfs/linux-2.6/xfs_iops.c
+++ b/fs/xfs/linux-2.6/xfs_iops.c
@@ -349,7 +349,9 @@ xfs_vn_link(
        if (unlikely(error))
                return -error;
-        atomic_inc(&inode->i_count);
+        spin_lock(&inode->i_lock);
+        inode->i_count++;
+        spin_unlock(&inode->i_lock);
        d_instantiate(dentry, inode);
        return 0;
 }
diff --git a/fs/xfs/xfs_inode.h b/fs/xfs/xfs_inode.h
index ec1f28c4fc4f..53a14575bf3b 100644
--- a/fs/xfs/xfs_inode.h
+++ b/fs/xfs/xfs_inode.h
@@ -493,8 +493,10 @@ void		xfs_mark_inode_dirty_sync(xfs_inode_t *);
 #define IHOLD(ip) \
 do { \
-        ASSERT(atomic_read(&VFS_I(ip)->i_count) > 0) ; \
+        spin_lock(&VFS_I(ip)->i_lock);          \
-        atomic_inc(&(VFS_I(ip)->i_count)); \
+        ASSERT(&VFS_I(ip)->i_count > 0);        \
+        VFS_I(ip)->i_count++;                   \
+        spin_unlock(&VFS_I(ip)->i_lock);        \
        trace_xfs_ihold(ip, _THIS_IP_); \
 } while (0)
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 2c3dede519f1..659579634f9a 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -727,7 +727,7 @@ struct inode {
        struct list_head        i_sb_list;
        struct list_head        i_dentry;
        unsigned long           i_ino;
-        atomic_t                i_count;
+        unsigned int            i_count;
        unsigned int            i_nlink;
        uid_t                   i_uid;
        gid_t                   i_gid;
diff --git a/ipc/mqueue.c b/ipc/mqueue.c
index 01582e5fe998..d72c0fa15e0c 100644
--- a/ipc/mqueue.c
+++ b/ipc/mqueue.c
@@ -762,8 +762,11 @@ SYSCALL_DEFINE1(mq_unlink, const char __user *, u_name)
        }
        inode = dentry->d_inode;
-        if (inode)
+        if (inode) {
-                atomic_inc(&inode->i_count);
+                spin_lock(&inode->i_lock);
+                inode->i_count++;
+                spin_unlock(&inode->i_lock);
+        }
        err = mnt_want_write(ipc_ns->mq_mnt);
        if (err)
                goto out_err;
diff --git a/kernel/futex.c b/kernel/futex.c
index e7a35f1039e7..a6cec3270c78 100644
--- a/kernel/futex.c
+++ b/kernel/futex.c
@@ -168,7 +168,9 @@ static void get_futex_key_refs(union futex_key *key)
        switch (key->both.offset & (FUT_OFF_INODE|FUT_OFF_MMSHARED)) {
        case FUT_OFF_INODE:
-                atomic_inc(&key->shared.inode->i_count);
+                spin_lock(&key->shared.inode->i_lock);
+                key->shared.inode->i_count++;
+                spin_unlock(&key->shared.inode->i_lock);
                break;
        case FUT_OFF_MMSHARED:
                atomic_inc(&key->private.mm->mm_count);
diff --git a/mm/shmem.c b/mm/shmem.c
index eef4ebea5158..c4e04a5da5af 100644
--- a/mm/shmem.c
+++ b/mm/shmem.c
@@ -1882,7 +1882,9 @@ static int shmem_link(struct dentry *old_dentry, struct inode *dir, struct dentr
        dir->i_size += BOGO_DIRENT_SIZE;
        inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME;
        inc_nlink(inode);
-        atomic_inc(&inode->i_count);    /* New dentry reference */
+        spin_lock(&inode->i_lock);
+        inode->i_count++;       /* New dentry reference */
+        spin_unlock(&inode->i_lock);
        dget(dentry);           /* Extra pinning count for the created dentry */
        d_instantiate(dentry, inode);
 out:
diff --git a/net/socket.c b/net/socket.c
index 769c386bd428..367296ccafbe 100644
--- a/net/socket.c
+++ b/net/socket.c
@@ -368,7 +368,9 @@ static int sock_alloc_file(struct socket *sock, struct file **f, int flags)
                  &socket_file_ops);
        if (unlikely(!file)) {
                /* drop dentry, keep inode */
-                atomic_inc(&path.dentry->d_inode->i_count);
+                spin_lock(&path.dentry->d_inode->i_lock);
+                path.dentry->d_inode->i_count++;
+                spin_unlock(&path.dentry->d_inode->i_lock);
                path_put(&path);
                put_unused_fd(fd);
                return -ENFILE;