if (n < size)
                size = n;
 
-       if (XFS_FORCED_SHUTDOWN(mp)) {
+       if (XFS_FORCED_SHUTDOWN(mp))
                return -EIO;
-       }
 
        if (unlikely(ioflags & IO_ISDIRECT))
                mutex_lock(&inode->i_mutex);
                                        dmflags, &locktype);
                if (ret) {
                        xfs_iunlock(ip, XFS_IOLOCK_SHARED);
-                       goto unlock_isem;
+                       goto unlock_mutex;
                }
        }
 
 
        xfs_iunlock(ip, XFS_IOLOCK_SHARED);
 
-unlock_isem:
+unlock_mutex:
        if (unlikely(ioflags & IO_ISDIRECT))
                mutex_unlock(&inode->i_mutex);
        return ret;
        vrwlock_t               locktype;
        size_t                  ocount = 0, count;
        loff_t                  pos;
-       int                     need_isem = 1, need_flush = 0;
+       int                     need_i_mutex = 1, need_flush = 0;
 
        XFS_STATS_INC(xs_write_calls);
 
                        return XFS_ERROR(-EINVAL);
 
                if (!VN_CACHED(vp) && pos < i_size_read(inode))
-                       need_isem = 0;
+                       need_i_mutex = 0;
 
                if (VN_CACHED(vp))
                        need_flush = 1;
        }
 
 relock:
-       if (need_isem) {
+       if (need_i_mutex) {
                iolock = XFS_IOLOCK_EXCL;
                locktype = VRWLOCK_WRITE;
 
                                        S_ISBLK(inode->i_mode));
        if (error) {
                xfs_iunlock(xip, XFS_ILOCK_EXCL|iolock);
-               goto out_unlock_isem;
+               goto out_unlock_mutex;
        }
 
        new_size = pos + count;
                loff_t          savedsize = pos;
                int             dmflags = FILP_DELAY_FLAG(file);
 
-               if (need_isem)
+               if (need_i_mutex)
                        dmflags |= DM_FLAGS_IMUX;
 
                xfs_iunlock(xip, XFS_ILOCK_EXCL);
                                      dmflags, &locktype);
                if (error) {
                        xfs_iunlock(xip, iolock);
-                       goto out_unlock_isem;
+                       goto out_unlock_mutex;
                }
                xfs_ilock(xip, XFS_ILOCK_EXCL);
                eventsent = 1;
                                        isize, pos + count);
                if (error) {
                        xfs_iunlock(xip, XFS_ILOCK_EXCL|iolock);
-                       goto out_unlock_isem;
+                       goto out_unlock_mutex;
                }
        }
        xfs_iunlock(xip, XFS_ILOCK_EXCL);
                        error = -remove_suid(file->f_dentry);
                if (unlikely(error)) {
                        xfs_iunlock(xip, iolock);
-                       goto out_unlock_isem;
+                       goto out_unlock_mutex;
                }
        }
 
                                        -1, FI_REMAPF_LOCKED);
                }
 
-               if (need_isem) {
+               if (need_i_mutex) {
                        /* demote the lock now the cached pages are gone */
                        XFS_ILOCK_DEMOTE(mp, io, XFS_IOLOCK_EXCL);
                        mutex_unlock(&inode->i_mutex);
 
                        iolock = XFS_IOLOCK_SHARED;
                        locktype = VRWLOCK_WRITE_DIRECT;
-                       need_isem = 0;
+                       need_i_mutex = 0;
                }
 
                xfs_rw_enter_trace(XFS_DIOWR_ENTER, io, (void *)iovp, segs,
                        pos += ret;
                        count -= ret;
 
-                       need_isem = 1;
+                       need_i_mutex = 1;
                        ioflags &= ~IO_ISDIRECT;
                        xfs_iunlock(xip, iolock);
                        goto relock;
            !(ioflags & IO_INVIS)) {
 
                xfs_rwunlock(bdp, locktype);
-               if (need_isem)
+               if (need_i_mutex)
                        mutex_unlock(&inode->i_mutex);
                error = XFS_SEND_NAMESP(xip->i_mount, DM_EVENT_NOSPACE, vp,
                                DM_RIGHT_NULL, vp, DM_RIGHT_NULL, NULL, NULL,
                                0, 0, 0); /* Delay flag intentionally  unused */
                if (error)
                        goto out_nounlocks;
-               if (need_isem)
+               if (need_i_mutex)
                        mutex_lock(&inode->i_mutex);
                xfs_rwlock(bdp, locktype);
                pos = xip->i_d.di_size;
                        if (error)
                                goto out_unlock_internal;
                }
-       
+
                xfs_rwunlock(bdp, locktype);
-               if (need_isem)
+               if (need_i_mutex)
                        mutex_unlock(&inode->i_mutex);
 
                error = sync_page_range(inode, mapping, pos, ret);
 
  out_unlock_internal:
        xfs_rwunlock(bdp, locktype);
- out_unlock_isem:
-       if (need_isem)
+ out_unlock_mutex:
+       if (need_i_mutex)
                mutex_unlock(&inode->i_mutex);
  out_nounlocks:
        return -error;