} else if (mode & S_IFDIR) {
                inode->i_op = &simple_dir_inode_operations;
                inode->i_fop = &simple_dir_operations;
-               parent->d_inode->i_nlink++;
+               inc_nlink(parent->d_inode);
        } else
                BUG();
        inode->i_private = data;
 
 
        if (mtd_ino) {
                /* Destroy the inode if it exists */
-               mtd_ino->i_nlink = 0;
+               clear_nlink(mtd_ino);
                iput(mtd_ino);
        }
 }
 
        if (inode->i_nlink > 1)
                retval = affs_remove_link(dentry);
        else
-               inode->i_nlink = 0;
+               clear_nlink(inode);
        affs_unlock_link(inode);
        inode->i_ctime = CURRENT_TIME_SEC;
        mark_inode_dirty(inode);
 
        inode->i_mapping->a_ops = (AFFS_SB(sb)->s_flags & SF_OFS) ? &affs_aops_ofs : &affs_aops;
        error = affs_add_entry(dir, inode, dentry, ST_FILE);
        if (error) {
-               inode->i_nlink = 0;
+               clear_nlink(inode);
                iput(inode);
                return error;
        }
 
        error = affs_add_entry(dir, inode, dentry, ST_USERDIR);
        if (error) {
-               inode->i_nlink = 0;
+               clear_nlink(inode);
                mark_inode_dirty(inode);
                iput(inode);
                return error;
        return 0;
 
 err:
-       inode->i_nlink = 0;
+       clear_nlink(inode);
        mark_inode_dirty(inode);
        iput(inode);
        return error;
 
        write_unlock(&entries_lock);
 
        if (dentry) {
-               dentry->d_inode->i_nlink--;
+               drop_nlink(dentry->d_inode);
                d_drop(dentry);
                dput(dentry);
                simple_release_fs(&bm_mnt, &entry_count);
 
        if (old_file->d_inode) {
                cifsInode = CIFS_I(old_file->d_inode);
                if (rc == 0) {
-                       old_file->d_inode->i_nlink++;
+                       inc_nlink(old_file->d_inode);
 /* BB should we make this contingent on superblock flag NOATIME? */
 /*                     old_file->d_inode->i_ctime = CURRENT_TIME;*/
                        /* parent dir timestamps will update from srv
 
        if (!error) {
                /* VFS may delete the child */
                if (de->d_inode)
-                   de->d_inode->i_nlink = 0;
+                       clear_nlink(de->d_inode);
 
                /* fix the link count of the parent */
                coda_dir_drop_nlink(dir);
 
 
        dentry = d_find_alias(inode);
 
-       inode->i_nlink--;
+       drop_nlink(inode);
        d_delete(dentry);
        dput(dentry);   /* d_alloc_name() in devpts_pty_new() */
        dput(dentry);           /* d_find_alias above */
 
 fail_drop:
        dquot_drop(inode);
        inode->i_flags |= S_NOQUOTA;
-       inode->i_nlink = 0;
+       clear_nlink(inode);
        unlock_new_inode(inode);
        iput(inode);
        return ERR_PTR(err);
 
 fail_drop:
        dquot_drop(inode);
        inode->i_flags |= S_NOQUOTA;
-       inode->i_nlink = 0;
+       clear_nlink(inode);
        unlock_new_inode(inode);
        iput(inode);
        brelse(bitmap_bh);
 
 
        if (err) {
 out_clear_inode:
-               inode->i_nlink = 0;
+               clear_nlink(inode);
                unlock_new_inode(inode);
                ext3_mark_inode_dirty(handle, inode);
                iput (inode);
 
 fail_drop:
        dquot_drop(inode);
        inode->i_flags |= S_NOQUOTA;
-       inode->i_nlink = 0;
+       clear_nlink(inode);
        unlock_new_inode(inode);
        iput(inode);
        brelse(inode_bitmap_bh);
 
         * Set the i_nlink to zero so it will be deleted later
         * when we drop inode reference.
         */
-       tmp_inode->i_nlink = 0;
+       clear_nlink(tmp_inode);
 
        ext4_ext_tree_init(handle, tmp_inode);
        ext4_orphan_add(handle, tmp_inode);
 
                if (new_inode) {
                        /* checked empty_dir above, can't have another parent,
                         * ext4_dec_count() won't work for many-linked dirs */
-                       new_inode->i_nlink = 0;
+                       clear_nlink(new_inode);
                } else {
                        ext4_inc_count(handle, new_dir);
                        ext4_update_dx_flag(new_dir);
 
 
        res = hfs_cat_create(inode->i_ino, dir, &dentry->d_name, inode);
        if (res) {
-               inode->i_nlink = 0;
+               clear_nlink(inode);
                hfs_delete_inode(inode);
                iput(inode);
                return res;
 
        res = hfs_cat_create(inode->i_ino, dir, &dentry->d_name, inode);
        if (res) {
-               inode->i_nlink = 0;
+               clear_nlink(inode);
                hfs_delete_inode(inode);
                iput(inode);
                return res;
 
        goto out;
 
 out_err:
-       inode->i_nlink = 0;
+       clear_nlink(inode);
        hfsplus_delete_inode(inode);
        iput(inode);
 out:
 
        res = hfsplus_create_cat(inode->i_ino, dir, &dentry->d_name, inode);
        if (res) {
-               inode->i_nlink = 0;
+               clear_nlink(inode);
                hfsplus_delete_inode(inode);
                iput(inode);
                goto out;
 
                i->i_mode &= ~0111;
                i->i_op = &hpfs_file_iops;
                i->i_fop = &hpfs_file_ops;
-               i->i_nlink = 0;*/
+               clear_nlink(i);*/
                make_bad_inode(i);
                return;
        }
 
 
        d_instantiate(path.dentry, inode);
        inode->i_size = size;
-       inode->i_nlink = 0;
+       clear_nlink(inode);
 
        error = -ENFILE;
        file = alloc_file(&path, FMODE_WRITE | FMODE_READ,
 
        dquot_drop(inode);
        inode->i_flags |= S_NOQUOTA;
 fail_unlock:
-       inode->i_nlink = 0;
+       clear_nlink(inode);
        unlock_new_inode(inode);
 fail_put:
        iput(inode);
 
        mutex_unlock(&JFS_IP(dip)->commit_mutex);
        if (rc) {
                free_ea_wmap(ip);
-               ip->i_nlink = 0;
+               clear_nlink(ip);
                unlock_new_inode(ip);
                iput(ip);
        } else {
        mutex_unlock(&JFS_IP(dip)->commit_mutex);
        if (rc) {
                free_ea_wmap(ip);
-               ip->i_nlink = 0;
+               clear_nlink(ip);
                unlock_new_inode(ip);
                iput(ip);
        } else {
        rc = txCommit(tid, 2, &iplist[0], 0);
 
        if (rc) {
-               ip->i_nlink--; /* never instantiated */
+               drop_nlink(ip); /* never instantiated */
                iput(ip);
        } else
                d_instantiate(dentry, ip);
        mutex_unlock(&JFS_IP(dip)->commit_mutex);
        if (rc) {
                free_ea_wmap(ip);
-               ip->i_nlink = 0;
+               clear_nlink(ip);
                unlock_new_inode(ip);
                iput(ip);
        } else {
        mutex_unlock(&JFS_IP(dir)->commit_mutex);
        if (rc) {
                free_ea_wmap(ip);
-               ip->i_nlink = 0;
+               clear_nlink(ip);
                unlock_new_inode(ip);
                iput(ip);
        } else {
 
 {
        int ret;
 
-       inode->i_nlink--;
+       drop_nlink(inode);
        ret = write_inode(inode);
        LOGFS_BUG_ON(ret, inode->i_sb);
        return ret;
 
        ta = kzalloc(sizeof(*ta), GFP_KERNEL);
        if (!ta) {
-               inode->i_nlink--;
+               drop_nlink(inode);
                iput(inode);
                return -ENOMEM;
        }
                abort_transaction(inode, ta);
                li->li_flags |= LOGFS_IF_STILLBORN;
                /* FIXME: truncate symlink */
-               inode->i_nlink--;
+               drop_nlink(inode);
                iput(inode);
                goto out;
        }
 
        inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME;
        ihold(inode);
-       inode->i_nlink++;
+       inc_nlink(inode);
        mark_inode_dirty_sync(inode);
 
        return __logfs_create(dir, dentry, inode, NULL, 0);
 
                /* inode->i_nlink == 0 can be true when called from
                 * block validator */
                /* set i_nlink to 0 to prevent caching */
-               inode->i_nlink = 0;
+               clear_nlink(inode);
                logfs_inode(inode)->li_flags |= LOGFS_IF_ZOMBIE;
                iget_failed(inode);
                if (!err)
 
                memset(&inode->i_ctime, 0, sizeof(inode->i_ctime));
                inode->i_version = 0;
                inode->i_size = 0;
-               inode->i_nlink = 0;
+               clear_nlink(inode);
                inode->i_uid = -2;
                inode->i_gid = -2;
                inode->i_blocks = 0;
 
 
  failed_acl:
  failed_bmap:
-       inode->i_nlink = 0;
+       clear_nlink(inode);
        iput(inode);  /* raw_inode will be deleted through
                         generic_delete_inode() */
        goto failed;
 
        }
 
        if (new_inode) {
-               new_inode->i_nlink--;
+               drop_nlink(new_inode);
                new_inode->i_ctime = CURRENT_TIME;
        }
        old_dir->i_ctime = old_dir->i_mtime = CURRENT_TIME;
        if (update_dot_dot) {
                status = ocfs2_update_entry(old_inode, handle,
                                            &old_inode_dot_dot_res, new_dir);
-               old_dir->i_nlink--;
+               drop_nlink(old_dir);
                if (new_inode) {
-                       new_inode->i_nlink--;
+                       drop_nlink(new_inode);
                } else {
                        inc_nlink(new_dir);
                        mark_inode_dirty(new_dir);
                goto leave;
        }
 
-       inode->i_nlink = 0;
+       clear_nlink(inode);
        /* do the real work now. */
        status = __ocfs2_mknod_locked(dir, inode,
                                      0, &new_di_bh, parent_di_bh, handle,
 
                inode->i_fop = &proc_sys_file_operations;
        } else {
                inode->i_mode |= S_IFDIR;
-               inode->i_nlink = 0;
+               clear_nlink(inode);
                inode->i_op = &proc_sys_dir_operations;
                inode->i_fop = &proc_sys_dir_file_operations;
        }
 
                /* a stale NFS handle can trigger this without it being an error */
                pathrelse(&path_to_sd);
                reiserfs_make_bad_inode(inode);
-               inode->i_nlink = 0;
+               clear_nlink(inode);
                return;
        }
 
        make_bad_inode(inode);
 
       out_inserted_sd:
-       inode->i_nlink = 0;
+       clear_nlink(inode);
        th->t_trans_id = 0;     /* so the caller can't use this handle later */
        unlock_new_inode(inode); /* OK to do even if we hadn't locked it */
        iput(inode);
 
                               dentry->d_name.len, inode, 1 /*visible */ );
        if (retval) {
                int err;
-               inode->i_nlink--;
+               drop_nlink(inode);
                reiserfs_update_sd(&th, inode);
                err = journal_end(&th, dir->i_sb, jbegin_count);
                if (err)
                               dentry->d_name.len, inode, 1 /*visible */ );
        if (retval) {
                int err;
-               inode->i_nlink--;
+               drop_nlink(inode);
                reiserfs_update_sd(&th, inode);
                err = journal_end(&th, dir->i_sb, jbegin_count);
                if (err)
                               dentry->d_name.len, inode, 1 /*visible */ );
        if (retval) {
                int err;
-               inode->i_nlink = 0;
+               clear_nlink(inode);
                DEC_DIR_INODE_NLINK(dir);
                reiserfs_update_sd(&th, inode);
                err = journal_end(&th, dir->i_sb, jbegin_count);
                                    dentry->d_name.len, inode, 1 /*visible */ );
        if (retval) {
                int err;
-               inode->i_nlink--;
+               drop_nlink(inode);
                reiserfs_update_sd(&th, inode);
                err = journal_end(&th, parent_dir->i_sb, jbegin_count);
                if (err)
 
        retval = journal_begin(&th, dir->i_sb, jbegin_count);
        if (retval) {
-               inode->i_nlink--;
+               drop_nlink(inode);
                reiserfs_write_unlock(dir->i_sb);
                return retval;
        }
 
        if (retval) {
                int err;
-               inode->i_nlink--;
+               drop_nlink(inode);
                err = journal_end(&th, dir->i_sb, jbegin_count);
                reiserfs_write_unlock(dir->i_sb);
                return err ? err : retval;
 
        }
 
        ubifs_assert(inode->i_nlink == 1);
-       inode->i_nlink = 0;
+       clear_nlink(inode);
        err = remove_xattr(c, host, inode, &nm);
        if (err)
                inode->i_nlink = 1;
 
 
        fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err);
        if (!fi) {
-               inode->i_nlink--;
-               mark_inode_dirty(inode);
+               inode_dec_link_count(inode);
                iput(inode);
                return err;
        }
        init_special_inode(inode, mode, rdev);
        fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err);
        if (!fi) {
-               inode->i_nlink--;
-               mark_inode_dirty(inode);
+               inode_dec_link_count(inode);
                iput(inode);
                return err;
        }
        inode->i_fop = &udf_dir_operations;
        fi = udf_add_entry(inode, NULL, &fibh, &cfi, &err);
        if (!fi) {
-               inode->i_nlink--;
-               mark_inode_dirty(inode);
+               inode_dec_link_count(inode);
                iput(inode);
                goto out;
        }
 
        fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err);
        if (!fi) {
-               inode->i_nlink = 0;
+               clear_nlink(inode);
                mark_inode_dirty(inode);
                iput(inode);
                goto out;
 
 
 fail_remove_inode:
        unlock_super(sb);
-       inode->i_nlink = 0;
+       clear_nlink(inode);
        iput(inode);
        UFSD("EXIT (FAILED): err %d\n", err);
        return ERR_PTR(err);
 
 
        d_instantiate(path.dentry, inode);
        inode->i_size = size;
-       inode->i_nlink = 0;     /* It is unlinked */
+       clear_nlink(inode);     /* It is unlinked */
 #ifndef CONFIG_MMU
        error = ramfs_nommu_expand_for_mapping(inode, size);
        if (error)